Automated Predicate Abstraction for Real-Time Models

Axel Legay and Azadeh Farzan (Eds.): International Workshop on Verification of Infinite-State Systems (INFINITY 2009) EPTCS 10, 2009, pp. 36–43, doi:10.4204/EPTCS.10.3 Automated Predicate Abstraction for Real-Time Models Bahareh Badban∗ Stefan Leue Department of Computer and Information Science, University of Konstanz, Germany Bahareh.Badban@uni-konstanz.de Stefan.Leue@uni-konstanz.de Jan-Georg Smaus Institut f¨ur Informatik, Universit¨at Freiburg, Germany Smaus@informatik.uni-freiburg.de Introduction Model checking has been widely successful in validating and debugging hardware de- signs and communication protocols. However, state-space explosion is an intrinsic problem which limits the applicability of model checking tools. To overcome this limitation software model checkers have suggested different approaches, among which abstraction methods have been highly esteemed. modern techniques. Among others, predicate abstraction is a prominent technique which has been widely used in modern model checking. This technique has been shown to enhance the effectiveness of the reachability computation technique in infinite-state systems. In this technique an infinite-state system is represented abstractly by a finite-state system, where states of the abstract model correspond to the truth valuations of a chosen set of atomic predicates. Predicate abstraction was first introduced in [8] as a method for auto- matically determining invariant properties of infinite-state systems. This technique involves abstracting a concrete transition system using a set of formulas called predicates which usually denote some state properties of the concrete system. The practical applicability of predicate abstraction is impeded by two problems. First, predicates need to be provided manually [11, 7]. This means that the selection of appropriate abstraction predicates is based on a user-driven trial-and-error process. The high degree of user intervention also stands in the way of a seamless integration into practical software development processes. Second, very often the abstraction is too coarse in order to allow relevant system properties to be verified. This calls for abstrac- tion refinement [6], often following a counterexample guided abstraction refinement scheme [5, 3]. Real time models are one example of systems with a large state space as time adds much complexity to the system. In this event, recently there have been increasing number of research to provide a means for the abstraction of such models. It is the objective of this paper to provide support for an automated predicate abstraction technique for concurrent dense real-time models according to the timed automaton model of [1]. We propose a method to generate an efficient set of predicates than a manual, ad-hoc process would be able to provide. We use the results from our recent work [2] to analyze the behavior of the system under verification to discover its local state invariants and to remove transitions that can never be traversed. We then describe a method to compute a predicate abstraction based on these state invariants. We use information regarding the control state labels as well as the newly computed invariants in the considered control states when determining the abstraction predicates. We have developed a prototype ∗Corresponding author B. Badban & S. Leue & J.G. Smaus 37 tool that implements the invariant determination. Work is under way to also implement the computa- tion of a predicate abstraction based on our proposed method. We plan to embed our approach into a comprehensive abstraction and refinement methodology for timed automata. Related Work. An interactive method for predicate abstraction of real-time systems where a set of predicates called basis is provided by the user is presented in [6]. The manual choice of the abstraction basis depends on the user’s understanding of the system. The work presented in [15, 16] proposes an abstraction method which is based on identifying a set of predicates that is fine enough to distinguish between any two clock regions and which creates a strongly preserving abstraction of the system. The basis predicates are discovered by spurious paths obtained through model-checking of the system. Also, in this approach the choice of the original set of predicates relies on the user’s understanding of the system, as well as on the counterexample generation experiments. To the best of our knowledge, at the time of writing, there has been no research done on automatically generating invariants (predicates) for dense real time models, which will be the central contribution of our paper. In the functional setting the CEGAR methodology based on the seminal paper [5] has been rather influential in the development of hard- and software verification methodologies, e.g., [3]. Abstraction predicate discovery based on the analysis of spurious counterexamples is at the heart of the work in [7]. The approaches presented in [10, 13] and in [9] use interpol

…(Full text truncated)…

This content is AI-processed based on ArXiv data.