Branching-time Logic Research Articles

Completeness of a Branching-Time Logic with Possible Choices

In this paper we present BTC, which is a complete logic for branchingtime whose modal operator quantifies over histories and whose temporal operators involve a restricted quantification over histories in a given possible choice. This is a technical novelty, since the operators of the usual logics for branching-time such as CTL express an unrestricted quantification over histories and moments. The value of the apparatus we introduce is connected to those logics of agency that are interpreted on branching-time, as for instance Stit Logics.

Branching-Time Model-Checking of Probabilistic Pushdown Automata

In this paper we study complexity of the model-checking problem for probabilistic pushdown automata (pPDA) and qualitative fragments of two branching-time logics PCTL* and PECTL*. We prove tha this problem is in 2-EXPTIME for pPDA and qualitative PCTL*. Consequently, we prove that model-checking of stateless pPDA (pBPA) and both qualitative PCTL* and qualitative PECTL* is 2-EXPTIME-hard. These results combined with results of several other papers give us that the model-checking problem for pPDA (and also for pBPA) and both qualitative PCTL* and qualitative PECTL* is 2-EXPTIME-complete. Finally, we survey known results on model-checking of pPDA and branching-time logics.

An Automata-based Approach for CTL⋆ With Constraints

We introduce a general definition for a family of branching-time logics that extend CTL* by allowing constraints between variables at the atomic level. These constraints allow to compare values of variables at different states of the model. We define an automata-theoretic approach to solve verification problems for such extensions. Our method is based on a finite abstraction of the infinite state space and a symbolic representation of the models that generalizes several approaches used for extensions of the linear-time logic LTL with constraints. We extend and combine several constructions involving alternating tree automata. We apply this approach to prove decidability and optimal complexity results for particular instances of CTL* extensions whenever an abstraction of the models verifying a “nice” property can be computed. These theoretical results generalize several results on LTL with constraints where such nice abstractions are used.

Model Checking Merged Program Traces

During a program's execution, state information can be collected and stored in the form of program traces. With such traces, one can analyze dynamic properties of the program. In this paper, we consider the problem of merging multiple traces from the same program in order to compose an approximate temporal model of its behavior. With such a model one can perform model checking based on both linear- and branching-time logics. To this end, we formally define what we mean by program trace and present some algorithms to perform trace merging. We show that each of these algorithms yield a different kind of temporal model, appropriate for different kinds of analyses. Our method is motivated by the possibility of analyzing simulations in a way that has not been done so far, and thus is developed with the needs of such a domain in mind. To demonstrate the practical feasibility of the proposed theoretical approach, we explain how to actually perform model checking of our temporal models using the NuSMV tool. Moreover, we provide proof-of-concept Java implementations of the proposed trace merging algorithms, which output NuSMV specifications. We also describe a simple case study using this implementation.

Branching-Time Logics Repeatedly Referring to States

While classical temporal logics lose track of a state as soon as a temporal operator is applied, several branching-time logics able to repeatedly refer to a state have been introduced in the literature. We study such logics by introducing a new formalism, hybrid branching-time logics, subsuming the other approaches and making the ability to refer to a state more explicit by assigning a name to it. We analyze the expressive power of hybrid branching-time logics and the complexity of their satisfiability problem. As main result, the satisfiability problem for the hybrid versions of several branching-time logics is proved to be 2EXPTIME-complete. To prove the upper bound, the automata-theoretic approach to branching-time logics is extended to hybrid logics. As a result of independent interest, the nonemptiness problem for alternating one-pebble Buchi tree automata is shown to be 2EXPTIME-complete. A common property of the logics studied is that they refer to only one state. This restriction is crucial: The ability to refer to more than one state causes a nonelementary blow-up in complexity. In particular, we prove that satisfiability for NCTL* has nonelementary complexity.

Symbolic model checking for channel-based component connectors

