Benedetto Intrigila

Finite horizon analysis of Markov Chains with the Murϕ verifier

In this paper we present an explicit disk-based verification algorithm for Probabilistic Systems defining discrete time/finite state Markov Chains. Given a Markov Chain and an integer k (horizon), our algorithm checks whether the probability of reaching an error state in at most k steps is below a given threshold. We present an implementation of our algorithm within a suitable extension of the Murϕ verifier. We call the resulting probabilistic model checker FHP-Murϕ (Finite Horizon ProbabilisticMurϕ). We present experimental results comparing FHP-Murϕ with (a finite horizon subset of) PRISM, a state-of-the-art symbolic model checker for Markov Chains. Our experimental results show that FHP-Murϕ can handle systems that are out of reach for PRISM, namely those involving arithmetic operations on the state variables (e.g. hybrid systems).

Combinatorial principles in elementary number theory

Abstract We prove that the theory IΔ 0 , extended by a weak version of the Δ 0 -Pigeonhole Principle, proves that every integer is the sum of four squares (Lagranges theorem). Since the required weak version is derivable from the theory IΔ 0 + ∀ x ( x log( x ) exists), our results give a positive answer to a question of Macintyre (1986). In the rest of the paper we consider the number-theoretical consequences of a new combinatorial principle, the ‘Δ 0 -Equipartition Principle’ (Δ 0 EQ). In particular we give a new proof, which can be formalized in IΔ 0 + Δ 0 EQ, of the fact that every prime of the form 4 n + 1 is the sum of two squares.

A probabilistic approach to automatic verification of concurrent systems

The main barrier to automatic verification of concurrent systems is the huge amount of memory required to complete the verification task (state explosion). In this paper we present a probabilistic algorithm for automatic verification via model checking. Our algorithm trades space with time. In particular, when memory is full because of state explosion our algorithm does not give up verification. Instead it just proceeds at a lower speed and its results will only hold with some arbitrarily small error probability. Our preliminary experimental results show that by using our probabilistic algorithm we can typically save more than 30% of RAM with an average time penalty of about 100% w.r.t. a deterministic state space exploration with enough memory to complete the verification task. This is better than giving up the verification task because of lack of memory.

Some new results on easy lambda-terms

Abstract Given two closed λ-terms A and B we consider the question whether the equation A = B is consistent with the λβ-calculus. In general the problem is undecidable. However, if A is a 0-term, we can give good sufficient conditions for the consistency of λβ +{ A = B }. This allows us to prove some counterintuitive results such as: (1) there is a closed λ-term X which can be consistently equated to every closed λ-term with the exception of the identity λχ.χ, (2) there is a closed λ-term which can be consistently equated to every closed normal form, but not to the Curry fixed point operator Y .

Exploiting Transition Locality in the Disk Based Mur phi Verifier

The main obstruction to automatic verification of Finite State Systems is the huge amount of memory required to complete the verification task (state explosion). This motivates research on distributed as well as disk based verification algorithms.In this paper we present a disk based Breadth First Explicit State Space Exploration algorithm as well as an implementation of it within the Mur? verifier. Our algorithm exploits transition locality (i.e. the statistical fact that most transitions lead to unvisited states or to recently visited states) to decrease disk read accesses thus reducing the time overhead due to disk usage.A disk based verification algorithm for Mur? has been already proposed in the literature. To measure the time speed up due to locality exploitation we compared our algorithm with such previously proposed algorithm. Our experimental results show that our disk based verification algorithm is typically more than 10 times faster than such previously proposed disk based verification algorithm.To measure the time overhead due to disk usage we compared our algorithm with RAM based verification using the (standard) Mur? verifier with enough memory to complete the verification task. Our experimental results show that even when using 1/10 of the RAM needed to complete verification, our disk based algorithm is only between 1.4 and 5.3 times (3 times on average) slower than (RAM) Mur? with enough RAM memory to complete the verification task at hand.Using our disk based Mur? we were able to complete verification of a protocol with about 109 reachable states. This would require more than 5 gigabytes of RAM using RAM based Mur?.

