Margherita Napoli

Reachability of multistack pushdown systems with scope-bounded matching relations

A multi-stack pushdown system is a natural model of concurrent programs. The basic verification problems are in general undecidable (two stacks suffice to encode a Turing machine), and in the last years, there have been some successful approaches based on under-approximating the system behaviors. In this paper, we propose a restriction of the semantics of the general model such that a symbol that is pushed onto a stack can be popped only within a bounded number of context-switches. Note that, we allow runs to be formed of unboundedly many execution contexts, we just bound the scope (in terms of number of contexts) of matching push and pop transitions. We call the resulting model a multi-stack pushdown system with scope-bounded matching relations (SMpds). We show that the configuration reachability and the location reachability problems for SMpds are both Pspace-complete, and that the set of the reachable configurations is regular, in the sense that there exists a multi-tape finite automaton that accepts it.

A temporal logic for multi-threaded programs

Temporal logics for nested words are a specification formalism for procedural programs, since they express requirements about matching calls and returns. We extend this formalism to multiply nested words, which are natural models of the computations of concurrent programs. We study both the satisfiability and the model-checking problems, when the multiply nested words are runs of multi-stack pushdown systems (Mpds). In particular, through a tableau-based construction, we define a Buchi Mpds for the models of a given formula. As expected both problems are undecidable, thus we consider some meaningful restrictions on the Mpds, and show decidability for the considered problems.

Verification of scope-dependent hierarchical state machines

A hierarchical state machine (Hsm) is a finite state machine where a vertex can either expand to another hierarchical state machine (box) or be a basic vertex (node). Each node is labeled with atomic propositions. We study an extension of such model which allows atomic propositions to label also boxes (Shsm). We show that Shsms can be exponentially more succinct than Shsms and verification is in general harder by an exponential factor. We carefully establish the computational complexity of reachability, cycle detection, and model checking against general Ltl and Ctl specifications. We also discuss some natural and interesting restrictions of the considered problems for which we can prove that Shsms can be verified as much efficiently as Hsms, still preserving an exponential gap of succinctness.

On a Logic for Coalitional Games with Priced-Resource Agents

Alternating-time Temporal Logic (ATL) and Coalition Logic (CL) are well-established logical formalisms particularly suitable to model games between dynamic coalitions of agents (like e.g. the system and the environment). Recently, the ATL formalism has been extended in order to take into account boundedness of the resources needed for a task to be performed. The resulting logic, called Resource-BoundedATL (RB-ATL), has been presented in quite a variety of scenarios. Even if the model checking problem for extensions of ATL dealing with resource bounds is usually undecidable, a model checking procedure for RB-ATL has been proposed. In this paper, we introduce a new formalism, called PRB-ATL, based on a different notion of resource bounds and we show that its model checking problem remains in EXPTIME and has a PSPACE lower bound. Then, we tackle the problem of coalition formation. How and why agents should aggregate is not a new issue and has been deeply investigated, in past and recent years, in various frameworks, as for example in algorithmic game theory, argumentation settings, and logic-based knowledge representation. We face this problem in the setting of priced resource-bounded agents with the goal specified by an ATL formula. In particular we solve the problem of determining the minimal cost coalitions of agents acting in accordance to rules expressed by a priced game arena and satisfying a given formula. We show that such problem is computationally not harder than verifying the satisfaction of the same formula with fixed coalitions.

Synchronization of a line of identical processors at a given time

We are given a line of n identical processors (finite automata) that work synchronously. Each processor can transmit just one bit of information to the adjacent processors (if any) to the left and to the right. The computation starts at time 1 with the leftmost processor in an initial state and all other processors in a quiescent state. Given the time f(n), the problem is to set (synchronize) all the processors in a particular state for the first time, at the very same instant f(n). This problem is also known as the Firing Squad Synchronization Problem and was introduced by Moore in 1964. Mazoyer has given a minimal time solution with the least number of different states (six) and very recently he has given a minimal time solution for the constrained problem in which adjacent processors can exchange only one bit. In this paper we present solutions that synchronize the line at a given time, expressed as a function of n. In particular we give solutions that synchronize at the times nlogn, n√n, n 2 and 2 n. Moreover we also show how to compose solutions in such a way to obtain synchronizing solutions for all times expressed by polynomials with nonnegative coefficients. Clearly all such solutions work also in the general case when the bit constraint is relaxed.

Parametric metric interval temporal logic

We study an extension of the logic MITL with parametric constants. In particular, we define a logic, denoted PMITL (parametric MITL), where the subscripts of the temporal operators are intervals with possibly a parametric endpoint. We consider typical decision problems, such as emptiness and universality of the set of parameter valuations under which a given parametric formula is satisfiable, or whether a given parametric timed automaton is a model of a given parametric formula. We show that when each parameter is used with a fixed polarity and only parameter valuations which evaluate parametric intervals to non-singular time intervals are taken into consideration, then the considered problems are decidable and Expspace-complete. We also investigate the computational complexity of these problems for natural fragments of PMITL, and show that in meaningful fragments of the logic they are Pspace-complete. Finally, we discuss other natural parameterizations of MITL, which indeed lead to undecidability.

Program Complexity in Hierarchical Module Checking

Module checking is a well investigated technique for verifying the correctness of open systems, which are systems characterized by an ongoing interaction with an external environment. In the classical module checking framework, in order to check whether an open system satisfies a required property, we first translate the entire system into an open model (module ) that collects all possible behaviors of the environment and then check it with respect to a formal specification of the property. Recently, in the case of closed system, Alur and Yannakakis have considered hierarchical structure models in order to have models exponentially more succinct. A hierarchical model uses as nodes both ordinary nodes and supernodes, which are hierarchical models themselves. For CTL specifications, it has been shown that for the simple case of models having only single-exit supernodes, the hierarchical model checking problem is not harder than the classical one. On the contrary, for the more general multiple-exit case, the problem becomes Pspace -complete. In this paper, we investigate the program complexity of the CTL hierarchical module checking problem , that is, we consider the module checking problem for a fixed CTL formula and modules having also supernodes that are modules themselves. By exploiting an automata-theoretic approach through the introduction of hierarchical Buchi tree automata, we show that, in the single-exit case, the addressed problem remains in Ptime , while in the multiple-exit case, it becomes Pspace -complete.

Timed tree automata with an application to temporal logic

Abstract. Finite automata on

A Unifying Approach for Multistack Pushdown Automata

\omega

Model Checking for Graded CTL

-sequences and