This paper introduces a temporal logic framework to reason about the coordination mechanisms and data flow of exogenous coordination models. We take a CTL-like branching time logic, augmented with regular expressions that specify the observable I/O-operations, as a starting point. The paper provides the syntax and semantics of our logic and introduces the corresponding model checking algorithm. The second part of the paper reports an implementation that relies on a symbolic representation of the coordination network and the connected components by means of binary decision diagrams. A couple of examples are given to illustrate the efficiency of the model checking techniques and their implementation.

Model Checking for a Class of Weighted Automata

A large number of different model checking approaches has been proposed during the last decade. The different approaches are applicable to different model types including untimed, timed, probabilistic and stochastic models. This paper presents a new framework for model checking techniques which includes some of the known approaches and enlarges the class of models to which model checking can be applied to the general class of weighted automata. The approach allows an easy adaption of model checking to models which have not been considered yet for this purpose. Examples for those new model types for which model checking can be applied are max/plus or min/plus automata which are well established models to describe different forms of dynamic systems and optimization problems. In this context, model checking can be used to verify temporal or quantitative properties of a system. The paper first presents briefly our class of weighted automata, as a very general model type. Then Valued Computational Tree Logic (CTL$) is introduced as a natural extension of the well known branching time logic CTL. Afterwards, algorithms to check a weighted automaton with respect to a CTL$ formula are presented. As a last result, bisimulation equivalence is extended to weighted automata and CTL$.

3-Valued abstraction: More precision at less cost

This paper investigates both the precision and the model checking efficiency of abstract models designed to preserve branching time logics w.r.t. a 3-valued semantics. Current abstract models use ordinary transitions to over approximate the concrete transitions, while they use hyper transitions to under approximate the concrete transitions. In this work, we refer to precision measured w.r.t. the choice of abstract states, independently of the formalism used to describe abstract models. We show that current abstract models do not allow maximal precision. We suggest a new class of models and a construction of an abstract model which is most precise w.r.t. any choice of abstract states. As before, the construction of such models might involve an exponential blowup, which is inherent by the use of hyper transitions. We therefore suggest an efficient algorithm in which the abstract model is constructed during model checking, by need. Our algorithm achieves maximal precision w.r.t. the given property while remaining quadratic in the number of abstract states. To complete the picture, we incorporate it into an abstraction-refinement framework.

Branching Time Logics $\mathcal {BTL}^{\mathrm {U,S}}_{\mathrm {N},\mathrm {N}^{-1}}(\mathcal {Z})_{\alpha }$ with Operations Until and Since Based on Bundles of Integer Numbers, Logical Consecutions, Deciding Algorithms

This paper is intended as an attempt to describe logical consequence in branching time logics. We study temporal branching time logics $\mathcal {BTL}^{\mathrm {U,S}}_{\mathrm {N},\mathrm {N}^{-1}}(\mathcal {Z})_{\alpha }$ which use the standard operations Until and Next and dual operations Since and Previous (LTL, as standard, uses only Until and Next). Temporal logics $\mathcal {BTL}^{\mathrm {U,S}}_{\mathrm {N},\mathrm {N}^{-1}}(\mathcal {Z})_{\alpha }$ are generated by semantics based on Kripke/Hinttikka structures with linear frames of integer numbers $\mathcal {Z}$ with a single node (glued zeros). For $\mathcal {BTL}^{\mathrm {U,S}}_{\mathrm {N},\mathrm {N}^{-1}}(\mathcal {Z})_{\alpha }$, the permissible branching of the node is limited by α (where 1≤α≤ω). We prove that any logic $\mathcal {BTL}^{\mathrm {U,S}}_{\mathrm {N},\mathrm {N}^{-1}}(\mathcal {Z})_{\alpha }$ is decidable w.r.t. admissible consecutions (inference rules), i.e. we find an algorithm recognizing consecutions admissible in $\mathcal {BTL}^{\mathrm {U,S}}_{\mathrm {N},\mathrm {N}^{-1}}(\mathcal {Z})_{\alpha }$. As a consequence, it implies that $\mathcal {BTL}^{\mathrm {U,S}}_{\mathrm {N},\mathrm {N}^{-1}}(\mathcal {Z})_{\alpha }$ itself is decidable and solves the satisfiability problem.

Control of Nondeterministic Discrete Event Systems for Simulation Equivalence

