2,171 research outputs found
LTL Model-Checking for Dynamic Pushdown Networks Communicating via Locks
A Dynamic Pushdown Network (DPN) is a set of pushdown systems (PDSs) where each process can dynamically create new instances of PDSs. DPNs are a natural model of multi-threaded programs with (possibly recursive) procedure calls and thread creation. Extension of DPNs with locks allows processes to synchronize via locks. Thus, DPNs with locks are a well adapted formalism to model multi-threaded programs that synchronize via locks. Therefore, it is important to have model-checking algorithms for DPNs with locks. However, in general, the model-checking problem of DPNs with locks against reachability properties, and hence Linear Temporal Logic (LTL), is undecidable. To obtain de-cidable results, we study in this work the model-checking problem of DPNs with well-nested locks against single-indexed Linear Temporal Logic (LTL) properties of the form E f i s.t. f i is a LTL formula interpreted over the PDS i. We show that this model-checking problem is decidable. We propose an automata-based approach for computing the set of configurations of a DPN with locks that satisfy the corresponding single-indexed LTL formula
Visibly Linear Dynamic Logic
We introduce Visibly Linear Dynamic Logic (VLDL), which extends Linear
Temporal Logic (LTL) by temporal operators that are guarded by visibly pushdown
languages over finite words. In VLDL one can, e.g., express that a function
resets a variable to its original value after its execution, even in the
presence of an unbounded number of intermediate recursive calls. We prove that
VLDL describes exactly the -visibly pushdown languages. Thus it is
strictly more expressive than LTL and able to express recursive properties of
programs with unbounded call stacks.
The main technical contribution of this work is a translation of VLDL into
-visibly pushdown automata of exponential size via one-way alternating
jumping automata. This translation yields exponential-time algorithms for
satisfiability, validity, and model checking. We also show that visibly
pushdown games with VLDL winning conditions are solvable in triply-exponential
time. We prove all these problems to be complete for their respective
complexity classes.Comment: 25 Page
A Navigation Logic for Recursive Programs with Dynamic Thread Creation
Dynamic Pushdown Networks (DPNs) are a model for multithreaded programs with
recursion and dynamic creation of threads. In this paper, we propose a temporal
logic called NTL for reasoning about the call- and return- as well as thread
creation behaviour of DPNs. Using tree automata techniques, we investigate the
model checking problem for the novel logic and show that its complexity is not
higher than that of LTL model checking against pushdown systems despite a more
expressive logic and a more powerful system model. The same holds true for the
satisfiability problem when compared to the satisfiability problem for a
related logic for reasoning about the call- and return-behaviour of pushdown
systems. Overall, this novel logic offers a promising approach for the
verification of recursive programs with dynamic thread creation
Forward Analysis and Model Checking for Trace Bounded WSTS
We investigate a subclass of well-structured transition systems (WSTS), the
bounded---in the sense of Ginsburg and Spanier (Trans. AMS 1964)---complete
deterministic ones, which we claim provide an adequate basis for the study of
forward analyses as developed by Finkel and Goubault-Larrecq (Logic. Meth.
Comput. Sci. 2012). Indeed, we prove that, unlike other conditions considered
previously for the termination of forward analysis, boundedness is decidable.
Boundedness turns out to be a valuable restriction for WSTS verification, as we
show that it further allows to decide all -regular properties on the
set of infinite traces of the system
CARET analysis of multithreaded programs
Dynamic Pushdown Networks (DPNs) are a natural model for multithreaded
programs with (recursive) procedure calls and thread creation. On the other
hand, CARET is a temporal logic that allows to write linear temporal formulas
while taking into account the matching between calls and returns. We consider
in this paper the model-checking problem of DPNs against CARET formulas. We
show that this problem can be effectively solved by a reduction to the
emptiness problem of B\"uchi Dynamic Pushdown Systems. We then show that CARET
model checking is also decidable for DPNs communicating with locks. Our results
can, in particular, be used for the detection of concurrent malware.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854
Visibly Pushdown Modular Games
Games on recursive game graphs can be used to reason about the control flow
of sequential programs with recursion. In games over recursive game graphs, the
most natural notion of strategy is the modular strategy, i.e., a strategy that
is local to a module and is oblivious to previous module invocations, and thus
does not depend on the context of invocation. In this work, we study for the
first time modular strategies with respect to winning conditions that can be
expressed by a pushdown automaton.
We show that such games are undecidable in general, and become decidable for
visibly pushdown automata specifications.
Our solution relies on a reduction to modular games with finite-state
automata winning conditions, which are known in the literature.
We carefully characterize the computational complexity of the considered
decision problem. In particular, we show that modular games with a universal
Buchi or co Buchi visibly pushdown winning condition are EXPTIME-complete, and
when the winning condition is given by a CARET or NWTL temporal logic formula
the problem is 2EXPTIME-complete, and it remains 2EXPTIME-hard even for simple
fragments of these logics.
As a further contribution, we present a different solution for modular games
with finite-state automata winning condition that runs faster than known
solutions for large specifications and many exits.Comment: In Proceedings GandALF 2014, arXiv:1408.556
Transformational Verification of Linear Temporal Logic
We present a new method for verifying Linear Temporal
Logic (LTL) properties of finite state reactive systems based on logic programming and program transformation. We encode a finite state system and an LTL property which we want to verify as a logic program on infinite lists. Then we apply a verification method consisting of two steps. In the first step we transform the logic program that encodes the given system and the given property into a new program belonging to the class of the so-called linear monadic !-programs (which are stratified, linear recursive programs defining nullary predicates or unary predicates on infinite lists). This transformation is performed by applying rules that preserve correctness. In the second step we verify the property of interest by using suitable proof rules for linear monadic !-programs. These proof rules can be encoded as a logic program which always terminates, if evaluated by using tabled resolution. Although our method uses standard
program transformation techniques, the computational complexity of the derived verification algorithm is essentially the same as the one of the Lichtenstein-Pnueli algorithm [9], which uses sophisticated ad-hoc techniques
- …