11,958 research outputs found
Quantified CTL: Expressiveness and Complexity
While it was defined long ago, the extension of CTL with quantification over
atomic propositions has never been studied extensively. Considering two
different semantics (depending whether propositional quantification refers to
the Kripke structure or to its unwinding tree), we study its expressiveness
(showing in particular that QCTL coincides with Monadic Second-Order Logic for
both semantics) and characterise the complexity of its model-checking and
satisfiability problems, depending on the number of nested propositional
quantifiers (showing that the structure semantics populates the polynomial
hierarchy while the tree semantics populates the exponential hierarchy)
From Quantified CTL to QBF
QCTL extends the temporal logic CTL with quantifications over atomic propositions. This extension is known to be very expressive: QCTL allows us to express complex properties over Kripke structures (it is as expressive as MSO). Several semantics exist for the quantifications: here, we work with the structure semantics, where the extra propositions label the Kripke structure (and not its execution tree), and the model-checking problem is known to be PSPACE-complete in this framework. We propose a model-checking algorithm for QCTL based on a reduction to QBF. We consider several reduction strategies, and we compare them with a prototype (based on the SMT-solver Z3) on several examples
CTL+FO Verification as Constraint Solving
Expressing program correctness often requires relating program data
throughout (different branches of) an execution. Such properties can be
represented using CTL+FO, a logic that allows mixing temporal and first-order
quantification. Verifying that a program satisfies a CTL+FO property is a
challenging problem that requires both temporal and data reasoning. Temporal
quantifiers require discovery of invariants and ranking functions, while
first-order quantifiers demand instantiation techniques. In this paper, we
present a constraint-based method for proving CTL+FO properties automatically.
Our method makes the interplay between the temporal and first-order
quantification explicit in a constraint encoding that combines recursion and
existential quantification. By integrating this constraint encoding with an
off-the-shelf solver we obtain an automatic verifier for CTL+FO
The Logic of Counting Query Answers
We consider the problem of counting the number of answers to a first-order
formula on a finite structure. We present and study an extension of first-order
logic in which algorithms for this counting problem can be naturally and
conveniently expressed, in senses that are made precise and that are motivated
by the wish to understand tractable cases of the counting problem
On the Complexity of ATL and ATL* Module Checking
Module checking has been introduced in late 1990s to verify open systems,
i.e., systems whose behavior depends on the continuous interaction with the
environment. Classically, module checking has been investigated with respect to
specifications given as CTL and CTL* formulas. Recently, it has been shown that
CTL (resp., CTL*) module checking offers a distinctly different perspective
from the better-known problem of ATL (resp., ATL*) model checking. In
particular, ATL (resp., ATL*) module checking strictly enhances the
expressiveness of both CTL (resp., CTL*) module checking and ATL (resp. ATL*)
model checking. In this paper, we provide asymptotically optimal bounds on the
computational cost of module checking against ATL and ATL*, whose upper bounds
are based on an automata-theoretic approach. We show that module-checking for
ATL is EXPTIME-complete, which is the same complexity of module checking
against CTL. On the other hand, ATL* module checking turns out to be
3EXPTIME-complete, hence exponentially harder than CTL* module checking.Comment: In Proceedings GandALF 2017, arXiv:1709.0176
A Team Based Variant of CTL
We introduce two variants of computation tree logic CTL based on team
semantics: an asynchronous one and a synchronous one. For both variants we
investigate the computational complexity of the satisfiability as well as the
model checking problem. The satisfiability problem is shown to be
EXPTIME-complete. Here it does not matter which of the two semantics are
considered. For model checking we prove a PSPACE-completeness for the
synchronous case, and show P-completeness for the asynchronous case.
Furthermore we prove several interesting fundamental properties of both
semantics.Comment: TIME 2015 conference version, modified title and motiviatio
Reasoning About Strategies: On the Model-Checking Problem
In open systems verification, to formally check for reliability, one needs an
appropriate formalism to model the interaction between agents and express the
correctness of the system no matter how the environment behaves. An important
contribution in this context is given by modal logics for strategic ability, in
the setting of multi-agent games, such as ATL, ATL\star, and the like.
Recently, Chatterjee, Henzinger, and Piterman introduced Strategy Logic, which
we denote here by CHP-SL, with the aim of getting a powerful framework for
reasoning explicitly about strategies. CHP-SL is obtained by using first-order
quantifications over strategies and has been investigated in the very specific
setting of two-agents turned-based games, where a non-elementary model-checking
algorithm has been provided. While CHP-SL is a very expressive logic, we claim
that it does not fully capture the strategic aspects of multi-agent systems. In
this paper, we introduce and study a more general strategy logic, denoted SL,
for reasoning about strategies in multi-agent concurrent games. We prove that
SL includes CHP-SL, while maintaining a decidable model-checking problem. In
particular, the algorithm we propose is computationally not harder than the
best one known for CHP-SL. Moreover, we prove that such a problem for SL is
NonElementarySpace-hard. This negative result has spurred us to investigate
here syntactic fragments of SL, strictly subsuming ATL\star, with the hope of
obtaining an elementary model-checking problem. Among the others, we study the
sublogics SL[NG], SL[BG], and SL[1G]. They encompass formulas in a special
prenex normal form having, respectively, nested temporal goals, Boolean
combinations of goals and, a single goal at a time. About these logics, we
prove that the model-checking problem for SL[1G] is 2ExpTime-complete, thus not
harder than the one for ATL\star
- …