Abstract

This chapter provides an introduction to graph searching games, a form of one- or two-player games on graphs that have been studied intensively in algorithmic graph theory. The unifying idea of graph searching games is that a number of searchers wants to find a fugitive on an arena defined by a graph or hypergraph. Depending on the precise definition of moves allowed for the searchers and the fugitive and on the type of graph the game is played on, this yields a huge variety of graph searching games.

The objective of this chapter is to introduce and motivate the main concepts studied in graph searching and to demonstrate some of the central ideas developed in this area.

Introduction

Graph searching games are a form of two-player games where one player, the Searcher or Cop, tries to catch a Fugitive or Robber. The study of graph searching games dates back to the dawn of mankind: running after one another or after an animal has been one of the earliest activities of mankind and surely our hunter-gatherer ancestors thought about ways of optimising their search strategies to maximise their success.

Game playing is a powerful metaphor that fits many situations where interaction between autonomous agents plays a central role. Numerous tasks in computer science, such as design, synthesis, verification, testing, query evaluation, planning, etc. can be formulated in game-theoretic terms. Viewing them abstractly as games reveals the underlying algorithmic questions, and helps to clarify relationships between problem domains. As an organisational principle, games offer a fresh and intuitive way of thinking through complex issues.

As a result mathematical models of games play an increasingly important role in a number of scientific disciplines and, in particular, in many branches of computer science. One of the scientific communities studying and applying games in computer science has formed around the European Network ‘Games for Design and Verification’ (GAMES), which proposes a research and training programme for the design and verification of computing systems, using a methodology that is based on the interplay of finite and infinite games, mathematical logic and automata theory.

This network had initially been set up as a Marie Curie Research Training Network, funded by the European Union between 2002 and 2006. In its four years of existence this network built a strong European research community that did not exist before. Its flagship activity – the annual series of GAMES workshops – saw an ever-increasing number of participants from both within and outside Europe. The ESF Research Networking Programme GAMES, funded by the European Science Foundation ESF from 2008 to 2013, builds on the momentum of this first GAMES network, but it is scientifically broader and more ambitious, and it covers more countries and more research groups.

This book addresses the broad community of researchers in various fields who use relations in their scientific work. Relations occur or are used in such diverse areas as psychology, pedagogy, social choice theory, linguistics, preference modelling, ranking, multicriteria decision studies, machine learning, voting theories, spatial reasoning, data base optimization, and many more. In all these fields, and of course in mathematics and computer science, relations are used to express, to model, to reason, and to compute with. Today, problems arising in applications are increasingly handled using relational means.

In some of the above mentioned areas it sometimes looks as if the wheel is being reinvented when standard results are rediscovered in a new specialized context. Some areas are highly mathematical, others require only a moderate use of mathematics. Not all researchers are aware of the developments that relational methods have enjoyed in recent years.

A coherent text on this topic has so far not been available, and it is intended to provide one with this book. Being an overview of the field it offers an easy start, that is nevertheless theoretically sound and up to date. It will be a help to scientists even if they are not overly versed in mathematics but have to apply it. The exposition does not stress the mathematical side too early. Instead, visualizations of ideas – mainly via matrices but also via graphs – are presented first, while proofs during the early introductory chapters are postponed to an appendix.

So far we have concentrated on the foundations of relational mathematics. Now we switch to applications. A first area of applications concerns all the different variants of orderings as they originated in operations research: weakorders, semiorders, intervalorders, and block-transitive orderings. With the Scott-Suppes Theorem in relational form as well as with the study of the consecutive 1s property, we here approach research level.

The second area of applications concerns modelling preferences with relations. The hierarchy of orderings is considered investigating indifference and incomparability, often starting from so-called preference structures, i.e., relational outcomes of assessment procedures. A bibliography on early preference considerations is contained in [2].

The area of aggregating preferences with relations, studied as a third field of applications, is relatively new. It presents relational measures and integration in order to treat the trust and belief of the Dempster–Shafer Theory in relational form. In contrast, the fuzzy approach is well known, with the coeficients of matrices stemming from the real interval [0, 1]; it comes closer and closer to relational algebra proper. In the present book, a direct attempt is made. Also t-norms and De Morgan triples can be generalized to a relational form.

Part I starts by recalling more or less trivial facts on sets, their elements or subsets, and relations between them. It is rather sketchy and will probably be uninteresting for literate scientists such as mathematicians and/or logicians.

Sets, elements, subsets, and relations can be represented in different ways. We will give hints to the programmer how to work with concrete relations and put particular emphasis on methods for switching from one form to another. Such transitions may be achieved on the representation level; they may, however, also touch a higher relation-algebraic level which we hide at this early stage.

We are going to recall how a partition is presented, or a permutation. Permutations may lead to a different presentation of a set or of a relation on or between sets. Functions between sets may be given in various forms, as a table, as a list, or in some other form. A partition may reduce the problem size when factorizing according to it. We show how relations emerge. This may be simply by writing down a matrix, or by abstracting with a cut from a real-valued matrix. For testing purposes, the relation may be generated randomly.

There is a clash in attitudes and expectations between mathematicians and information engineers. While the first group is interested in reasoning about properties, the second aims at computing and evaluating around these properties and thus tries to have the relations in question in their hands.

Typechecking is a static analysis on programs that enables the detection of potential dynamic type errors. Since it is already a standard technique in programming languages and since XML's schemas are analogous to data types in programming languages, we might expect existing typechecking techniques to be usable also for the verification of XML processing programs. However, a concrete analysis algorithm must be renewed entirely since schemas have a mathematical structure completely different from conventional data types. In this chapter, we first overview various approaches to XML typechecking and then consider, as a case study, a core of the XDuce type system in detail.

Compact taxonomy

Since the aim of typechecking is the rejection of possibly incorrect programs, it is a language feature clearly visible to the user. Therefore, in constructing a typechecker we must take into account not only the internal analysis algorithm but also the external specification, which further influences the design of the whole language.

The first design consideration is the kind of type error that should be detected. That is, what sort of type error should be raised from a program in the target language? The most typical kind of error occurs when the final result does not conform to the specified “output type.” However, some languages also check intermediate results against types. For example, the XDuce language has a pattern match facility, according to which a match error occurs when a form of conformance test on an intermediate result fails (Section 5.1).