This paper studies supervisory control of discrete event systems subject to specifications modeled as nondeterministic automata. The control is exercised so that the controlled system is simulation equivalent to the (nondeterministic) specification. Properties expressed in the universal fragment of the branching-time logic can equivalently be expressed as simulation equivalence specifications. This makes the simulation equivalence a natural choice for behavioral equivalence in many applications and it has found wide applicability in abstraction-based approaches to verification. While simulation equivalence is more general than language equivalence, we show that existence as well as synthesis of both the target and range control problems remain polynomially solvable. Our development shows that the simulation relation is a preorder over automata, with the union and the synchronization of the automata serving as an infimal upperbound and a supremal lowerbound, respectively. For the special case when the plant is deterministic, the notion of state-controllable-similar is introduced as a necessary and sufficient condition for the existence of similarity enforcing supervisor. We also present conditions for the existence of a similarity enforcing supervisor that is deterministic.

Symbolic Model Checking for Channel-based Component Connectors

The paper reports on the foundations and experimental results with a model checker for component connectors modelled by networks of channels in the calculus Reo. The specification formalisms is a branching time logic that allows to reason about the coordination principles of and the data flow in the network. The underlying model checking algorithm relies on variants of standard automata-based approaches and model checking for CTL-like logics. The implementation uses a symbolic representation of the network and the enabled I/O-operations by means of binary decision diagrams. It has been applied to a couple examples that illustrate the efficiency of our model checker.

Local Module Checking for CTL Specifications

Model checking is a well known technique for the verification of finite state models using temporal logic specification. While model checking is suitable for transformational systems (also called closed systems), it is unsuitable for open systems (also known as reactive systems) where the nondeterminism in the environment must be considered during verification. Module checking is an approach for the verification of open systems which have both closed (internal) and open (environment or external) states. It has been demonstrated in [Orna Kupferman, Moshe Y. Vardi, and Pierre Wolper. Module checking. Information and Computation, 164:322–344, 2001] that the complexity of module checking branching time logic CTL is EXPTIME-complete. The approach to module checking is global and the method tries to establish that the property in question holds over all possible environments.This papers develops a local approach to CTL module checking using tableau rules. The proposed approach tries to determine a single environment under which the negation of the property is satisfied over the given module. Such a strategy, thus, leads to a local approach to module checking where we only explore states that are relevant to proving that the negation of the property can be satisfied over the given module using an appropriate witness (environment) that the algorithm also generates. While the worst case complexity of our algorithm is identical to the earlier complexity, we demonstrate that practical implementation of the proposed approach is feasible and yields much better results than the global approach.

Introduction and Call for Papers

In this issue, the JLC corner on directions in nonclassical logic is continued with the article ‘Axiomatizing the monodic fragment of ’ by Sebastian Bauer. In recent years, a great deal of attention has been paid to the search for decidable fragments of undecidable logics and axiomatizable fragments of non-axiomatizable logics. In first-order temporal logic, for example, Hodkinson, Wolter, and Zakharyaschev introduced the notion of monodic formulas [1, 2]. A formula is monodic if all temporal operators in it are applied only to formulas containing at most one free variable. In ‘Axiomatizing the monodic fragment of ’, Sebastian Bauer extends the existing work on monodic fragments by showing that the monodic fragment of an important quantified branching time logic, namely first-order Computation Tree Logic (CTL), is axiomatizable. The corner on directions in nonclassical logic is meant to be a continuous platform for bringing to the fore interesting and important directions in nonclassical logic. These may be completely new lines of research, surprising extensions of established theories, unexpected or hitherto unnoted connections between two or more areas or important but neglected or underestimated approaches. Contributions to the corner are invited from all areas of non-classical logic and may consist of single papers, or pairs or triples of complementary papers highlighting a common theme. Also proposals for topics to be addressed in the corner are most welcome. Electronic submissions may be sent to Heinrich.Wansing@tu-dresden.de, using ‘JLC corner’ as the subject line.

From Linear to Branching-Time Temporal Logics: Transfer of Semantics and Definability

