28 results
Temporal Logics
- Valentin Goranko
-
- Published online:
- 08 September 2023
- Print publication:
- 05 October 2023
-
- Element
- Export citation
-
Temporal Logics are a rich variety of logical systems designed for formalising reasoning about time, and about events and changes in the world over time. These systems differ by the ontological assumptions made about the nature of time in the associated models, by the logical languages involving various operators for composing temporalized expressions, and by the formal logical semantics adopted for capturing the precise intended meaning of these temporal operators. Temporal logics have found a wide range of applications as formal frameworks for temporal knowledge representation and reasoning in artificial intelligence, and as tools for formal specification, analysis, and verification of properties of computer programs and systems. This Element aims at providing both a panoramic view on the landscape of the variety of temporal logics and closer looks at some of their most interesting and important landmarks.
APPROXIMATING TREES AS COLOURED LINEAR ORDERS AND COMPLETE AXIOMATISATIONS OF SOME CLASSES OF TREES
- Part of
- RUAAN KELLERMAN, VALENTIN GORANKO
-
- Journal:
- The Journal of Symbolic Logic / Volume 86 / Issue 3 / September 2021
- Published online by Cambridge University Press:
- 08 June 2021, pp. 1035-1065
- Print publication:
- September 2021
-
- Article
- Export citation
-
We study the first-order theories of some natural and important classes of coloured trees, including the four classes of trees whose paths have the order type respectively of the natural numbers, the integers, the rationals, and the reals. We develop a technique for approximating a tree as a suitably coloured linear order. We then present the first-order theories of certain classes of coloured linear orders and use them, along with the approximating technique, to establish complete axiomatisations of the four classes of trees mentioned above.
LOGICS FOR PROPOSITIONAL DETERMINACY AND INDEPENDENCE
- VALENTIN GORANKO, ANTTI KUUSISTO
-
- Journal:
- The Review of Symbolic Logic / Volume 11 / Issue 3 / September 2018
- Published online by Cambridge University Press:
- 02 April 2018, pp. 470-506
- Print publication:
- September 2018
-
- Article
- Export citation
-
This paper investigates formal logics for reasoning about determinacy and independence. Propositional Dependence Logic ${\cal D}$ and Propositional Independence Logic ${\cal I}$ are recently developed logical systems, based on team semantics, that provide a framework for such reasoning tasks. We introduce two new logics ${{\cal L}_D}$ and ${{\cal L}_{\,I\,}}$, based on Kripke semantics, and propose them as alternatives for ${\cal D}$ and ${\cal I}$, respectively. We analyse the relative expressive powers of these four logics and discuss the way these systems relate to natural language. We argue that ${{\cal L}_D}$ and ${{\cal L}_{\,I\,}}$ naturally resolve a range of interpretational problems that arise in ${\cal D}$ and ${\cal I}$. We also obtain sound and complete axiomatizations for ${{\cal L}_D}$ and ${{\cal L}_{\,I\,}}$.
References
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 716-736
-
- Chapter
- Export citation
2 - Preliminaries and Background I
- from PART I - MODELS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 17-34
-
- Chapter
- Export citation
-
Summary
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 ∅.
12 - Frameworks for Decision Procedures
- from PART IV - METHODS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 467-475
-
- Chapter
- Export citation
-
Summary
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.
5 - Basic Modal Logics
- from PART II - LOGICS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 100-149
-
- Chapter
- Export citation
-
Summary
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: AXa (read as for all paths starting from the current state, at the next state) and EXa (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.
8 - The Modal Mu-Calculus
- from PART II - LOGICS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 271-328
-
- Chapter
- Export citation
-
Summary
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.
9 - Alternating-Time Temporal Logics
- from PART II - LOGICS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 329-358
-
- Chapter
- Export citation
-
Summary
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.
PART II - LOGICS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 83-84
-
- Chapter
- Export citation
PART I - MODELS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 15-16
-
- Chapter
- Export citation
14 - The Automata-Based Approach
- from PART IV - METHODS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 543-624
-
- Chapter
- Export citation
-
Summary
In this chapter we present the automata-based approach for a variety of temporal logics and classes of automata and compare the advantages and the drawbacks of the different constructions. We do not always aim at optimal complexity upper bounds but also take other criteria into account. This is not a chapter on automata theory but rather a chapter on automata for temporal logics. We focus our attention on reductions of decision problems for temporal logics into decision problems on automata instead of in-depth treatment of automata. References are provided, as usual, as bibliographical notes.
As already discussed in Section 1.1.3, the automata-based approach consists of reducing logical problems to automata-based decision problems in order to take advantage of known results and decision procedures from automata theory. The notion of models for logical formulae is substituted by the notion of words or trees accepted by automata (or any other type of structures accepted by automata). The correspondence between formulae and automata, which underlines the difference between a declarative statement (a formula) and an operational device (an automaton), allows to reduce many logical problems, viz.:
• satisfiability of a formula φ (i.e. existence of a model for φ) reduces to checking nonemptiness of an automaton Aφ (i.e. existence of a word/tree accepted by Aφ) by using a map between models and, respectively, words or trees;
• validity of a formula φ (i.e. truth of φ is all models) reduces to checking universality of an automaton Aφ (i.e. checking whether Aφ accepts all words/trees);
• entailment of one formula φ by another formula ψ reduces to checking whether all what is accepted by the automaton Aφ is also accepted by the automaton Aψ (the inclusion problem).
The idea in a nutshell: the automata considered here are not Turing-complete and have restricted computational power and decidable decision problems, so logical decision problems can be reduced to respective automata-based decision problems for which algorithms exist. This is all the magic around this approach to solve logical decision problems: design a reduction and then rely on automata-based decision procedures.Alternatively, this approach can be viewed as a means to solving logical decision problems by using a class of devices with limited computational power, i.e. automata. This is why it helps to better understand their computational power.
11 - Computational Complexity
- from PART III - PROPERTIES
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 419-464
-
- Chapter
- Export citation
-
Summary
This chapter is devoted to the study of the computational complexity of the standard decision problems – satisfiability, validity and model checking – for temporal logics that have been introduced earlier.
Complexity theory is the classification of problems according to the resources needed to solve (or define) them, not just the resources needed to run a particular algorithm for a given problem. This classification leads to a hierarchy of complexity classes, the important ones have been recalled in Section 2.2.2. Our general aim is, of course, to pinpoint the exact location of a given decision problem for any given temporal logic within this hierarchy. The purpose of this chapter, though, is to focus on lower bounds on these positions.
A decision problem, like the satisfiability problem for LTL, for instance, is classified in a complexity-theoretic sense when matching lower and upper bounds have been found. Upper bounds are often given by the analysis of the resource consumption of a particular algorithm for that problem. Part IVof this book presents different methodologies that can be used to solve these problems for temporal logics. Tight upper bounds on their complexities will be established there. The developments in this chapter underline the notion of optimal complexity used in previous chapters: that no algorithm with considerably less resource consumption can be found for the underlying problem (unless such algorithms could be found for an entire class of problems).
The concept of lower bound is easy to grasp when the complexity hierarchy is not seen as a system measuring absolute but relative values; the complexity of a decision problem is measured by relating it to the complexity of other decision problems. A lower bound of a complexity class C is then simply to be understood as ‘this problem is (provably) as difficult as all problems in the class C’. Difficulty is, of course, measured in a formal way, meaning that one would be able to find better algorithms for all problems in class C if one could find a better algorithm for that particular problem. This decision problem is then said to be C-hard.
PART III - PROPERTIES
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 359-360
-
- Chapter
- Export citation
6 - Linear-Time Temporal Logics
- from PART II - LOGICS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 150-208
-
- Chapter
- Export citation
-
Summary
Linear-time temporal logics formalise reasoning about single computations in transition systems, represented by linear models over natural numbers, that is, infinite sequences of states of length ω. With linear-time formulae one can specify a rich variety of important properties of infinite computations; not only local ones, like BML, but also related to their limit behaviour, such as safety, liveness or fairness. In fact, a classical result by Hans Kamp implies that the most popular linear-time logic LTL, which will be introduced and studied in this chapter, is as expressive as first-order logic on single computations Kamp (1968).
Alinear-time formula is normally used in order to specify a property for all computations in a given interpreted transition system, reflecting the view of a program as the collection of all its possible executions. This means that LTL cannot express basic branching-time properties, so the expressiveness of LTL on nonlinear transition systems is incomparable to the one of BML (see Chapter 10).
In this chapter we present and study the linear-time logic LTL and some of its most interesting extensions: with past-time operators, automata-based operators, propositional quantification, etc. We will focus on the logical and computational properties of these logics, viz. their semantics, expressiveness, model checking and testing of satisfiability and validity. We will establish the fundamental ultimately periodic model property of LTL: every satisfiable formula of that logic is satisfiable in an ultimately periodic linear model, that is, in a computation that, after a certain initial segment, starts repeating forever. Moreover, effective upper bounds, in the worst-case exponential in the length of the formula, can be computed for the length of both the initial segment and the period. Thus, the ultimately periodicmodel property implies decidability of the satisfiablity (and, hence, of validity, too) in LTL and provides a decision method for that problem. Eventually, that method can be refined and transformed into an optimal decision procedure which will be presented here. Alternative decision procedures, essentially using the same property but based respectively on tablehis chapter we present and study the linear-time logic LTL and some of its most interesting extensions: with past-time operators, automata-based operators, propositional quantification, etc.
13 - Tableaux-Based Decision Methods
- from PART IV - METHODS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 476-542
-
- Chapter
- Export citation
-
Summary
The underlying idea of the method of semantic tableaux for testing satisfiability of logical formulae is to organise a systematic search for a satisfyingmodel of the input formula, or set of formulae. Both the entire procedure and the search tree itself are usually called ‘tableau’. The tableau search follows the logical structure of the formulae to be satisfied and consists of repeated application of specific formula decomposition rules associated with the logical connectives in the given logical language. If the search for a satisfying model terminates without success, the tableau is pronounced ‘closed’ and the input set of formulae is declared unsatisfiable. If the tableau method is sound, closure of the tableau search must imply that the input set of formulae is indeed unsatisfiable. If the search succeeds, or never terminates, the tableau is pronounced ‘open’. If the input is not satisfiable, a complete tableau procedure is supposed to terminate and establish that the input is not satisfiable, indeed.
Traditionally tableaux are regarded as logical deductive systems, built in a formal, declarative, rule-based manner. Tableaux for classical logic use only local decomposition rules, while tableaux for modal and temporal logics also involve successor rules and in the traditional versions both types of rules are treated on a par and the control mechanisms are built in as provisos for the application of these rules. While soundness and completeness are sine qua non, termination is not a common requirement. Indeed, in case of logics with undecidable but recursively axiomatisable validity, such as first-order logic, a sound and complete tableau cannot be always terminating, so it can only be used as a deductive system, but not as a decision procedure. In this book we use tableaux as decision procedures, hence in our context termination is a requirement that is as essential as soundness and completeness. Moreover, if a tableau-based search terminates successfully (as open tableau) it usually provides sufficient information to build a model satisfying the input. Thus, a sound, complete and always terminating tableau for a given logic provides not only a decision procedure for testing satisfiability (respectively, validity) in it, but also a constructive method for model building, whenever a model for the input set of formulae exists.
7 - Branching-Time Temporal Logics
- from PART II - LOGICS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 209-270
-
- Chapter
- Export citation
-
Summary
In the previous two chapters we presented temporal logics for reasoning about local properties of interpreted transition systems (BML) and about global properties of linear time models, that is, single computations (LTL). Neither of these, however, is expressive enough to reason about global properties of all computations in the transition system. This is where branching-time temporal logics come into play. They combine the full repertoire of temporal operators of LTL, on one hand, with the ability to quantify over paths, and hence over computations, starting at the current state.
The temporal operators X and U of LTL navigate forwards along a particular run and express global properties about it. Thus, LTL is suited for reasoning about single computations in a transition system, but does not provide any syntactic means to look at alternative runs in the system. On the other hand, BML provides the means to look at all immediate successors of the current state, but not any further. So, the idea of the branching-time framework is to put temporal operators and path quantifiers together and enable global reasoning about all possible computations starting from a given state, and eventually about what happens in the entire transition system. In particular, the path quantification can be regarded as a generalisation of both existential and universal model checking in LTL, but it also enables much more, viz. any Boolean combination of both, as well as iterating these by nesting path quantifiers. In the simplest cases of interaction between path quantifiers and temporal operators, these are required to alternate strictly and that restriction generates the simplest natural branching-time logics TLR and CTL which we study here. Gradually extending the admissible patterns of combinations of temporal and Boolean operators over what patterns of path quantification is allowed produces a growing hierarchy of more expressive logics, eventually leading to the fully unrestricted language of the branching-time logic CTL*.
We present in this chapter the most popular species of branching-time logics and discuss and compare their expressiveness. Nevertheless, the proofs about expressiveness results are deferred to Chapter 10 that is exclusively dedicated to those questions.
PART IV - METHODS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 465-466
-
- Chapter
- Export citation
10 - Expressiveness
- from PART III - PROPERTIES
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 361-418
-
- Chapter
- Export citation
-
Summary
A formula of a temporal logic expresses a temporal property of interpreted transition systems, for instance in order to specify formally some wanted or some unwanted behaviour of the system. With several logics at hand, a natural question arises that has already been introduced in Chapter 7 with the definition of several syntactic fragments of CTL*: what are the properties that can be formalised in a particular logic? And which ones cannot be formalised? The first question is answered, in a way, by all formulae of that logic, but this answer is pretty much useless for getting an idea of what is possible with that logic. A better way to address these questions is to look at the whole picture of all temporal logics. We can naturally compare two logics L1 and L2 by asking whether every property that is formalisable in L1 can also be formalised in L2. It is easily seen that this yields a preorder on all temporal logics of the same kind, for example all linear-time temporal logics or all branching-time temporal logics. Note that a temporal property can be identified with the class of (rooted) interpreted transition systems that possess this property. Thus, a formula from one logic being expressible by a formula in another logic simply amounts to the two formulae being equivalent in the usual logical sense, i.e. having the same families of models. For linear-time logics this is a family of computation paths, while for branching-time logics it is a family of rooted interpreted transition systems.
A careful analysis of what is possible in which logic should thus give us two hierarchies, of linear-time logics and of branching-time logics.Obviously, itwould be nice to unify them in one big picture which shows the expressive power of every temporal logic. For this we need to be able to compare a linear-time and a branching-time logic, and this can be done by regarding the former as a latter with implicit quantification over computation paths. When we identify a linear-time formula φ with the branching-time property Aφ or Eφ then we should be able to study the relative expressive power of all temporal logics in one big picture.
3 - Transition Systems
- from PART I - MODELS
- Stéphane Demri, Centre National de la Recherche Scientifique (CNRS), Paris, Valentin Goranko, Stockholms Universitet, Martin Lange, Universität Kassel, Germany
-
- Book:
- Temporal Logics in Computer Science
- Published online:
- 13 October 2016
- Print publication:
- 13 October 2016, pp 35-82
-
- Chapter
- Export citation
-
Summary
Transition systems are widely used to model computer programs and systems. They consist of states, representing possible configurations, and transitions, representing possible state changes. Such changes may be governed by an action induced by the system itself or by an external event. This is a fundamental model to define the semantics of computer systems or abstract computational devices such as finite statemachines, pushdown systems, Turing machines, counter machines, timed automata, etc. Besides, many other models of sequential, parallel, reactive and interactive processes and computations, such as Petri nets, process calculi such as CCS and CSP, etc., can naturally be recast as transition systems.
Transition systems are mathematically quite simple, as they can be viewed as (possibly infinite) directed graphs with labels on vertices or on edges. Yet, theoretical tools developed for them have allowed striking breakthroughs to be made for software verification, in particular due to the approach of verification by model checking.
In the context of this book, transition systems appear in two capacities: as object of primary interest and study, in Part I of the book, and as models for the temporal logics which we will study further. A real system can be modelled by different abstract transition systems and in different levels of detail. It is therefore important to have precise criteria whether a given abstract model faithfully captures the formally specified behaviour of the given real transition system. For that it is necessary to have a precise notion of behaviour of a transition system, so later in this chapter we also address the question:
When should two transition systems be considered to be behaviourally equivalent?
This question does not have a unique answer, as the notion of equivalence depends on the behavioural features of transition systems that are considered of importance for the real systems they model. Such features may involve local behaviour (pre- and postconditions), generated paths and computations, as well as reachability, safety, liveness, fairness, etc., types of system properties. Accordingly, a variety of natural notions of behavioural equivalence arise. We will concentrate on two of them – bisimilarity and trace equivalence – because they are inherently linked to the notion of logical equivalence.