This chapter presents preliminaries on set-theoretical notions, binary relations, linear orderings, fixpoint theory and computational complexity classes. Mainly, we provide notations for standard notions rather than giving a thorough introduction to these notions. More definitions are provided in the book, and we invite the reader to consult textbooks on these subjects for further information. For instance, in Moschovakis (2006) any reader can find material about set-theoretical notions, ordinals or fixpoints far beyond what is sketched in this chapter. Still, we implicitly assume that the reader has basic set-theoretic background. As stated already in Chapter 1, we do not intend to teach this material here but rather to recall the most basic notions, terminology and notation. The current chapter is included for the convenience of the reader as a quick reference.

Structure of the chapter. The chapter is divided into two sections. The first section contains standard material on sets and relations. Section 2.1.1 presents standard set-theoretical notions that are used throughout the book. Binary relations are ubiquitous structures in this volume, and Section 2.1.2 is dedicated to standard definitions about them. In Section 2.1.3, we provide basic definitions about partial and linear orders.

The second section contains material that is more specialised and needed for the development of a theory of and algorithms for temporal logics. Section 2.2.1 presents the basics of fixpoint theory; Chapter 8, which deals with the modal μ-calculus with fixpoint operators, uses some of the results stated herein. In Section 2.2.2, we recall standard complexity classes defined via deterministic and nondeterministic time- and space-bounded Turing machines. Other classes, in particular involving alternating Turing machines, are discussed in Chapter 11. Section 2.2.3 provides an introduction to 2-player zero-sum games of perfect information that are useful, for instance, in defining the game-theoretic approach to temporal logics.

Sets and Relations

Operations on Sets

Throughout this book we use the standard notations for set-theoretical notions:membership (∈), inclusion (⊆), strict (or proper) inclusion (⊂), union of sets (∪), intersection of sets (∩), difference of sets (\) and product of sets (×). The empty set is denoted by ∅.

This fourth and last part of the book provides algorithmic methods for the main decision problems that come with temporal logics: satisfiability, validity and model checking. Model checking is typically easier, particularly for branching-time logics, and therefore admits simpler solutions that have been presented in the chapters of Part II already. Since temporal logics are usually closed under complementation, satisfiability and validity are very closely related and methods dealing with one of them can easily be used to solve the other, so we will not consider them separately. Indeed, in order to check a formula φ for validity, one can check ¬φ for satisfiability and invert the result since φ is valid iff ¬φ is unsatisfiable. Satisfiability is reducible to validity likewise. Furthermore, a satisfiability-checking procedure would typically yield not only the answer but also, in the positive case, a model witnessing the satisfiability of the input formula. Such an interpreted transition system would refute validity of ¬φ, i.e. be a countermodel for its validity. Hence, the focus of this part is on satisfiability checking.

The methods presented here are closely linked to Chapter 11, which provided lower bounds on the computational complexity of these decision problems, i.e. it explained how difficult these problems are from a computational perspective. The following chapters provide themissing halves to an exact analysis of temporal logics’ computational complexities: by estimating the time and space consumption that these methods need in order to check for satisfiability, satisfaction, etc., we obtain upper bounds on these decision problems. Thus, while Chapter 11 showed how hard at least these problems are, the following chapters show how hard they are at most, by presenting concrete algorithmic solutions for these decision problems.

The methods presented in the following three chapters are in fact methodologies in the sense that each chapter introduces a particular framework for obtaining methods for certain temporal logics. Each of these frameworks – tableaux, automata and games – has its own characteristics, strengths and weaknesses and may or may not be particularly suited for particular temporal logics. Axiomatic systems, presented in the respective chapters of Part II, provide an alternativemethodology that historically appeared first, but they can only be used to establish validity (resp. nonsatisfiability) when it is the case, and provide no answer otherwise, so they are not really decision methods.

This chapter is a brief introduction to the basic multimodal logic BML, interpreted as the simplest natural temporal logic for reasoning about transition systems. Indeed, transition systems are nothing but Kripke frames and interpreted transition systems are simply Kripke models, so a standard Kripke semantics is provided for a multimodal language with modal operators □ a and ◊ a, associated with each transition relation Ra. These bear natural meaning in interpreted transition systems, stating what must be true in all /respectively, what may be true at some/ Ra-successors of the current state. In order to emphasise these readings of the modal operators, we will use a notation that is unusual for modal logic, but is more suitable in the context of temporal logics: AX a (read as for all paths starting from the current state, at the next state) and EX a (for some path starting from the current state, at the next state). Thus, BML is the minimal natural logical language to specify local properties of transition systems.