This paper investigates logical aspects of combining linear orders as semantics for modal and temporal logics, with modalities for possible paths, resulting in a variety of branching time logics over classes of trees. Here we adopt a unified approach to the Priorean, Peircean and Ockhamist semantics for branching time logics, by considering them all as fragments of the latter, obtained as combinations, in various degrees, of languages and semantics for linear time with a modality for possible paths. We then consider a hierarchy of natural classes of trees and bundled trees arising from a given class of linear orders and show that in general they provide different semantics. We also discuss transfer of definability from linear orders to trees and introduce a uniform translation from Priorean to Peircean formulae which transfers definability of properties of linear orders to definability of properties of all paths in trees.

BTL2 and the expressive power of ECTL+

We show that ECTL + , the classical extension of CTL with fairness properties, is expressively equivalent to BTL 2 , a natural fragment of the monadic logic of order. BTL 2 is the branching-time logic with arbitrary quantification over paths, and where path formulae are restricted to quantifier depth 2 first-order formulae in the monadic logic of order. This result, linking ECTL + to a natural fragment of the monadic logic of order, provides a characterization that other branching-time logics, e.g., CTL , lack. We then go on to show that ECTL + and BTL 2 are not finitely based (i.e., they cannot be defined by a finite set of temporal modalities) and that their model-checking problems are of the same complexity.

BTL 2 and the expressive power of ECTL

We show that ECTL+, the classical extension of CTL with fairness properties, is expressively equivalent to BTL2, a natural fragment of the monadic logic of order. BTL2 is the branching-time logic with arbitrary quantification over paths, and where path formulac are restricted to quantifier depth 2 first-order formulae in the monadic logic of order. This result, linking ECTL+ to a natural fragment of the monadic logic of order, provides a characterization that other branching-time logics, e.g., CTL, lack. We then go on to show that ECTL+ and BTL2 are not finitely based (i.e., they cannot be defined by a finite set of temporal modalities) and that their model-checking problems are of the same complexity.

Moment/History Duality in Prior’s Logics of Branching-Time

The basic notions in Prior’s Ockhamist and Peircean logics of branching-time are the notion of moment and that of history (or course of events). In the tree semantics, histories are defined as maximal linearly ordered sets of moments. In the geometrical approach, both moments and histories are primitive entities and there is no set theoretical (and ontological) dependency of the latter on the former. In the topological approach, moments can be defined as the elements of a rank 1 base of a non-Archimedean topology on the set of histories. In this paper, it will be shown that the topological approach, and hence the other approaches, can be reconstructed in a framework in which the basic notions are those of history and of relative closeness relation among histories.

A clausal resolution method for branching-time logic ECTL+

We expand the applicability of the clausal resolution technique to the branching-time temporal logic ECTL+. ECTL+ is strictly more expressive than the basic computation tree logic CTL and its extension, ECTL, as it allows Boolean combinations of fairness and single temporal operators. We show how any ECTL+ formula can be translated to a normal form the structure of which was initially defined for CTL and then used for ECTL. This enables us to apply to ECTL+ a resolution technique defined over the set of clauses. Both correctness of the method and complexity of the transformation procedure are given.

Characterizing EF and EX tree logics

The expressive power of temporal branching time logics that use the modalities EX and EF is described. Forbidden pattern characterizations are given for tree languages definable in three logics: EX, EF and EX + EF . The characterizations give algorithms for the definability problem in the respective logics that are polynomial in the size of a deterministic tree automaton representing the language.

Supervisory Control of Discrete Event Systems with CTL* Temporal Logic Specifications

The supervisory control problem of discrete event systems with temporal logic specifications is studied. The full branching time logic of CTL* is used for expressing specifications of discrete event systems. The control problem of CTL* is reduced to the decision problem of CTL*. A small model theorem for the control of CTL* is obtained. It is shown that the control problem of CTL* (resp., CTL) is complete for deterministic double (resp., single) exponential time. A sound and complete supervisor synthesis algorithm for the control of CTL* is provided. Special cases of the control of computation tree logic (CTL) and linear-time temporal logic are also studied.