Exploiting Transition Locality in Automatic Verification

In this paper we present an algorithm to contrast state explosion when using Explicit State Space Exploration to verify protocols. We show experimentally that protocols exhibit transition locality. We present a verification algorithm that exploits transition locality as well as an implementation of it within the Murϕ verifier. Our algorithm is compatible with all Breadth First (BF) optimization techniques present in the Murϕ verifier and it is by no means a substitute for any of them. In fact, since our algorithm trades space with time, it is typically most useful when one runs out of memory and has already used all other state reduction techniques present in the Murϕ verifier. Our experimental results show that using our approach we can typically save more than 40% of RAM with an average time penalty of about 50% when using (Murϕ) bit compression and 100% when using bit compression and hash compaction.

Automated Generation of Optimal Controllers through Model Checking Techniques

We present a methodology for the synthesis of controllers, which exploits (explicit) model checking techniques. That is, we can cope with the systematic exploration of a very large state space. This methodology can be applied to systems where other approaches fail. In particular, we can consider systems with an highly non-linear dynamics and lacking a uniform mathematical description (model). We can also consider situations where the required control action cannot be specified as a local action, and rather a kind of planning is required. Our methodology individuates first a raw optimal controller, then extends it to obtain a more robust one. A case study is presented which considers the well known truck-trailer obstacle avoidance parking problem, in a parking lot with obstacles on it. The complex non-linear dynamics of the truck-trailer system, within the presence of obstacles, makes the parking problem extremely hard. We show how, by our methodology, we can obtain optimal controllers with different degrees of robustness.

Synchronized regular expressions

Abstract. Text manipulation is one of the most common tasks for everyone using a computer. The increasing number of textual information in electronic format that every computer user collects everyday also increases the need of more powerful tools to interact with texts. Indeed, much work has been done to provide simple and versatile tools that can be useful for the most common text manipulation tasks. Regular Expressions (RE), introduced by Kleene, are well known in the formal language theory. RE have been extended in various ways, depending on the application of interest. In almost all the implementations of RE search algorithms (e.g. the egrep [15] UNIX command, or the Perl [20] language pattern matching constructs) we find backreferences, i.e. expressions that make reference to the string matched by a previous subexpression. Generally speaking, it seems that all kinds of synchronizations between subexpressions in a RE can be very useful when interacting with texts. In this paper we introduce the Synchronized Regular Expressions (SRE) as an extension of the Regular Expressions. We use SRE to present a formal study of the already known backreferences extension, and of a new extension proposed by us, which we call the synchronized exponents. Moreover, since we are dealing with formalisms that should have a practical utility and be used in real applications, we have the problem of how to present SRE to the final users. Therefore, in this paper we also propose a user-friendly syntax for SRE to be used in implementations of SRE-powered search algorithms.

Automatic verification of a turbogas control system with the murϕ verifier

Automatic analysis of Hybrid Systems poses formidable challenges both from a modeling as well as from a verification point of view. We present a case study on automatic verification of a Turbogas Control System (TCS) using an extended version of the Murφv; verifier. TCS is the heart of ICARO, a 2MW Co-generative Electric Power Plant. For large hybrid systems, as TCS is, the modeling effort accounts for a significant part of the whole verification activity. In order to ease our modeling effort we extended the Murφv; verifier by importing the C language long double type (finite precision real numbers) into it. We give experimental results on running our extended Murφv; on our TCS model. For example using Murφv; we were able to compute an admissible range of values for the variation speed of the user demand of electric power to the turbogas.

The Ant-Lion Paradigm for Strong Normalization

We look for strongly normalizable (SN) solutions of fixed point equations of the ?-calculus. We propose a paradigmatic way (the ant-lion paradigm) to solve some meaningful sample problems: (a) the adequacy theorem for numeral systems of the ?-K-calculus is extended to the ?-I-calculus and to the ?-?K-calculus (obtained by extending the ?-I-calculus by a restricted K as a ?-rule); (b) the fixed point equation X = FX is solved for F specialized into a deed; (c) numeral systems are classified by examples with respect to the key notions of the paper.