Since the chapter is written from the primary perspective of transition systems, rather than from modal logic perspective, we have put an emphasis on certain topics such as expressiveness, bisimulation, model checking, the finite model property and deciding satisfiability, while other fundamental topics in modal logic – such as deductive systems and proof theory, model theory, correspondence theory, algebraic semantics and duality theory – are almost left untouched here. Of all deductive systems developed for modal logics we only mention the axiomatic system for BML here and present a version of the tableaubased method for it in Chapter 13; for the rest we only provide basic references in the bibliographic notes.

This chapter can also be viewed as a stepping stone towards the more expressive and interesting temporal logics that are presented further.

Structure of this chapter. Section 5.1 presents the syntax and semantics for BML. The relational translation from BML into first-order logic (FO) is also presented emphasising the fact that BML can be viewed as a fragment of classical first-order predicate logic. Section 5.2 presents some techniques for renaming and transformation of BML formulae to equisatisfiable ones in certain normal form of modal depth two.

We have noted that the basic modal logic BML suffers from the deficiency of not being able to make assertions about connectivity, i.e. every BML formula can only ‘look’ up to a certain depth into a transition system. This is of course not enough for many purposes, and this is why richer formalisms like reachability logic TLR and the computation tree logic CTL have been introduced. As we demonstrated in Chapter 7, these logics possess temporal operatorswhich directly translate such assertions into the syntax of a logic. As we showed in Section 7.1.5, all temporal operators in CTL added on top of BML have simple and elegant characterisations in terms of least or greatest fixpoint solutions to certain equations.

The modal μ-calculus Lμ uses this idea as a general principle in order to add expressive power to the basic modal logic BML. It only features two additional syntactic constructs: a least and a greatest fixpoint operator. Thus, it differs from the other logics studied here in the way that the fixpoint character of a formula is being made explicit in it. This has pros and cons: it allows any least or greatest fixpoint solution of an equation expressed with basic modal logic to be defined; on the other hand this results in a far less intuitive syntax of the logic when compared to the other temporal logics.

These two aspects determine the role that the modal μ-calculus plays in the world of temporal logics. The generic use of fixpoint quantifiers gives it a relatively high expressive power. Many other temporal logics can be embedded into themodal μ-calculus. The explicit use of fixpoint quantifiers come with a generic instruction for doing model checking using fixpoint iteration. Such algorithms can then be specialised to the embedded temporal logics. Thus, the modal μ-calculus is often called the backbone of temporal logics.

Structure of the chapter. In Section 8.1 we start by introducing the concept of fixpoint quantification which leads to the formal logic called the modal μ-calculus. Early on we show that it can embed CTL simply because this translation is helpful in understanding the use of fixpoint quantifiers for the specification of temporal behaviour.

The transitions in the transition systems that we have studied so far are primitive and abstract objects. The nature of the possible transitions between states and the mechanisms that generate and determine them have not been essential in the context of the linear and branching time temporal logics we have studied in the previous chapters.

Here we introduce and study a more involved type of transition system, called concurrent game structures, for modelling scenarios that typically arise in open or multiagent systems. An open system is a system (computer, device, agent) interacting with an environment. The properties and behaviour of such open systems can be modelled by 2-player games. More generally, a multiagent system may involve several interacting (possibly, cooperating or competing) agents, each pursuing their own goals or acting randomly (like nature or the environment). Concurrent game structures are special types of multiagent transition systems, where the transitions are determined by tuples of simultaneous actions performed by a fixed set of agents. Various logical formalisms extending linear and branching-time temporal logics can be used for the specification, verification and reasoning about dynamic properties of open and multiagent systems.

In this chapter we present and study concurrent game structures as models for the family of so-called alternating-time temporal logics. They are themost popular and influential logics for strategic reasoning in multiagent systems and are multiagent versions of branchingtime temporal logics which correspond to closed or single-agent systems in a sense that we will discuss in the chapter.

Structure of the chapter. We introduce concurrent multiagent transition systems and models in Section 9.1 and then the logics ATL* and ATL in Section 9.2.We then discuss model checking and satisfiability testing for these logics in Section 9.3. As usual, the chapter ends with exercises and bibliographic notes.

Concurrent Multiagent Transition Systems

Concurrent Game Structures and Models

We begin with a motivating example. Figure 9.1 depicts two transition systems. The one on top involves two robots, Robot1 and Robot2, and a carriage. There are three different positions of the carriage, denoted by states s0, s1 and s2. Each robot has two possible actions at any of the states: push and wait. Robot1 can only push the carriage in clockwise direction, whereas Robot2 can only push it in anticlockwise direction.