Tools and Algorithms for the Construction and Analysis of Systems, 6 conf., TACAS 2000

Lecture Notes in Computer Science Edited by G. Goos, J. Hartmanis and J. van Leeuwen 1785 3 Berlin Heidelberg New Yo...

Author: Susanne Graf | Michael Schwartzbach

23 downloads 865 Views 5MB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form

DOWNLOAD PDF

Lecture Notes in Computer Science Edited by G. Goos, J. Hartmanis and J. van Leeuwen

1785

3

Berlin Heidelberg New York Barcelona Hong Kong London Milan Paris Singapore Tokyo

Susanne Graf

Michael Schwartzbach (Eds.)

Tools and Algorithms for the Construction and Analysis of Systems 6th International Conference, TACAS 2000 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2000 Berlin, Germany, March 25 – April 2, 2000 Proceedings

13

Series Editors Gerhard Goos, Karlsruhe University, Germany Juris Hartmanis, Cornell University, NY, USA Jan van Leeuwen, Utrecht University, The Netherlands Volume Editors Susanne Graf VERIMAG 2, Avenue de la Vignate, 38240 Gières, France E-mail: [email protected] Michael Schwartzbach University of Aarhus BRICS, Department of Computer Science Ny Munkegade, 8000 Aarhus C, Denmark E-mail: [email protected] Cataloging-in-Publication Data applied for Die Deutsche Bibliothek - CIP-Einheitsaufnahme Tools and algorithms for the construction and analysis of systems : 6th international conference ; proceedings / TACAS 2000, held as part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2000, Berlin, Germany, March 25 - April 2, 2000. Susanne Graf ; Michael Schwartzbach (ed.). - Berlin ; Heidelberg ; New York ; Barcelona ; Hong Kong ; London ; Milan ; Paris ; Singapore ; Tokyo : Springer, 2000 (Lecture notes in computer science ; Vol. 1785) ISBN 3-540-67282-6

CR Subject Classification (1991): F.3, D.2.4, D.2.2, C.2.4, F.2.2 ISSN 0302-9743 ISBN 3-540-67282-6 Springer-Verlag Berlin Heidelberg New York This work is subject to copyright. All rights are reserved, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, re-use of illustrations, recitation, broadcasting, reproduction on microfilms or in any other way, and storage in data banks. Duplication of this publication or parts thereof is permitted only under the provisions of the German Copyright Law of September 9, 1965, in its current version, and permission for use must always be obtained from Springer-Verlag. Violations are liable for prosecution under the German Copyright Law. Springer-Verlag is a company in the BertelsmannSpringer publishing group. © Springer-Verlag Berlin Heidelberg 2000 Printed in Germany Typesetting: Camera-ready by author, data conversion by DA-TeX Gerd Blumenstein Printed on acid-free paper SPIN 10719978 06/3142 543210

Foreword

ETAPS 2000 was the third instance of the European Joint Conferences on Theory and Practice of Software. ETAPS is an annual federated conference that was established in 1998 by combining a number of existing and new conferences. This year it comprised five conferences (FOSSACS, FASE, ESOP, CC, TACAS), five satellite workshops (CBS, CMCS, CoFI, GRATRA, INT), seven invited lectures, a panel discussion, and ten tutorials. The events that comprise ETAPS address various aspects of the system development process, including specification, design, implementation, analysis, and improvement. The languages, methodologies, and tools which support these activities are all well within its scope. Different blends of theory and practice are represented, with an inclination towards theory with a practical motivation on one hand and soundly-based practice on the other. Many of the issues involved in software design apply to systems in general, including hardware systems, and the emphasis on software is not intended to be exclusive. ETAPS is a loose confederation in which each event retains its own identity, with a separate program committee and independent proceedings. Its format is open-ended, allowing it to grow and evolve as time goes by. Contributed talks and system demonstrations are in synchronized parallel sessions, with invited lectures in plenary sessions. Two of the invited lectures are reserved for “unifying” talks on topics of interest to the whole range of ETAPS attendees. The aim of cramming all this activity into a single one-week meeting is to create a strong magnet for academic and industrial researchers working on topics within its scope, giving them the opportunity to learn about research in related areas, and thereby to foster new and existing links between work in areas that were formerly addressed in separate meetings. The program of ETAPS 2000 included a public business meeting where participants had the opportunity to learn about the present and future organization of ETAPS and to express their opinions about what is bad, what is good, and what might be improved. ETAPS 2000 was hosted by the Technical University of Berlin and was efficiently organized by the following team: Bernd Mahr (General Chair) Hartmut Ehrig (Program Coordination) Peter Pepper (Organization) Stefan J¨ ahnichen (Finances) Radu Popescu-Zeletin (Industrial Relations) with the assistance of BWO Marketing Service GmbH. The publicity was superbly handled by Doris F¨ ahndrich of the TU Berlin with assistance from the ETAPS publicity chair, Andreas Podelski. Overall planning for ETAPS conferences is the responsibility of the ETAPS steering committee, whose current membership is:

VI

Foreword

Egidio Astesiano (Genova), Jan Bergstra (Amsterdam), Pierpaolo Degano (Pisa), Hartmut Ehrig (Berlin), José Fiadeiro (Lisbon), Marie-Claude Gaudel (Paris), Susanne Graf (Grenoble), Furio Honsell (Udine), Heinrich Hußmann (Dresden), Stefan J¨ ahnichen (Berlin), Paul Klint (Amsterdam), Tom Maibaum (London), Tiziana Margaria (Dortmund), Ugo Montanari (Pisa), Hanne Riis Nielson (Aarhus), Fernando Orejas (Barcelona), Andreas Podelski (Saarbr¨ ucken), David Sands (G¨ oteborg), Don Sannella (Edinburgh), Gert Smolka (Saarbr¨ ucken), Bernhard Steffen (Dortmund), Wolfgang Thomas (Aachen), Jerzy Tiuryn (Warsaw), David Watt (Glasgow), Reinhard Wilhelm (Saarbr¨ ucken) ETAPS 2000 received generous sponsorship from: the the the the the

Institute for Communication and Software Technology of TU Berlin European Association for Programming Languages and Systems European Association for Theoretical Computer Science European Association for Software Development Science “High-Level Scientific Conferences” component of the European Commission’s Fifth Framework Programme

I would like to express my sincere gratitude to all of these people and organizations, the program committee members of the ETAPS conferences, the organizers of the satellite events, the speakers themselves, and finally Springer-Verlag for agreeing to publish the ETAPS proceedings. January 2000

Donald Sannella ETAPS Steering Committee Chairman

Preface

This volume contains the proceedings of the 6th TACAS, International Conference on Tools and Algorithms for the Construction and Analysis of Systems. TACAS took place at the Technical University of Berlin, March 27–31, 2000, as a part of the third European Joint Conferences on Theory and Practice of Software (ETAPS) whose aims and organization are detailed in a separate foreword by Don Sannella. Previous TACAS meetings were held in 1999 (Amsterdam), 1998 (Lisbon), 1997 (Twente), 1996 (Passau), and 1995 (Aarhus). Since 1998 TACAS has been a conference and part of ETAPS. All previous TACAS proceedings have been published as volumes in Springerr-Verlag’s Lecture Notes in Computer Science series. It is the goal of TACAS to provide a forum for researchers, developers, and users interested in the development and application of tools for the specification, verification, analysis, and construction of software and hardware systems. In particular, it aims to promote the exchange of ideas between different communities of theoreticians, tool builders, tool users, and system designers of various specialized areas that traditionally had little interaction. In this respect, TACAS reflects the overall goal of ETAPS from a tool oriented perspective. In effect, the scope of TACAS intersects with those of all other ETAPS events, which address more traditional areas of interest. As a consequence, in addition to the standard criteria for acceptability, contributions have also been selected on the basis of their conceptual significance in the neighbouring areas. This comprises the comparison of concepts and methods, their degree of support via interactive or fully automatic tools, and case studies revealing the application profiles of the considered methods and tools. In order to emphasize the practical importance of tools, TACAS encourages tool presentations on equal footing with traditional scientific papers, treating them as “first class citizens”. In practice, this means that they have the same space in the proceedings and a full slot in the plenary conference session. Of course, during the conference there were also demonstrations of tools not announced in the official program. These proceedings contain – an invited lecture by Pierre Wolper and Bernhard Boigelot from the University of Liège “On the Construction of Automata from Linear Arithmetic Constraints”. – 33 regular contributions, covering a wide range of topics and being all relevant to the development of tools. They have been selected from 107 submissions, which is the largest number of submission TACAS has had so far. – the text of two short tool demonstrations which were reviewed by the ETAPS steering committee.

VIII

Preface

TACAS was hosted by the Technical University of Berlin, and being part of ETAPS, it shared the excellent organization described by Don Sannella in the foreword. TACAS will be continued next year as a part of ETAPS at Genova and in 2002 in Grenoble. Finally, we would like to thank the program committee and all the referees for their assistance in selecting the papers, Don Sannella for mastering the coordination of the whole ETAPS, and last but not least, the local organizers in Berlin. January 2000

Susanne Graf Michael Schwartzbach

Steering Committee Ed Brinksma (U. Twente) Rance Cleaveland (SUNY at Stony Brook) Kim G. Larsen (U. Aalborg) Bernhard Steffen (U. Dortmund)

Program Committee Chairs: Susanne Graf (VERIMAG, Grenoble) Michael Schwartzbach (BRICS, Aarhus)

Thomas Ball (Microsoft Reasearch) Ed Brinksma (U. Twente) Rance Cleaveland (Stony Brook) Matthew Dwyer (Kansas State U.) Fausto Giunchiglia (U. Trento) Constance Heitmeyer (Naval Research) Gerard Holzmann (Bell Labs) Claude Jard (IRISA, Rennes)

Joost Kok (U. Leiden) Kim Larsen (U. Aalborg) Tiziana Margaria (U. Dortmund) Bernhard Steffen (U. Dortmund) Perdita Stevens (U. Edinburgh) Wang Yi (U. Uppsala)

Preface

Reviewers Parosh Abdulla Rajeev Alur Tobias Amnell Stuart Anderson Myla M. Archer Mark Ardis Eugène Asarin David Aspinall Gerd Behrmann Johan Bengtsson Saddek Bensalem Ramesh Bharadwaj Roland Bol Marcello Bonsangue Ahmed Bouajjani Julian Bradfield Volker Braun Paul Caspi Frederico Crazzolara Pedro D’Argenio Mads Dam Achim Dannecker Alexandre David Rick Dewar Rolf Drechsler Jakob Engblom Harald Ganzinger Stephen Gilmore Jens Chr. Godskesen David Griffioen Corin Gurr Michael Hanus John Hatcliff Klaus Havelund Lo¨ıc Hélouët Jesper G. Henriksen

Holger Hermanns Andreas Holzmann Juraj Hromkovic Frank Huch Thomas Hune Hardi Hungar Purush Iyer Paul Jackson Ralph Jeffords Henrik E. Jensen Peter K. Jensen Thierry Jeron Mark Jerrum Bengt Jonsson Pim Kars Joost-Pieter Katoen Tim Kempster Yonit Kesten James Kirby Nils Klarlund Jens Knoop Kaare J. Kristoffersen Yassine Lakhnech Rom Langerak Elizabeth Leonard Martin Leucker Jorn Lind-Nielsen Hans Henrik Løvengreen Angelika Mader Thomas Mailund Oded Maler Radu Mateescu Michael Mendler Faron Moller Laurent Mounier Anders Møller

Markus M¨ uller-Olm Gustaf Naeser Kedar Namjoshi Uwe Nestmann Peter Niebert Oliver Niese Marcus Nilsson Thomas Noll Jan Nystr¨ om Corina Pasareanu Doron Peled Paul Pettersson Xu Qiwen Sriram Rajamani Arend Rensink Marina Ribaudo Søren Riis Judi Romijn Mauno Ronkko Vlad Rusu Oliver R¨ uthing Theo Ruys Konstantinos Sagonas Wolfram Schulte Joseph Sifakis Mikael Sjodin Arne Skou Margaret H. Smith Colin Stirling Jan Tretmans Stavros Tripakis Judith Underwood Glynn Winskel Sergio Yovine René de Vries

IX

Table of Contents

Invited Contribution On the Construction of Automata from Linear Arithmetic Constraints . . . . . . 1 Pierre Wolper and Bernard Boigelot Software and Formal Methods Tools An Extensible Type System for Component-Based Design . . . . . . . . . . . . . . . . . . 20 Yuhong Xiong and Edward A. Lee Proof General: A Generic Tool for Proof Development . . . . . . . . . . . . . . . . . . . . . 38 David Aspinall ViewPoint-Oriented Software Development: Tool Support for Integrating Multiple Perspectives by Distributed Graph Transformation . . . . . . . . . . . . . . . . 43 Michael Goedicke, Bettina Enders, Torsten Meyer and Gabriele Taentzer Formal Methods Tools Consistent Integration of Formal Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 Peter Braun, Heiko L¨ otzbeyer, Bernhard Sch¨ atz and Oscar Slotosch An Architecture for Interactive Program Provers . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 J¨ org Meyer and Arnd Poetzsch-Heffter The PROSPER Toolkit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 Louise A. Dennis, Graham Collins, Michael Norrish, Richard Boulton, Konrad Slind, Graham Robinson, Mike Gordon and Tom Melham CASL: From Semantics to Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 Till Mossakowski Timed and Hybrid Systems On the Construction of Live Timed Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Sébastien Bornot, Gregor G¨ oßler and Joseph Sifakis On Memory-Block Traversal Problems in Model-Checking Timed Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Fredrik Larsson, Paul Pettersson and Wang Yi Symbolic Model Checking for Rectangular Hybrid Systems . . . . . . . . . . . . . . . .142 Thomas A. Henzinger and Rupak Majumdar

XII

Table of Contents

Efficient Data Structure for Fully Symbolic Verification of Real-Time Software Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 Farn Wang Infinite and Parameterized Systems Verification of Parameterized Systems Using Logic Program Transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 Abhik Roychoudhury, K. Narayan Kumar, C.R. Ramakrishnan, I.V. Ramakrishnan and Scott A. Smolka Abstracting WS1S Systems to Verify Parameterized Networks . . . . . . . . . . . . 188 Kai Baukus, Saddek Bensalem, Yassine Lakhnech and Karsten Stahl FMona: A Tool for Expressing Validation Techniques over Infinite State Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 J.-P. Bodeveix and M. Filali Transitive Closures of Regular Relations for Verifying Infinite-State Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 Bengt Jonsson and Marcus Nilsson Diagnostic and Test Generation Using Static Analysis to Improve Automatic Test Generation . . . . . . . . . . . . . 235 Marius Bozga, Jean-Claude Fernandez and Lucian Ghirvu Efficient Diagnostic Generation for Boolean Equation Systems . . . . . . . . . . . . 251 Radu Mateescu Efficient Model-Checking Compositional State Space Generation with Partial Order Reductions for Asynchronous Communicating Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266 Jean-Pierre Krimm and Laurent Mounier Checking for CFFD-Preorder with Tester Processes . . . . . . . . . . . . . . . . . . . . . . . 283 Juhana Helovuo and Antti Valmari Fair Bisimulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 Thomas A. Henzinger and Sriram K. Rajamani Integrating Low Level Symmetries into Reachability Analysis . . . . . . . . . . . . . 315 Karsten Schmidt Model-Checking Tools Model Checking Support for the ASM High-Level Language . . . . . . . . . . . . . . 331 Giuseppe Del Castillo and Kirsten Winter

Table of Contents

XIII

A Markov Chain Model Checker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 Holger Hermanns, Joost-Pieter Katoen, Joachim Meyer-Kayser and Markus Siegle Model Checking SDL with Spin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 Dragan Boˇsnaˇcki, Dennis Dams, Leszek Holenderski and Natalia Sidorova Salsa: Combining Constraint Solvers with BDDs for Automatic Invariant Checking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 Ramesh Bharadwaj and Steve Sims Symbolic Model-Checking Symbolic Model Checking of Probabilistic Processes Using MTBDDs and the Kronecker Representation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Luca de Alfaro, Marta Kwiatkowska, Gethin Norman, David Parker and Roberto Segala Symbolic Reachability Analysis Based on SAT-Solvers . . . . . . . . . . . . . . . . . . . . 411 Parosh Aziz Abdulla, Per Bjesse and Niklas Eén Symbolic Representation of Upward-Closed Sets . . . . . . . . . . . . . . . . . . . . . . . . . . 426 Giorgio Delzanno and Jean-Fran¸cois Raskin BDD vs. Constraint-Based Model Checking: An Experimental Evaluation for Asynchronous Concurrent Systems . . . . . . . 441 Tevfik Bultan Visual Tools Tool-Based Specification of Visual Languages and Graphic Editors . . . . . . . . 456 Magnus Niemann and Roswitha Bardohl VIP: A Visual Editor and Compiler for v-Promela . . . . . . . . . . . . . . . . . . . . . . . . 471 Moataz Kamel and Stefan Leue Verification of Critical Systems A Comparison of Two Verification Methods for Speculative Instruction Execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .487 Tamarah Arons and Amir Pnueli Partial Order Reductions for Security Protocol Verification . . . . . . . . . . . . . . . 503 Edmund Clarke, Somesh Jha and Will Marrero Model Checking Security Protocols Using a Logic of Belief . . . . . . . . . . . . . . . . 519 Massimo Benerecetti and Fausto Giunchiglia

XIV

Table of Contents

A Formal Specification and Validation of a Critical System in Presence of Byzantine Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535 S. Gnesi, D. Latella, G. Lenzini, C. Abbaneo, A. Amendola and P. Marmo Author Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .551

On the Construction of Automata from Linear Arithmetic Constraints Pierre Wolper and Bernard Boigelot Université de Liège, Institut Montefiore, B28 4000 Liège Sart-Tilman, Belgium {pw,boigelot}@montefiore.ulg.ac.be

Abstract. This paper presents an overview of algorithms for constructing automata from linear arithmetic constraints. It identifies one case in which the special structure of the automata that are constructed allows a linear-time determinization procedure to be used. Furthermore, it shows through theoretical analysis and experiments that the special structure of the constructed automata does, in quite a general way, render the usual upper bounds on automata operations vastly overpessimistic.

1

Introduction

Model checking [CES86,QS81,VW86] is a now widespread technique for verifying temporal properties of reactive programs. There are several ways to develop the theory of model checking, a particularly attractive one being through the construction of automata from temporal logic formulas [VW86,BVW94]. As a result, there has been a fair amount of interest in the construction of automata from temporal logical formulas, the history of which is actually fairly interesting. The starting point is clearly the work of B¨ uchi on the decidability of the first and second-order monadic theories of one successor [B¨ uc62]. These decidability results were obtained through a translation to infinite-word automata, for which B¨ uchi had to prove a very nontrivial complementation lemma. The translation is nonelementary, but this is the best that can be done. It is quite obvious that linear-time temporal logic can be translated to the first-order theory of one successor and hence to infinite-word automata. From a logician’s point of view, this could be seen as settling the question, but an interest in using temporal logic for computer science applications, in particular program synthesis [MW84,EC82] triggered a second look at the problem. Indeed, it was quite obvious that a nonelementary construction was not necessary to build an automaton from a temporal logic formula; it could be done within a single exponential by a direct construction [WVS83,VW94]. As originally presented, this construction was worst and best case exponential. Though it was fairly clear that it could be modified to operate more effectively on many instances, nothing

This research was partially funded by a grant of the “Communauté fran¸caise de Belgique - Direction de la recherche scientifique - Actions de recherche concertées”.

S. Graf and M. Schwartzbach (Eds.): TACAS/ETAPS 2000, LNCS 1785, pp. 1–19, 2000. c Springer-Verlag Berlin Heidelberg 2000

2

Pierre Wolper and Bernard Boigelot

was written about this, probably because the topic was thought to be rather trivial and had no bearing on general complexity results. Nevertheless, the idea that doing model checking through the construction of automata was taken seriously, at least by some, and attempts were made to incorporate automata-theoretic model checking into tools, notably into SPIN [Hol91,Hol97]. Of course, this required an effective implementation of the logic to automaton translation algorithm and the pragmatics of doing this are not entirely obvious. A description of such an implementation was given in [GPVW95] and “improved” algorithms have been proposed since [DGV99]. Note that there are some questions about how to measure such “improvements” since the worst-case complexity of the algorithms stays the same. Nevertheless, experiments show that, for the temporal logic formulas most frequently used in verification, the automata can be kept quite small. Thus, even though it is an intrinsically exponential process, building an automaton from a temporal logic formula appears to be perfectly feasible in practice. What is surprising is that it took quite a long time for the details of a usable algorithmic solution to be developed and codified. Since building automata from temporal logic formulas turns out to be feasible, one might wonder if the same approach could work for other logics. This has been tried for the second-order monadic logic of one successor (S1S ) in the MONA tool [HJJ+ 95]. Here, one is confronted with nonelementary complexity, but careful algorithm selection and coding as well as the fact that the practically useful formulas are not arbitrary make the tool unquestionably usable. Motivated by the need to represent sets of integer vectors in the context of the verification of infinite-state systems [BW94], an automata-based approach is being developed for linear integer (Presburger) arithmetic [WB95,Boi98]. The idea that Presburger arithmetic formulas can be represented by automata goes back at least to B¨ uchi [B¨ uc60], and has lead to nice characterization results for the finite-state representable sets of integer vectors [Cob69,Sem77,BHMV94]. The attractiveness of the approach is not so much for single-shot arithmetic decision problems for which more traditional decision procedures perform well [Pug92], but for situations in which represented sets are repeatedly manipulated and compared, as is necessary in verification. Indeed, minimized deterministic finite automata are a convenient normal form for arithmetic formulas, in a way similar to BDDs [Bry92] being a normal form for Boolean formulas. Nevertheless, attempts to make a pragmatic use of automata representing arithmetic formulas are fairly recent [WB95,BC96] and one now needs to delve into the details of the automata constructions. Indeed, a straightforward approach to building the automata is quite unworkable and a crude complexity analysis leads only to a nonelementary upper bound, which is unsatisfactory since Presburger arithmetic is know to be decidable in double exponential space. Fortunately, one can do better. In [WB95] it was suggested to use concurrent automata as a representation. This indeed reduces the size of the automata, but pushes up the complexity of manipulating them. An important step was made in [BC96] where it was showed that there is a simple construction for obtain-

On the Construction of Automata from Linear Arithmetic Constraints

3

ing a deterministic automaton corresponding to an equation or an inequation. That paper even goes further and claims that a triple exponential deterministic automaton can be built for an arbitrary Presburger formula. Unfortunately, though the result itself might not be false, the argument used to substantiate this claim is intrinsically incorrect as we will discuss in this paper. In [TRS98] an encouraging experiment with an automaton-based Presburger implementation is described. Finally, the LASH tool [LASH] is a comprehensive implementation of arithmetic through automata. This paper aims at presenting and improving on the basics of the pragmatics of constructing automata from Presburger formulas. It starts with a detailed exposition of the construction of automata for linear equations and inequations. The fundamental idea of the construction is that of [BC96], which we extend and improve. First, we deal with signed integers using 2’s complement notation (see also [BBR97,BRW98]). Second, we aim at obtaining automata for both directions of reading number encodings. For equations, this is not problematic since the constructed automaton is immediately deterministic in both directions. For inequations, the construction of [BC96] gives an automaton that is deterministic in one direction, but nondeterministic in the other. However, we show that the automaton, taken in its nondeterministic direction, has a special structure that allows the use of a linear-time determinization procedure of possibly independent interest. Furthermore, this result shows that at least in this special case, the general exponential upper bound on determinization is vastly pessimistic. Finally, we turn to the problem of building automata for arbitrary Presburger formulas. Here, the interesting question is whether an unbounded alternation of quantifiers leads or not to a nonelementary blowup in the size of the automaton. This of course can be the case for arbitrary automata, but we show, with the help of a logic-based argument, that it is not the case for the automata obtained from Presburger formulas. We further substantiate this by giving the results of a number of experiments done with the LASH tool.

2

Preliminaries

Presburger arithmetic is the first-order theory of the structure N, 0, ≤, +, i.e. the natural numbers with the ≤ predicate as well as the 0-ary function 0 and the binary function +, all interpreted in the standard way. A Presburger formula with free variables thus represents a set of natural number vectors. In what follows, we will also refer to the theory of the related structure Z, 0, ≤, +, i.e. the additive theory of the integers, as Presburger arithmetic. Context will remove any ambiguity. When encoded in a base r ≥ 2, a natural number is a word over the alphabet {0, . . . r−1}. A language or set of words thus represents a set of natural numbers. An obvious question to ask then is which sets of natural numbers correspond to the regular languages under this representation. The question was answered by Cobham who showed that the sets representable in at least two relatively prime bases are exactly those definable in Presburger arithmetic [Cob69]. If one limits

4


oneself to a specific base, say base 2, slightly more is representable. Precisely, one can add to Presburger arithmetic the function Vr (n) giving the largest power of the base r dividing its argument n (see [BHMV94]). Similar results exist for vectors of natural numbers. To encode an n-dimensional vector x = (x1 , . . . , xn ), one encodes each of its components in base r. The length of the encoding of the components is then made uniform by adding leading 0s to the shorter components. The result is then viewed as a word over the alphabet rn by considering together the first digits of all the vector components, then the second digits, and so on. Example 1. The vector (4, 3) is encoded in binary by (100, 011), which is viewed as the word (1, 0)(0, 1)(0, 1) over the alphabet 22 . Cobham’s result on the sets representable by regular languages was extended to natural number vectors by Semenov [Sem77]. In many situations, it is useful to deal with integers rather than with natural numbers. There are several ways to extend the encoding we just introduced to integers. An obvious one is to add a sign bit, but this leads to the need to constantly distinguish the cases of positive and negative numbers. If one works in base 2, which will be our choice from now on, things can be made more uniform, exactly as is done in computer arithmetic, by using 2’s complement notation as proposed in [WB95,BRW98,Boi98]. In this notation, a number bk bk−1 . . . b1 b0 of length k + 1 written in base 2 is interpreted as −bk 2k + 0≤i≤k−1 bi 2i . It is thus positive if bk is 0 and negative if this bit is 1. There is one slight difficulty that comes from the fact that there is no bound on the size of the integers we consider and that thus we are dealing with variable-length encodings of integers, as opposed to the fixed length usually used in computer arithmetic. This is not problematic if we require that the leading bit of a number is always a sign bit, i.e. it is 0 is the number is positive and 1 if the number is negative1 . Indeed, there is then no ambiguity on the interpretation of the first bit of a number and repeating the sign bit, whether it is 0 or 1, has no incidence on the value of the number interpreted according to 2’s complement’s rule since −2k + 2k−1 = −2k−1 . We can thus still easily make the lengths of the encodings of the components of a vector equal. Example 2. The vector (−2, 12) can be encoded as (11110, 01100) or as the word (1, 0)(1, 1)(1, 1)(1, 0)(0, 0). Our goal here is to use finite automata to represent Presburger definable sets of integers. The advantages of this representation are that it is easy to compute with and that it makes questions about the represented sets, for instance nonemptiness, easy to decide. Furthermore, by using minimal deterministic automata, one even obtains a convenient normal form for Presburger definable sets of integer vectors. We will thus consider the problem of building automata corresponding to Presburger formulas. There are however two questions we have to deal with before doing so. 1

More formally, this means that to represent an integer x, we use a number of bits k > 0 large enough to satisfy −2k−1 ≤ x < 2k−1 .


5

Since sign bits can be repeated any number of times, an integer vector has an infinite number of representations. The question then is, which representations should the automata accept. It turns out that the most convenient answer is all valid representations, a representation of a vector being valid if its length is sufficient to allow its largest magnitude component to start with a sign bit. Indeed, representing an integer vector by all its encodings allows the Boolean operations on sets of vectors to correspond exactly with the matching language operation on the encodings. The same is unfortunately not true of projection, which is the automaton operation that allows us to handle existential quantification. Indeed, if for example one projects out the largest component of a vector by using language projection on the encodings, one can be left with an automaton that accepts only encodings beyond an unnecessarily long minimum inherited from the component that was eliminated. This problem can nevertheless be solved by using a specific projection operation that allows skipping the repetition of the initial symbol of a word. The second question is whether our automata will read encodings starting with the most significant or with the least significant bit. One can see advantages to using either directions, and the constructions we give allow automata to be built for either direction. However, our default choice, and the one we will use in examples, is to start with the most significant bit, this order often making the search for a vector accepted by an automaton more effective.

3

Building Automata for Presburger Formulas

We now turn to the problem of building an automaton accepting all encodings of the elements of a set defined by a Presburger formula. We could begin with a construction of automata for addition, equality and inequality, but there are interesting constructions that can deal directly with linear equations and inequations. We thus start with these. 3.1

Building Automata for Equations

The construction we present here is in essentially the one given in [BC96] adapted to handle negative numbers represented using 2’s complement, as well as to reading numbers starting with the most significant bit first. The construction is based on the following simple observation. Consider a representation of a vector x = (x1 , . . . , xn ) that is k bits long, and imagine adding the bits2 (b1 , . . . , bn ) = b respectively to the encodings of (x1 , . . . , xn ). The value x of the (k + 1)-bit long encoding thus obtained is given by x = 2x + b where addition is component-wise. This rule holds for every bit-tuple added except for the 2

Note that since there is a unique integer vector corresponding to an encoding, we will quite liberally talk about the vector defined by an encoding and, when appropriate use vector notation for encodings. In particular, we will always write elements (b1 , . . . , bn ) of 2n as bit vectors b.

6


first one, in which 1s have to be interpreted as −1. Thus, the value of a one bit long vector (b1 , . . . , bn ) = b is simply −b. Given this, it is very simple to construct an automaton for a linear equation a1 x1 + · · · + an xn = c which we write a.x = c. Indeed, the idea is to keep track of the value of the left-hand side of the equation as successive bits are read. Thus, except for a special initial state, each state of the automaton corresponds to an integer that represents the current value of the left-hand side. From a state corresponding to an integer γ = a.x for the vector x that has been read so far, there is a single transition for each bit vector b leading to the state γ = a.(2x + b) = 2a.x + a.b = 2γ + a.b. From the special initial state, the transition labeled b simply leads to the state a.(−b). The only accepting state is the one whose value is c. Formally, the automaton corresponding to an n-variable equation a.x = c is A = (S, 2n , δ, si , c) where – S = Z ∪ {si }, i.e. the states are the integers plus a special state si ; – the alphabet 2n is the set of n-bit vectors; – the transition function δ is defined by • δ(si , b) = −a.b and • δ(γ, b) = 2γ + a.b, for γ = si ; – the initial state is the special state si ; – the only accepting state is c, the value of the right-hand side of the equation. As defined, the automaton is infinite, but there are only a finite number of states from which the accepting state is reachable. Indeed, if a 1 represents the norm of a vector a = (a1 , . . . , an ) defined by a 1 = ni=1 |ai |, we have that from any state γ such that |γ| > a 1 , any transition leads to a state γ with |γ | > |γ|. So, if furthermore |γ| > |c|, c can never be reached from such a state. Hence, all states γ such that |γ| > a 1 and |γ| > |c| can be collapsed into a single nonaccepting state. Example 3. The automaton for the equation x − y = 2 is given in Figure 2. Note that, according to the criterion we have just given, the states beyond the solid line cannot be reached from the accepting state and thus can be collapsed into a single nonaccepting state. Furthermore, looking more carefully at this particular automaton, one sees that the states to be collapsed can in fact include those beyond the dotted line. The rule we have given for identifying unnecessary states is only approximative. It can be refined, but a more effective approach of identifying the necessary states is actually to construct the automaton backwards, starting from the accepting state. If this construction is limited to reachable states, only necessary states will be constructed. The exact construction is given in Figure 2. When limited to its reachable states, the automaton obtained by this construction is exactly the useful part of the automaton given by the forward construction. One can complete it by directing all missing transitions to a single nonaccepting sink state. It is deterministic since it is a part of the forward automaton we constructed initially and furthermore, it is minimal, since the sets


7

−7

01

−6

10

00, 11 01

−1 10

−3

00, 11 10 −2

01

10

−5

01 00, 11

−4

00, 11 0 01

00, 11

10

00, 11 1

10

2 01 3

01

00, 11

4

10 01

5

00, 11 10

6

7

Fig. 1. The automaton for x − y = 2.

1. Create a table H of automata states and a list L of “active” states. Both are initialized to {c}. 2. Repeat the following step until L = ∅. 3. Remove a state γ from L, and for every b ∈ 2n : – If γo = (γ − a.b)/2 is an integer, then • If γo is not in H, add it to H and L; • Add a transition labeled b from γo to γ; – If γ = −a.b, then • Add a transition labeled by b from the initial state si to γ.

Fig. 2. The automaton construction algorithm for an equation.

8


of words accepted from two distinct states cannot be identical. Indeed, the automaton is also deterministic when going backwards, except for transitions from the initial state, which is not a problem since the language accepted from the initial state is never equal to the one accepted from any other state. How many states does the automaton have? Clearly, any state (except for the initial one) is obtained from c by repeatedly applying the transformation T (γ) = (γ − a.b)/2. The states obtained by applying this transformation i times, i.e. those in T i (c) are in the range   i a 1  c ± 2i j=1 2j which is always included in

c . ± a 1 2i

(1)

Equation (1), implies that for i > log2 c, the range reduces to [− a 1 , a 1 ]. Thus the states can be found in at most log2 c + 1 ranges each of size bounded by 2 a 1 + 1. The total number of constructed states is thus O(log2 c × a 1 ), which is only logarithmic in the value of the additive constant c and hence linear in its number of bits. 3.2

Building Automata for Inequations

Consider now an inequation a.x ≤ c. Note that since we are dealing with integers, a strict inequation a.x < c is equivalent to the nonstrict inequation a.x ≤ c − 1. The forward construction we gave in the previous section can still be used to build an automaton for the inequation, the only difference being that now the set of accepting states is the set F = {γ | γ ≤ c}. Again, the automaton can be limited to a finite number of states. Indeed, starting with a positive γ such that γ > a 1 , all transitions will lead to a γ > γ and hence if γ > c, the inequation will never be satisfied. Similarly, if γ is negative and −γ > a 1 , all transitions will always lead to a γ < γ and thus if γ ≤ c, the inequation is satisfied. Again, the analysis above is somewhat coarse and a backwards construction can yield an automaton with less states. However, we have to take into account the fact that we are dealing with an inequation and not an equation, which leads us to construct an automaton somewhat different from the forward automaton. The main point is that, when computing the transitions leading to a state γ, we can no longer dismiss transitions for which γo = (γ − a.b)/2 is not an integer. Indeed, interpreting the fact that a state γ is reached to mean that the inequation a.x ≤ γ is satisfied by the word x read so far, the condition that has to be satisfied in a state γo from which γ is reached by a b transition is γo ≤ (γ − a.b)/2. An infinite number of states satisfy this condition, but it is sufficient to keep the largest since it corresponds to the weakest condition. Thus, as origin of a b transition to a state γ, we choose γo = (γ − a.b)/2. Finally, we have to add the possibility of transitions originating in the initial state. Thus, if −a.b ≤ γ, we also add a b transition from the initial state to γ.


9

The exact construction of the automaton is given in Figure 3, the initial state being si and the accepting state being c. 1. Create a table H of automata states and a list L of “active” states. Both are initialized to {c}; 2. Repeat the following step until L = ∅ : 3. Remove a state γ from L, and for every b ∈ 2n : – Let γo = (γ − a.b)/2 , then • If γo is not in H, add it to H and L; • Add a transition labeled b from γo to γ; – If −a.b ≤ γ, then • Add a transition labeled by b from the initial state si to γ.

Fig. 3. The automaton construction algorithm for an inequation

As opposed to the case of equations, the automaton we have just built is quite different from our initial forward automaton and is no longer deterministic. Indeed, clearly transitions from the initial state are not deterministic and, furthermore, (γ − a.b)/2 can be the same for two different values of γ, just think of γ = 2 and γ = 3 with b = 0. The bound on the number of states we derived for the case equations still holds, but for a nondeterministic automaton. If a deterministic automaton is desired, one is now faced with a potentially exponential determinization cost. However, it would be quite surprising that the automaton for an inequation be so much bigger than the automaton for the corresponding equation. We show that this is not case since the automaton we have constructed has a special structure that allows it to be determinized without increasing its number of states. The intuition behind the efficient determinization procedure is the following. Suppose that from a state γ, one has two b transitions leading respectively to states γ1 and γ2 . One obviously has either γ1 < γ2 or γ2 < γ1 and one can assume without loss of generality that the former holds. If one reads being in a state γ as meaning that the inequation a.x ≤ γ is satisfied by what has been read so far, it is immediate that any x that satisfies a.x ≤ γ1 also satisfies a.x ≤ γ2 . Hence only the stronger of the two conditions, i.e. a.x ≤ γ1 needs to be remembered in order to know if the word being read will end up being accepted, and the transition to the state γ2 can be dropped. We now formalize this intuition. Definition 1. Given a nondeterministic finite automaton A = (S, Σ, δ, s0 , F ), let As be the automaton A = (S, Σ, δ, s, F ), i.e. A where the initial state is s. The automaton A is then said to be ordered if there is an explicitly given, i.e. constant-time decidable, strict total order ≺ on its set S (possibly excluding the initial state if no transitions lead to it) of states and if for any pair of states satisfying s1 ≺ s2 , we have that L(As1 ) ⊂ L(As2 ). Ordered automata can be determinized efficiently.

10


Lemma 1. A nondeterministic ordered finite automaton can be determinized in linear time. Proof. Let A = (S, Σ, δ, s0 , F ) be an ordered nondeterministic finite automaton, i.e its transition function is of the type δ : S × Σ → 2S . The corresponding deterministic automaton is A = (S, Σ, δ , s0 , F ), all components of which are identical to those of A, except for δ : S × Σ → S which is defined by δ (a, s) = max(δ(a, s)). Thus, if several identically labeled transitions leave a state, they are replaced by a single transition to the largest of these states in the order defined on S. According to the definition of ordered automata, the language accepted from this largest state includes the language accepted from all smaller states and hence removing the transitions to smaller states does not change the language accepted by the automaton. Also note that if the initial state is not the target of any transition, it can safely be left out of the order. The determinization procedure just amounts to removing transitions and can be easily implemented in linear time. We are aiming at applying Lemma 1 to the nondeterministic automata we have constructed for inequations. So we need to check if these automata are ordered. Let us look at the words accepted from a state γ of the automaton A constructed for an inequation a.x ≤ c. These, will all be words w encoding a vector xw , which suffixed to any word w0 encoding a vector xw0 satisfying a.xw0 ≤ γ form a word w0 w encoding a vector xw0 w that satisfies a.xw0 w ≤ c. Thus all the words w accepted from a state γ are such that for all w0 satisfying a.xw0 ≤ γ one has a.xw0 w = a.xw0 2length(w) + a.xw ≤ c and hence, since the above holds for any w0 such that a.xw0 ≤ γ, w must satisfy γ2length(w) + a.xw ≤ c.

(2)

So, one expects that, if γ1 < γ2 , a word w accepted from γ2 will also be accepted from γ1 . In other words, one expects that L(Aγ2 ) ⊂ L(Aγ1 ) and that the automaton is ordered with respect to the relation ≺ which is the inverse of the numerical order. However, this is not quite so. Indeed, even though all words accepted from a state γ satisfy the relation expressed by Equation (2), it is not the case that all words satisfying Equation (2) are accepted. Fortunately, it is possible to “complete” the automaton we have constructed in such a way that the words accepted from a state γ are exactly those defined by Equation (2), and this can be done without adding states to the automaton. The completion procedure just adds transitions and accepting states. Given the automaton A = (S, 2n , δ, si , c) constructed by the algorithm of Figure 3 for an inequation a.x ≤ c, it constructs an automaton A = (S, 2n , δ , si , F ) as described in Figure 4.


11

1. The set of accepting states is F = {γ ∈ S | γ ≤ c}; 2. For every state γ, and bit vector b ∈ 2n , δ (γ, b) = δ(γ, b) ∪ {γ ∈ S | γ ≥ 2γ + a.b}.

Fig. 4. The completion algorithm. The completion algorithm can add a number of transitions that is quadratic in the number of states and hence can require quadratic time. We will see how this can be improved, but first let us prove that the completion algorithm does produce an ordered automaton. Lemma 2. The completion algorithm of Figure 4 produces an ordered automaton that accepts the same language as the original automaton. Proof. The order with respect to which the completed automaton is ordered is the inverse of the numerical order. We thus have to prove that if γ1 < γ2 then L(Aγ2 ) ⊂ L(Aγ1 ). This is done by showing that the set of words accepted from any state γ is exactly the one satisfying the relation given in Equation (2), which at the same time shows that the language accepted by the completed automaton is unchanged since the original automaton already accepted all solutions of the inequation. To show that any word satisfying Equation (2) in a state γ is accepted from that state, we proceed by induction on the length of words. For the induction to go through, we strengthen the property we are proving with the fact that max which is the largest γ such that for any word w of length k, the state γw k γ2 + a.xw ≤ c is in S. If the word is of length 0 (the empty word ε), it must be accepted iff γ ≤ c. This is guaranteed by the definition of the set of accepting states F . Furthermore, γεmax is simply c, which by construction is in S. For the inductive step, let w = b1 w1 , where w1 is of length k−1. By inductive max max is in S. By construction, the state (γw − a.b1 )/2 hypothesis, the state γw 1 1 max is in S and is the state γw . Since w satisfies the relation of Equation (2) in γ, max one must have that γ ≤ γw . Hence, the completion procedure adds from γ a max transition to γw1 given that max max ≥ 2γw + a.b1 ≥ 2γ + a.b1 . γw 1

Hence w is accepted from γ.

Note that the completion procedure adds transitions that will later be removed by the determinization procedure for the ordered automaton that is obtained. In fact from a state γ and for a bit vector b, the determinization procedure only keeps the transition to the smallest γ such that γ ≥ γ + a.b. Hence, in our completion procedure, we can add transitions according to the following rule: 1. For every state γ, and bit vector b ∈ 2n , δ (γ, b) = δ(γ, b) ∪ min{γ ∈ S | γ ≥ 2γ + a.b}.

12


This can be done in linear time and we have the following result. Theorem 1. The automaton constructed for an inequation by the algorithm of Figure 3 can be determinized in linear time. Example 4. The automaton produced by Algorithm 3 for the inequation x − y ≤ 2 is given in Figure 5, with the elements added by the simplified completion procedure in boldface, and the transitions deleted by the determinization procedure underlined.

00, 01, 10, 11

−1 10

10

01

10 00, 10, 11

00, 01, 11 0

00, 01, 10, 11

00, 10, 11 1

2

00, 01, 11

01 00, 01, 10, 11

Fig. 5. The automaton for x − y ≤ 2.

3.3

Building Automata for Arbitrary Formulas

In an arbitrary Presburger formula, one can always move negations inwards and quantifications outwards. Doing so, one obtains a Boolean combination of linear (in)equations prefixed by a string of quantifiers, i.e. a formula of the form Q1 x1 Q2 x2 . . . Qn xn φ(x1 , . . . , xn , y1 , . . . , ym )

(3)

where each Qi is either ∀ or ∃, φ is quantifier free and y1 , . . . ym are the free variables of the formula. The quantifier-free formula φ is a Boolean combination of linear equations and inequations φi . For each of the φi , we have seen how


13

to build a deterministic automaton of size O(2c|φi | ), where |φi | is the number of symbols needed to represent the (in)equation, coefficients being encoded in a base ≥ 2. The Boolean combination of these (in)equations can thus be represented by a deterministic automaton that is the product of the automata for the (in)equations, the accepting states being defined according to the given Boolean c|φi | c |φi | i combination. This product is of size O( i 2 ) or O(2 ), which is equal c|φ| to O(2 ). The size of this deterministic automaton is thus at most a single exponential in the size of the formula. To handle quantification, one replaces ∀ by ¬∃¬, and uses projection as the automaton operation corresponding to existential quantification. There is however one slight problem in doing so, which is that the automaton obtained by standard projection does not accept all encodings of the projected set of integer vectors. Example 5. The automaton for x = 1 ∧ y = 4 and the result of projecting out y from this automaton are given in Figure 6. The resulting automaton accepts the encodings of 1, but only those that are of length at least 4. The encodings 01 and 001 are not accepted.

00

00

01

00

10

0

0

0

1

0

Fig. 6. Automata for x = 1 ∧ y = 4 and its projection.

The problem illustrated in Example 5 can be solved by modifying the automaton obtained from projection to ensure that when a word in b+ w is accepted the word bw is also accepted. This is done by including in the set of states reachable from the initial state by b all states reachable from the initial state by b+ . The automaton obtained after a projection step is in general nondeterministic and one needs to determinize it in order to apply the complementation needed to handle universal quantification. One thus expects a exponential blowup in the size of the automaton for each quantifier alternation and thus an automaton whose size grows in a nonelementary way. In [BC96] it is argued that this is not the case, and that the size of the automaton is at most 3 exponentials in the size of the formula. Unfortunately, the argument used is false. Indeed, it essentially amounts to translating the string of alternating quantifiers to Boolean

14


transitions, generalizing the translation to nondeterministic transitions done in the handling of projection. The result is thus an alternating automaton of size O(2c|φ| ), which can be converted into a deterministic automaton two exponentials larger. The catch is that this implies that the quantifier prefix is handled bit-wise rather than number-wise. Explicitly, when moving from numbers to binary encodings, this implies that rather than translating (3) to Q1 b11 b12 . . . b1k Q2 b21 b22 . . . b2k . . . Qn bn1 bn2 . . . bnk φ, one translates it to Q1 b11 Q2 b21 . . . Qn bn1 Q1 b12 Q2 b22 . . . Qn bn2 . . . Q1 b1k Q2 b2k . . . Qn bnk φ, which has, of course, an entirely different meaning. That the argument used in [BC96] is false does not mean that the size of the automaton for a Presburger formula will grow nonelementarily with respect to the number of quantifier alternations. Indeed, an analysis of the traditional quantifier elimination procedure for Presburger arithmetic [End72] shows the opposite. Looking at this procedure, one notices that the number of basic formulas that are generated stays elementary in the size of the initial formula. Whatever the quantifier prefix of the formula, the quantifier elimination procedure only generates a Boolean combination of this elementary number of formulas. Hence, the formula obtained by the quantifier elimination procedure is elementary and so will be the corresponding automaton. 3.4

Pragmatics

So far, we have tried to present in a fairly detailed way the algorithms used to build automata from Presburger formulas. However, there are still a a substantial number of “improvements” that can be added to what we have described in order to obtain a good implemented system. We discuss here one such important improvement. The reader is certainly aware of the fact that one of the drawbacks of the automata we are constructing is that their alphabet is exponential in the number of variables of the arithmetic formula. Thus, even very simple formulas involving many variables will lead to automata with a huge number of transitions. Fortunately, there is a way around this. The idea is to sequentialize the reading of the bits of the vector components. That is, rather than reading a bit vector b = (b1 , b2 , . . . , bn ) as a single entity, one reads b1 , b2 , . . . , bn one at a time in a fixed order. The size of the alphabet is now always 2, whatever the number of components of the integer vectors defined. Of course, the counterpart is that the number of states of the automaton is increased, but this increase can be more moderate than the explosion in the number of transitions that comes from a large number of variables. This can easily be understood by observing that using 2n as alphabet amounts to representing the transitions from a state as a truth table, whereas sequentializing the reading of the bits corresponds to representing the transitions from a state as a decision diagram for a given bit order. Minimizing the automaton has the effect


15

of minimizing this diagram and one is in fact representing the transitions from a state with a structure that is similar to an OBDD [Bry92]. This technique is used in the LASH package [LASH] as well as in the MONA tool [HJJ+ 95]. The construction algorithms presented in this paper can easily be adapted to the sequentialized encoding of vectors.

4

Experimental Results

As discussed above, each application of a projection and determinization construction to an automaton representing arithmetic constraints is not going to yield an exponential blowup in the size of the automaton. The question then is, what blowup does in fact occur? To attempt to answer this question, we turned to experiments performed with the help of the LASH tool. The first experiment consists of applying an existential quantifier to the sets of solutions of random systems of linear inequalities. The results obtained for 100 systems of 8 inequations of dimension 4 with coefficients in the interval [−5, . . . , 5] are given in Figure 7. This figure depicts the number of states of the quantified automata, which are made deterministic and minimal, with respect to the size of the unquantified automata. Note that all the points fall below the dotted equality line, which means that the number of states always decreases.

100000

10000

1000

100

10 10

100

1000

10000

100000

1e+06

Fig. 7. Effect of quantification over systems of linear inequalities.

A second test consists of repeatedly applying an existential quantification to the automata of the previous experiment, until only a single free variable remains. Figure 8 gives the number of states of the automata obtained during, and as a result of, this process, relative to the size of the automaton obtained prior to the application of the last quantification operation.

16

Pierre Wolper and Bernard Boigelot 100000

10000

1000

100

10

1 1

10

100

1000

10000

100000

1e+06

Fig. 8. Effect of repeated quantification over systems of linear inequalities.

Finally, Figure 9 illustrates the effect of applying existential quantification to non-convex sets obtained by joining together the sets of solutions of two random systems of linear inequalities.

1000

100

10

1 10

100

1000

10000

100000

Fig. 9. Effect of quantification over non-convex sets.

It is rather surprising that these experiments show that every projectiondeterminization step in fact decreases the size of the automaton, whereas an exponential blowup could have been feared. This raises interesting questions, for instance, what exact bound can be proved on the size increase resulting from projecting and determinizing an arithmetic automaton? What structural properties of such automata explain this bound? These are still open questions.


5

17

Conclusions

There are two sets of conclusions that can be drawn from this paper. The first concerns the use of finite automata as a tool for handling Presburger arithmetic. The initial construction of an automaton from a quantifier-free formula can be exponentially expensive, either as the result of the interaction of many constraints or as a consequence of the presence of large multiplicative constants in formulas. It is easy to construct examples where this explosion occurs, but also to construct examples where things are much tamer. There is however, an important benefit linked to this potentially high cost: the automaton is a structure in which much of the information contained in the formula is explicit. For instance, satisfiability becomes decidable in linear time and inclusion between represented sets is, at worst, quadratic. Furthermore, as shown by our experiments, subsequent manipulation of the automaton need not be very costly. This indicates, that if one needs to repeatedly work with and transform a Presburger formula, as is often the case in verification applications, adopting the automatabased approach might very well be an excellent choice. On the other hand, if one is interested in a one shot satisfiability check, traditional approaches have the edge since building the automaton involves doing substantially more than just checking for the possibility of satisfying the given formula. Of course, only the accumulation of experiments coupled with the fine-tuning of tools will give the final word on the value of the approach. The second set of conclusions is about computing with automata and the corresponding complexity bounds. Our special determinization procedure for inequation automata as well as our discussion of projection-determinization operations indicate that the general complexity bounds for automata operations do not tell the full story when dealing with automata corresponding to linear constraints. For inequation automata, we were able to identify the structure that explained the absence of blowup while determinizing. For the determinization of the result of a projection operation, our only arguments for the absence of blowup comes from a logic-based analysis of the represented sets. It would, however, be much more satisfactory to explain the absence of blowup in purely automatatheoretic terms, which could lead to more direct and efficient algorithms, just as in the case of inequation automata. But, this remains an open problem.

References BBR97.

BC96.

B. Boigelot, L. Bronne, and S. Rassart. An improved reachability analysis method for strongly linear hybrid systems. In Proc. 9th Int. Conf.on Computer Aided Verification, volume 1254 of Lecture Notes in Computer Science, pages 167–178, Haifa, June 1997. Springer-Verlag. 3 A. Boudet and H. Comon. Diophantine equations, Presburger arithmetic and finite automata. In Proceedings of CAAP’96, number 1059 in Lecture Notes in Computer Science, pages 30–43. Springer-Verlag, 1996. 2, 3, 5, 13, 14

18


BHMV94. V. Bruyère, G. Hansel, C. Michaux, and R. Villemaire. Logic and precognizable sets of integers. Bulletin of the Belgian Mathematical Society, 1(2):191–238, March 1994. 2, 4 Boi98. B. Boigelot. Symbolic Methods for Exploring Infinite State Spaces. PhD thesis, Université de Liège, 1998. 2, 4 BRW98. Bernard Boigelot, Stéphane Rassart, and Pierre Wolper. On the expressiveness of real and integer arithmetic automata. In Proc. 25th Colloq. on Automata, Programming, and Languages (ICALP), volume 1443 of Lecture Notes in Computer Science, pages 152–163. Springer-Verlag, July 1998. 3, 4 Bry92. R.E. Bryant. Symbolic boolean manipulation with ordered binary-decision diagrams. ACM Computing Surveys, 24(3):293–318, 1992. 2, 15 B¨ uc60. J. R. B¨ uchi. Weak second-order arithmetic and finite automata. Zeitschrift Math. Logik und Grundlagen der Mathematik, 6:66–92, 1960. 2 B¨ uc62. J.R. B¨ uchi. On a decision method in restricted second order arithmetic. In Proc. Internat. Congr. Logic, Method and Philos. Sci. 1960, pages 1–12, Stanford, 1962. Stanford University Press. 1 BVW94. Orna Bernholtz, Moshe Y. Vardi, and Pierre Wolper. An automatatheoretic approach to branching-time model checking. In Computer Aided Verification, Proc. 6th Int. Workshop, volume 818 of Lecture Notes in Computer Science, pages 142–155, Stanford, California, June 1994. SpringerVerlag. 1 BW94. Bernard Boigelot and Pierre Wolper. Symbolic verification with periodic sets. In Computer Aided Verification, Proc. 6th Int. Conference, volume 818 of Lecture Notes in Computer Science, pages 55–67, Stanford, California, June 1994. Springer-Verlag. 2 CES86. E.M. Clarke, E.A. Emerson, and A.P. Sistla. Automatic verification of finite-state concurrent systems using temporal logic specifications. ACM Transactions on Programming Languages and Systems, 8(2):244–263, January 1986. 1 Cob69. A. Cobham. On the base-dependence of sets of numbers recognizable by finite automata. Mathematical Systems Theory, 3:186–192, 1969. 2, 3 DGV99. M. Daniele, F. Giunchiglia, and M. Y. Vardi. Improved automata generation for linear temporal logic. In Computer-Aided Verification, Proc. 11th Int. Conference, volume 1633, pages 249–260, July 1999. 2 EC82. E.A. Emerson and E.M. Clarke. Using branching time logic to synthesize synchronization skeletons. Science of Computer Programming, 2:241–266, 1982. 1 End72. H. B. Enderton. A mathematical introduction to logic. Academic Press, 1972. 14 GPVW95. Rob Gerth, Doron Peled, Moshe Y. Vardi, and Pierre Wolper. Simple on-the-fly automatic verification of linear temporal logic. In Proc. 15th Work. Protocol Specification, Testing, and Verification, Warsaw, June 1995. North-Holland. 2 HJJ+ 95. Jesper G. Henriksen, Jakob L. Jensen, Michael E. Jørgensen, Nils Klarlund, Robert Paige, Theis Rauhe, and Anders Sandholm. Mona: Monadic secondorder logic in practice. In Ed Brinksma, Rance Cleaveland, Kim Guldstrand Larsen, Tiziana Margaria, and Bernhard Steffen, editors, Tools and Algorithms for the Construction and Analysis of Systems, volume 1019 of Lecture Notes in Computer Science, pages 89–110. Springer-Verlag, 1995. 2, 15

On the Construction of Automata from Linear Arithmetic Constraints Hol91. Hol97.

LASH. MW84.

Pug92. QS81.

Sem77. TRS98.

VW86.

VW94. WB95.

WVS83.

19

G. Holzmann. Design and Validation of Computer Protocols. Prentice-Hall International Editions, 1991. 2 Gerard J. Holzmann. The model checker SPIN. IEEE Transactions on Software Engineering, 23(5):279–295, May 1997. Special Issue: Formal Methods in Software Practice. 2 The Liège Automata-based Symbolic Handler (LASH). Available at http://www.montefiore.ulg.ac.be/~boigelot/research/lash/. 3, 15 Zohar Manna and Pierre Wolper. Synthesis of communicating processes from temporal logic specifications. ACM Transactions on Programming Languages and Systems, 6(1):68–93, January 1984. 1 W. Pugh. A practical algorithm for exact array dependency analysis. Comm. of the ACM, 35(8):102, August 1992. 2 J.P. Queille and J. Sifakis. Specification and verification of concurrent systems in Cesar. In Proc. 5th Int’l Symp. on Programming, volume 137, pages 337–351. Springer-Verlag, Lecture Notes in Computer Science, 1981. 1 A. L. Semenov. Presburgerness of predicates regular in two number systems. Siberian Mathematical Journal, 18:289–299, 1977. 2, 4 R. K. Ranjan T. R. Shiple, J. H. Kukula. A comparison of Presburger engines for EFSM reachability. In Proc. 10th Int. Conf. on Computer Aided Verification, volume 1427 of Lecture Notes in Computer Science, pages 280– 292, Vancouver, July 1998. Springer-Verlag. 3 Moshe Y. Vardi and Pierre Wolper. An automata-theoretic approach to automatic program verification. In Proceedings of the First Symposium on Logic in Computer Science, pages 322–331, Cambridge, June 1986. 1 Moshe Y. Vardi and Pierre Wolper. Reasoning about infinite computations. Information and Computation, 115(1):1–37, November 1994. 1 Pierre Wolper and Bernard Boigelot. An automata-theoretic approach to Presburger arithmetic constraints. In Proc. Static Analysis Symposium, volume 983 of Lecture Notes in Computer Science, pages 21–32, Glasgow, September 1995. Springer-Verlag. 2, 4 Pierre Wolper, Moshe Y. Vardi, and A. Prasad Sistla. Reasoning about infinite computation paths. In Proc. 24th IEEE Symposium on Foundations of Computer Science, pages 185–194, Tucson, 1983. 1

An Extensible Type System for Component-Based Design Yuhong Xiong and Edward A. Lee {yuhong, eal}@eecs.berkeley.edu

Abstract. We present the design and implementation of the type system for Ptolemy II, which is a tool for component-based heterogeneous modeling and design. This type system combines static typing with run-time type checking. It supports polymorphic typing of components, and allows automatic lossless type conversion at run-time. To achieve this, we use a lattice to model the lossless type conversion relation among types, and use inequalities defined over the type lattice to specify type constraints in components and across components. The system of inequalities can be solved efficiently, with existence and uniqueness of a solution guaranteed by fixed-point theorems. This type system increases the safety and flexibility of the design environment, promotes component reuse, and helps simplify component development and optimization. The infrastructure we have built is generic in that it is not bound to one particular type lattice. The type system can be extended in two ways: by adding more types to the lattice, or by using different lattices to model different system properties. Higher-order function types and extended types can be accommodated in this way.

1

Introduction

Ptolemy II [5] is a system-level design environment that supports component-based heterogeneous modeling and design. The focus is on embedded systems. In component-based design, each component has an interface, which includes the data type of the messages sent or received by the component, and the communication protocols used by the component to exchange information with others. In Ptolemy II, the interconnection of components is represented by hierarchical clustered graphs. Interconnections imply type constraints. In addition, components themselves may have constraints on their interface and internal state variables. A good type system is particularly important for embedded systems. A type system can increase safety though type checking, promote component reuse through polymorphic typing, provide services such as automatic type conversion, and help optimize the design by finding low cost typing for polymorphic components. Ptolemy II supports heterogeneous design by providing a variety of models of computation (MoCs) [5]. It can be viewed as a coordination language where it manS. Graf and M. Schwartzbach (Eds.) TACAS/ETAPS 2000, LNCS 1785, pp. 20-37, 2000.  Springer-Verlag Berlin Heidelberg 2000

An Extensible Type System for Component-Based Design

21

ages the communication among independent components without much knowledge about the computation they carry out. In this regard, it is similar to other coordination languages like Manifold [2]. In different MoCs, component interaction obeys different semantics. However, this level of detail can be ignored in data level type system design, and a general message passing semantics can be assumed. This abstraction enables the same type system to work with widely differing models. Fig.1 shows a simplified graph representation of a Ptolemy II model. In Ptolemy II terminology, each of the components A, B, and C is an actor, and actors contain ports, denoted by the small circles on the actors. Actors send and receive messages through ports. Messages are encapsulated in tokens, which are typed. In general-purpose languages, there are two approaches for type system design: static typing and dynamic typing. Research in this area is driven to a large degree by the desire to combine the flexibility of dynamically typed languages with the security and early error-detection potential of statically typed languages. Polymorphic type systems of modern languages have achieved this goal to a large extent [14]. Since Ptolemy II is intended for large, complex, and possibly safety-critical system design, we choose static typing for its obvious advantages. To do this, we give each actor port a type. This type restricts the type of tokens that can pass though the port. Based on the port types and the graph topology, we can check the type consistency in the model statically, before it is executed. In Ptolemy II, static checking alone is not enough to ensure type safety at run-time because Ptolemy II is a coordination language, its type system does not have detailed information about the operation of each actor, except the declared types of the ports and the type constraints provided by the actors. In fact, Ptolemy II places no restriction on the implementation of an actor. So an actor may wrap a component implemented in a different language, or a model built by a foreign tool [11]. Therefore, even if a source actor declares its port type to be Int, no static structure prevents it from sending a token containing Double at run-time. The declared type Int in this case is only a promise from the actor, not a guarantee. Analogous to the run-time type checking in Java, the components are not trusted. Static type checking checks whether the components can work together as connected based on the information given by each component, but run-time type checking is also necessary for safety. With the help of static typing, run-time type checking can be done when a token is sent from a port. I.e., the run-time type checker checks the token type against the type of the port. This way, a type error is detected at the earliest possible time, and run-time type checking (as well as static type checking) can be performed by the system infrastructure instead of by the actors. Another benefit of static typing is that it allows the system to perform lossless type conversion. For example, if a sending port with type Int is connected to a receiving port with type Double, the integer token sent from the sender can be

22

Yuhong Xiong and Edward A. Lee

converted to a double token before it is passed to the receiver. This kind of run-time type conversion is done transparently by the Ptolemy II system (actors are not aware it). So the actors can safely cast the received tokens to the type of the receiving port. This makes actor development easier. As a design principle of Ptolemy II, the system does not implicitly perform data type conversions that lose information. The lossless type conversion relation among different types is modeled as a partially ordered set, called the type lattice. In Ptolemy II, polymorphic actors are actors that can accept multiple types on their ports. In general, the types on some or all of the ports of a polymorphic actor are not rigidly defined to specific types when the actor is written, so the actor can interact

Fig. 1. A simplified Ptolemy II model.

with other actors having different types. The acceptable types on polymorphic actors are described by a set of type constraints, which have the form of inequalities defined over the type lattice. The static type checker checks the applicability of a polymorphic actor in a topology (an interconnection of components) by finding specific types for them that satisfy the type constraints. This process, called type resolution, can be done by a very efficient algorithm. In addition to maintaining type consistency for data transfer, our type system plays a larger role. In a component-based architecture, there are two ways to get data to components: static configuration (via parameters) and dynamic message passing (via ports). Our system allows constraints on the types of parameters, as well as the types of ports. In addition, Ptolemy II permits state variables that are local to a component to be typed, so type constraints between ports, parameters, and state variables can all be expressed. Besides the models based on message passing, Ptolemy II also supports control oriented models, such as finite state machines (FSM), which represent a system as a sequence of state transitions in response to events. In this model, type constraints can link the transition guard and the event of the state machine. Hierarchical FSMs can be mixed with other concurrency models [7]. In these mixed models, type constraints can be propagated between the events of the control model and the data of the other concurrency models. Section 4.2 below shows an example of this.


23

Our type system is related to the work of Fuh and Mishra [6] that extended polymorphic type inference in ML [12] with subtypes. The lossless type conversion relation is a subtype relation. However, there are several key differences between our approach and the ML type system and the system of Fuh and Mishra. First, the ML type inference algorithm produces principal types. Principal types are the most general types for a program in that any other legal type assignment is a substitution instance of it. In our system, the type resolution algorithm finds the most specific type rather than the most general type. This specific type is the least fixed point solution for the type constraints rather than the greatest fixed point. As we will see, using the most specific type may help optimize the system under design, as the most specific type usually has a lower implementation cost. Second, the ML type system does all the checking statically, while our system combines static and run-time checking. As discussed above, we assume that the system components are opaque to the type system. The type system does not have detailed knowledge of the operation of the components, so static checking alone cannot guarantee run-time safety. Our combined approach can detect errors at the earliest possible time and minimize the computation of run-time checking. Third, the system of Fuh and Mishra allows arbitrary type conversion, represented by a coercion set, while our system concentrates on lossless conversion. This focus permits the conversion relation to form a lattice structure, and the type constraints to be expressed as inequalities on the lattice. As a result, the type constraints can be solved by a linear time algorithm, which is more efficient than the algorithm to check the consistency of a coercion set. The advantage of a constraint-based approach, like ours, is that constraint resolution can be separated from constraint generation, and resolution can employ a sophisticated algorithm. Although the users need to understand the constraint formulation, they do not have to understand the details of the resolution algorithm in order to use the system. In addition, the constraint resolution algorithm can be built as a generic tool that can be used for other applications. Even more important in Ptolemy II, the types are not aware of the constraints, so more types can be added to the type lattice, resulting in an extensible type system.

2

Ptolemy II

Ptolemy II offers a unified infrastructure for implementation of a number of models of computation. It consists of a set of Java packages. The key packages relevant to the type system are the kernel, actor, data, and graph packages.

2.1

The Kernel Package

The kernel package defines a small set of Java classes that implement a data structure

24


supporting a general form of uninterpreted clustered graphs, plus methods for accessing and manipulating such graphs. These graphs provide an abstract syntax for netlists, state transition diagrams, block diagrams, etc. A graph consists of entities and relations. Entities have ports. Relations connect entities through ports. Relations are multi-way associations. Hierarchical graphs can be constructed by encapsulating one graph inside the composite entity of another graph. This encapsulation can be nested arbitrarily.

2.2

The Actor Package

The actor package provides basic support for executable entities, or actors. It supports a general form of message passing between actors. Messages are passed between ports, which can be inputs, outputs or bidirectional ports. Actors can be typed, which means that their ports have a type. The type of the ports can be declared by the containing actor, or left undeclared on polymorphic actors; type resolution will resolve the types according to type constraints. Messages are encapsulated in tokens that are implemented in the data package or in user-defined classes extending those in the data package. A subpackage of the actor package contains a library of (currently) about 40 polymorphic actors.

2.3

The Data Package

The data package provides data encapsulation, polymorphism, parameter handling, and an expression language. Data encapsulation is implemented by a set of token classes. For example, IntToken contains an integer, DoubleMatrixToken contains a two-dimensional array of doubles. The tokens can be transported via message passing between Ptolemy II objects. Alternatively, they can be used to parameterize Ptolemy II objects. Such encapsulation allows for a great degree of extensibility, permitting developers to extend the library of data types that Ptolemy II can handle. One of the goals of the data package is to support polymorphic operations between tokens. For this, the base Token class defines methods for the primitive arithmetic operations, such as add(), multiply(), subtract(), divide(), modulo() and equals(). Derived classes override these methods to provide class specific operations where appropriate. Parameter handling and an extensible expression language, including its interpreter, are supported by a subpackage inside the data package. A parameter contains a token as its value. This token can be set directly, or specified by an expression. An expression may refer to other parameters, and dependencies and type relationships between parameters are handled transparently.


2.4

25

The Graph Package

This package provides algorithms for manipulating and analyzing mathematical graphs. Mathematical graphs are simpler than Ptolemy II clustered graphs in that there is no hierarchy, and arcs link exactly two nodes. Both undirected and directed graphs are supported. Acyclic directed graphs, which can be used to model complete partial orders (CPOs) and lattices [4], are also supported with more specialized algorithms. This package provides the infrastructure to construct the type lattice and implement the type resolution algorithm. However, this package is not aware of the types; it supplies generic tools that can used in different applications.

3

Type System Formulation

3.1

The Type Lattice

A lattice is a partially ordered set in which every subset of elements has a least upper bound and a greatest lower bound [4]. This mathematical structure is used to represent the lossless type conversion relation in a type system. An example of a type lattice is shown in Fig.2. This particular lattice is constructed in the data package using the infrastructure of the graph package. In the diagram, type α is greater than type β if there is a path upwards from β to α. Thus, ComplexMatrix is greater than Int. Type α is less than type β if there is a path downwards from β to α. Thus, Int is less than ComplexMatrix. Otherwise, types α and β are incomparable. Complex and Long, for example, are incomparable. The top element, General, which is “the most general type,” corresponds to the base token class; the bottom element, NaT (Not a Type), does not correspond to a token. Users can extend a type lattice by adding more types. In the type lattice, a type can be losslessly converted to any type greater than it. For example, an integer can be losslessly converted to a double. Here, we assume an integer is 32 bits long and a double is 64 bits using the IEEE 754 floating point format, as in Java. This hierarchy is related to the inheritance hierarchy of the token classes in that a subclass is always less than its super class in the type lattice, but some adjacent types in the lattice are not related by inheritance. So this hierarchy is a combination of the subtyping relation in object oriented languages, and ad hoc subtyping rules, such as Int ≤ Double [13]. Organizing types in a hierarchy is fairly standard. For example, Abelson and Sussman [1] organized the coercion relation among types in a hierarchy. However, they did not deliberately model the hierarchy as a lattice. Long ago, Hext [9] experimented with using a lattice to model the type conversion relation, but he was not working with an object oriented language and did not intend to support polymorphic system components. This work predates the popular use of those concepts.

26


Fig. 2. An example of a type lattice.

Type conversion is done by a method convert() in the token classes. This method converts the argument into an instance of the class implementing this method. For example, DoubleToken.convert(Token token) converts the specified token into an instance of DoubleToken. The convert() method can convert any token immediately below it in the type hierarchy into an instance of its own class. If the argument is several levels down the type hierarchy, the convert() method recursively calls the convert() method one level below to do the conversion. If the argument is higher in the type hierarchy, or is incomparable with its own class, convert() throws an exception. If the argument to convert() is already an instance of its own class, it is returned without any change.

3.2

Type Constraints

In Ptolemy II, to guarantee that information is not lost during data transfer, we require the type of a port that sends tokens to be the same as or lower than the type of the receiving port:

sendType ≤ receiveType

(1)


27

If both the sendType and receiveType are declared, the static type checker simply checks whether this inequality is satisfied, and reports a type conflict if it is not. In addition to the above constraint imposed by the topology, actors may also impose constraints among ports and parameters. For example, the Ramp actor in Ptolemy II, which is a source actor that produces a token on each execution with a value that is incremented by a specified step, stores the first output and the step value in two parameters. This actor will not declare the type of its port, but will specify the constraint that the port type is greater than or equal to the types of the two parameters. As another example, a polymorphic Distributor actor, which splits a single token stream into a set of streams, will specify the constraint that the type of a sending port is greater than or equal to that of the receiving port. This Distributor will be able to work on tokens of any type. In general, polymorphic actors need to describe the acceptable types through type constraints. All the type constraints in Ptolemy II are described in the form of inequalities like the one in (1). If a port or a parameter has a declared type, its type appears as a constant in the inequalities. On the other hand, if a port or a parameter has an undeclared type, its type is represented by a type variable in the inequalities. The domain of the type variable is the elements of the type lattice. The type resolution algorithm resolves the undeclared types in the constraint set. If resolution is not possible, a type conflict error will be reported. As an example of a constraint set, consider Fig.3. The port on actor A1 has declared type Int; the ports on A3 and A4 have declared type Double; and the ports on A2 have their types undeclared. Let the type variables for the undeclared types be α, β, and γ; the type constraints from the topology are: Int ≤ α Double ≤ β γ ≤ Double Now, assume A2 is a polymorphic adder, capable of doing addition for integer, double, and complex numbers. Then the type constraints for the adder can be written as:

Fig. 3. A topology (interconnection of components) with types.

28


α≤γ β≤γ γ ≤ Complex The first two inequalities constrain the precision of the addition result to be no less than that of the summands, the last one requires that the data on the adder ports can be converted to Complex losslessly. These six inequalities form the complete set of constraints and are used by the type resolution algorithm to solve for α, β, and γ. This inequality formulation is inspired by the type inference algorithm in ML [12]. There, type equations are used to represent type constraints. In Ptolemy II, the lossless type conversion hierarchy naturally implies inequality relations among the types instead of equalities. In ML, the type constraints are generated from program constructs. In a heterogeneous graphical programming environment like Ptolemy II, where details of the components are hidden, the system does not have enough information about the function of the actors, so the actors must present their type information by either declaring the type on their port, or by specifying a set of type constraints to describe the acceptable types on the undeclared ports. The Ptolemy II system also generates type constraints based on (1). This formulation converts type resolution into a problem of solving a set of inequalities defined over a finite lattice. An efficient algorithm for doing this is given by Rehof and Mogensen [15]. The appendix of this paper describes this algorithm through an example. Essentially, the algorithm starts by assigning all the type variables the bottom element of the type hierarchy, NaT, then repeatedly updating the variables to a greater element until all the constraints are satisfied, or until the algorithm finds that the set of constraints are not satisfiable. This process can be formulated as the search for the least fixed point of a monotonic function on the lattice. The least fixed point is the set of most specific types. It is unique [4], and satisfies the constraints if it is possible to satisfy the constraints. If the set of type constraints are not satisfiable, or some type variables are resolved to NaT, the static type checker flags a type conflict error. The former case can happen, for example, if the port on actor A1 in figure Fig.3 has declared type Complex. The latter can happen if an actor does not specify any type constraints on an undeclared sending port. If the type constraints do not restrict a type variable to be greater than NaT, it will stay at NaT after resolution. To avoid this, any sending port must either have a declared type, or some constraints to force its type to be greater than NaT. A solution satisfying the constraints may not be unique. In fact, the algorithm given in [15] can be used to find either the most specific solution (least in the lattice) or the most general solution (greatest in the lattice). The ML type inference algorithm finds the most general types for a given program, which allows maximal reuse of compiled code. In our case, multiple occurrences of an actor in a topology are treated


29

as different actors, even though they specify the same set of type constraints, so we do not need to use the most general type. In fact, our choice of using the most specific types has a key advantage: types lower in the type lattice usually have a lower implementation cost. For example, in embedded system design, hardware is often synthesized from a component-based description of a system. If a polymorphic adder is going be synthesized into hardware, and it receives Int tokens and sends the addition result to a Double port, our scheme will resolve the types of all the ports on the adder to Int, rather than Double. Using an integer adder will be more economical than a double adder. This is analogous to using types to generate more optimized code in compilers.

3.3

Run-Time Type Checking and Lossless Type Conversion

The declared type is a contract between an actor and the Ptolemy II system. If an actor declares that a sending port has a certain type, it asserts that it will only send tokens whose types are less than or equal to that type. If an actor declares a receiving port to have a certain type, it requires the system to only send tokens that are instances of the class of that type to that port. Run-time type checking is the component in the system that enforces this contract. When a token is sent from a sending port, the run-time type checker finds its type, and compares it with the declared type of the port. If the type of the token is not less than or equal to the declared type, a run-time type error will be reported. As discussed before, type conversion is needed when a token sent to a receiving port has a type less than the type of that port but is not an instance of the class of that type. Since this kind of lossless conversion is done automatically, an actor can safely cast a received token to the declared type. On the other hand, when an actor sends tokens, the tokens being sent do not have to have the exact declared type of the sending port. Any type that is less than the declared type is acceptable. For example, if a sending port has declared type Double, the actor can send IntToken from that port without having to convert it to a DoubleToken, since the conversion will be done by the system. So the automatic type conversion simplifies the input/output handling of the actors. Note that even with the convenience provided by the type conversion, actors should still declare the receiving types to be the most general that they can handle and the sending types to be the most specific that includes all tokens they will send. This maximizes their applications. In the previous example, if the actor only sends IntToken, it should declare the sending type to be Int to allow the port to be connected to a receiving port with type Int. If an actor has ports with undeclared types, its type constraints can be viewed as both a requirement and an assertion from the actor. The actor requires the resolved

30


types to satisfy the constraints. Once the resolved types are found, they serve the role of declared types at run time. I.e., the type checking and type conversion system guarantees to only put tokens that are instances of the class of the resolved type to receiving ports, and the actor asserts to only send tokens whose types are less than or equal to the resolved type from sending ports.

3.4

Discussion of Type Resolution and Polymorphism

Rehof and Mogensen proved that their algorithm for solving inequality constraints is linear time in the number of occurrences of symbols in the constraints, which in our case, can be translated into linear time in the number of constraints. This makes type resolution very efficient. On the other hand, one might be tempted to extend the formulation to achieve more flexibility in type specification. For example, it would be nice to introduce a OR relation among the constraints. This can be useful, in the case of a two-input adder, for specifying the constraint that the types of the two receiving ports are comparable. This constraint will prohibit tokens with incomparable types to be added. As shown in [15], this cannot be easily done. The inequality constraint problem belongs to the class of meet-closed problems. Meet-closed, in our case, means that if A and B are two solutions to the constraints, their greatest lower bound in the lattice is also a solution. This condition guarantees the existence of the least solution, if any solution exists at all. Introducing the OR relation would break the meet-closed property of the problem. Rehof and Mogensen also showed that any strict extension of the class of meet-closed problems solved by their algorithm will lead to an NP-complete problem. So far, the inequality formulation is generally sufficient for our purpose, but we are still exploring its limitations and workarounds. We have been using the term polymorphic actor broadly to mean the actors that can work with multiple types on their ports. In [3], Cardelli and Wegner distinguished two broad kinds of polymorphism: universal and ad hoc polymorphism. Universal polymorphism is further divided into parametric and inclusion polymorphism. Parametric polymorphism is obtained when a function works uniformly on a range of types. Inclusion polymorphism appears in object oriented languages when a subclass can be used in place of a superclass. Ad hoc polymorphism is also further divided into overloading and coercion. In terms of implementation, a universally polymorphic function will usually execute the same code for different types, whereas an ad-hoc polymorphic functions will execute different code. In an informal sense, Ptolemy II exhibits all of the above kinds of polymorphism. The Distributor actor, discussed in section 3.2 shows parametric polymorphism because it works with all types of tokens uniformly. If an actor declares its receiving type to be General, which is the type of the base token class, then that actor can accept any type of token since all the other token classes are derived from the base


31

token class. This is inclusion polymorphism. The automatic type conversion during data transfer is a form of coercion; it allows an receiving port with type Complex, for example, to be connected to sending ports with type Int, Double or Complex. An interesting case is the arithmetic and logic operators, like the Add actor. In most languages, arithmetic operators are overloaded, but different languages handle overloading differently. In standard ML, overloading of arithmetic operators must be resolved at the point of appearance, but type variables ranging over equality types are allowed for the equality operator [16]. In Haskell, type classes are used to provide overloaded operations [8]. Ptolemy II takes advantage of data encapsulation. The token classes in Ptolemy II are not passive data containers, they are active data in the sense that they know how to do arithmetic operations with another token. This way, the Add actor can simply call the add() method of the tokens, and work consistently on tokens of different type. An advantage of this design is that users can develop new token types with their implementation for the add() method, achieving an effect similar to user defined operator overloading in C++.

4

Examples

This section provides two examples of type resolution in Ptolemy II.

4.1

Fork Connection

Consider two simple topologies in Fig.4. where a single sending port is connected to two receiving ports in Fig.4(a) and two sending ports are connected to a single receiving port in Fig.4(b). Denote the types of the ports by a1, a2, a3, b1, b2, b3, as indicated in the figure. Some possibilities for legal and illegal type assignments are:

•

In Fig.4(a), if a1 = Int, a2 = Double, a3 = Complex. The topology is well typed. At run-time, the IntToken sent out from actor A1 will be converted to DoubleToken before transferred to A2, and converted to ComplexToken before transferred to A3. This shows that multiple ports with different types can be interconnected as long as the sender type can be losslessly converted to the receiver type.

Fig. 4. Two simple topologies with types.

32


•

In Fig.4(b), if b1 = Int, b2 = Double, and b3 is undeclared. The the resolved type for b3 will be Double. If b1 = Int and b2 = Boolean, the resolved type for b3 will be String since it is the lowest element in the type hierarchy that is higher than both Int and Boolean. In this case, if the actor B3 has some type constraints that require b3 to be less than String, then type resolution is not possible, a type conflict will be signaled. A Java applet that demonstrates the situation in Fig.4(b) and shows the type resolution process is available at the URL: http://ptolemy.eecs.berkeley.edu/ ptolemyII/ ptII0.3/ptII0.3/ptolemy/domains/sdf/demo/Type/Type.htm

4.2 Mixing FSM and SDF In [7], Girault, Lee and Lee showed how to mix finite-state machines (FSMs) with other concurrency models. For example FSM can be mixed with synchronous dataflow (SDF) [10], as shown in Fig.5. In this figure, the top of the hierarchy is an SDF system. The middle actor B in this system is refined to a FSM with two states, each of which is further refined to a SDF subsystem. One type constraint on the receiving port of B is that its type must be less than or equal to the types of both of the receiving ports of the SDF subsystems D and E, because tokens may be transported from the receiving port of B to the receiving ports of D or E. Assuming the types of the receiving ports on D and E are Int and Double, respectively, type resolution will resolve the type of the receiving port of B to Int. Similarly, a type constraint for the sending port of B is that its type must be greater than or equal to the types of both of the sending ports of D and E, and its resolved type will be Double. Note that this result is consistent with function subtyping [13]. If we consider the order in the type lattice as subtype relations, and the actors as functions, then D: Int→Int, E: Double→Double, and B: α→β before type resolution. Since D and E can take the place of B during execution, their types should be considered as subtypes of the type of B. Since function subtyping is contravariant for function arguments and covariant for function results, the type α should be a subtype of Int and Double and β should be a super type of Int and Double. This is exactly what the type constraints specify, and the resulting type for B: Int→Double is indeed a supertype of both of the types of D and E.


33

Fig. 5. Mixing FSM with SDF.

5

Conclusion and Future Work

In the design of the Ptolemy II type system, we have taken the approach of polymorphic static typing combined with run-time type checking. We use a lattice structure to model the lossless type conversion relation and provide automatic type conversion during data transfer. Polymorphism is supported by allowing the system components to specify type constraints, and a linear time algorithm is used for constraint resolution. This type system increases the safety and usability of the component-based design environment, promotes component reuse, and helps with design optimization. The infrastructure is built to operate on any type lattice, and so can be used to experiment with extended type systems. Currently, we are working on extending this system to support structured types such as array and record types. The goal is to allow the elements of arrays and records to contain tokens of arbitrary types, including structured types, and to be able to specify type constraints on them. One of the major difficulty with this extension is that the type lattice will become infinite, which raises questions on the convergence of type resolution. In the longer term, we will try to characterize the communication protocols used between system components, or some of the real-time properties of the system as types, and design a process-level type system to facilitate heterogeneous real-time modeling. This may potentially bring some of the benefit of data typing to the process level.

34


Acknowledgments This work is part of the Ptolemy project, which is supported by the Defense Advanced Research Projects Agency (DARPA), the State of California MICRO program, and the following companies: The Cadence Design Systems, Hewlett Packard, Hitachi, Hughes Space and Communications, Motorola, NEC, and Philips.

Appendix The Type Resolution Algorithm The type resolution algorithm starts by assigning all the type variables the bottom element of the type hierarchy, NaT, then repeatedly updating the variables to a greater element until all the constraints are satisfied, or until the algorithm finds that the set of constraints are not satisfiable. This iteration can be viewed as repeated evaluation of a monotonic function, and the solution is the least fixed point of the function. The kind of inequality constraints for which the algorithm can determine satisfiability are the ones with the greater term being a variable or a constant. By convention, we write inequalities with the lesser term on the left and the greater term on the right, as in α ≤ β, not β ≥ α. The algorithm allows the left side of the inequality to contain monotonic functions of the type variables, but not the right side. The first step of the algorithm is to divide the inequalities into two categories, Cvar and Ccnst. The inequalities in Cvar have a variable on the right side, and the inequalities in Ccnst have a constant on the right side. In the example of Fig.3, Cvar consists of: Int ≤ α Double ≤ β α≤γ β≤γ And Ccnst consists of: γ ≤ Double γ ≤ Complex The repeated evaluations are only done on Cvar, Ccnst are used as checks after the iteration is finished, as we will see later. Before the iteration, all the variables are assigned the value NaT, and Cvar looks like: Int ≤ α(NaT) Double ≤ β(NaT) α(NaT) ≤ γ(NaT) β(NaT) ≤ γ(NaT) Where the current value of the variables are inside the parenthesis next to the variable. At this point, Cvar is further divided into two sets: those inequalities that are not currently satisfied, and those that are satisfied:


35

Not-satisfied Satisfied Int ≤ α(NaT) α(NaT) ≤ γ(NaT) β(NaT) ≤ γ(NaT) Double ≤ β(NaT) Now comes the update step. The algorithm selects an arbitrary inequality from the Not-satisfied set, and forces it to be satisfied by assigning the variable on the right side the least upper bound of the values of both sides of the inequality. Assuming the algorithm selects Int ≤ α(NaT), then

(2)α = Int∨NaT = Int After α is updated, all the inequalities in Cvar containing it are inspected and are switched to either the Satisfied or Not-satisfied set, if they are not already in the appropriate set. In this example, after this step, Cvar is: Not-satisfied Satisfied Int ≤ α(Int) Double ≤ β(NaT) α(Int) ≤ γ(NaT) β(NaT) ≤ γ(NaT) The update step is repeated until all the inequalities in Cvar are satisfied. In this example, β and γ will be updated and the solution is: α = Int, β = γ = Double Note that there always exists a solution for Cvar. An obvious one is to assign all the variables to the top element, General, although this solution may not satisfy the constraints in Ccnst. The above iteration will find the least solution, or the set of most specific types. After the iteration, the inequalities in Ccnst are checked based on the current value of the variables. If all of them are satisfied, a solution to the set of constraints is found. As mentioned earlier, the iteration step can be seen as a search for the least fixed point of a monotonic function. In this view, the computation in (2) is the application of a monotonic function to type variables. Let L denote the type lattice. In an inequality r ≤ α, where α is a variable, and r is either a variable or a constant, the update function f: L2 → L is α’ = f(r, α) = r ∨ α. Here, α represents the value of the variable before the update, and α’ represents the value after the update. f can easily be seen to be monotonic and non-decreasing. And, since L is finite, it satisfies the ascending chain condition, so f is also continuous. Let the variables in the constraint set be α1, α2, ... , αN, where N is the total number of variables, and define Α = (α1, α2, ... , αN). The complete iteration can be viewed as repeated evaluation of a function F: LN → LN of Α, where F is the composition of the individual update functions. Clearly, F is also continuous. The iteration starts with the variables initialized to the bottom, Α = ⊥N, and computes the sequence Fi(⊥N) (i ≥ 0), which is a non-decreasing chain. By

36


the fixed point theorem in [4], the least upper bound of this chain is the least fixed point of F, corresponding to the most specific types in our case. Rehof and Mogensen [15] proved that the above algorithm is linear time in the number of occurrences of symbols in the constraints, and gave an upper bound on the number of basic computations. In our formulation, the symbols are type constants and type variables, and each constraint contains two symbols. So the type resolution algorithm is linear in the number of constraints.

References 1.

H. Abelson and G. J. Sussman, Structure and Interpretation of Computer Programs, The MIT Press, 1985.

2.

F. Arbab, MANIFOLD Version 2.0, CWI, Software Engineering Cluster, Kruislaan 413, 1098 SJ Amsterdam, The Netherlands, June, 1998.

3.

L. Cardelli and P. Wegner, “On Understanding Types, Data Abstraction, and Polymorphism,” ACM Computing Surveys, Vol.17, No.4, Dec. 1985.

4.

B. A. Davey and H. A. Priestly, Introduction to Lattices and Order, Cambridge University Press, 1990.

5.

J. Davis II, M. Goel, C. Hylands, B. Kienhuis, E. A. Lee, J. Liu, X. Liu, L. Muliadi, S. Neuendorffer, J. Reekie, N. Smyth, J. Tsay and Y. Xiong, Overview of the Ptolemy Project, ERL Technical Report UCB/ERL No. M99/37, Dept. EECS, University of California, Berkeley, CA 94720, July 1999. (http:// ptolemy.eecs.berkeley.edu/publications/papers/99/HMAD/)

6.

Y-C. Fuh and P. Mishra, “Type Inference with Subtypes,” Second European Symposium on Programming, Nancy, France, 1988.

7.

A. Girault, B. Lee, and E. A. Lee, “Hierarchical Finite State Machines with Multiple Concurrency Models,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, Vol.18, No.6, June 1999.

8.

C. V. Hall, K. Hammond, S.L. Peyton Jones, and P. L. Wadler, “Type Classes in Haskell,” ACM Transactions on Programming Languages, Vol.18, No.2, Mar. 1996.

9.

J. B. Hext, “Compile-Time Type-Matching,” Computer Journal, 9, 1967.

10. E. A. Lee and D. G. Messerschmitt, “Static Scheduling of Synchronous Data Flow Programs for Digital Signal Processing,” IEEE Transaction on Computer, Jan. 1987. 11. J. Liu, B. Wu, X. Liu, and E. A. Lee, “Interoperation of Heterogeneous CAD Tools in Ptolemy II,” Symposium on Design, Test, and Microfabrication of MEMS/MOEMS, Paris, France, Mar. 1999.


37

12. R. Milner, “A Theory of Type Polymorphism in Programming,” Journal of Computer and System Sciences, 17, pp. 384-375, 1978. 13. J. C. Mitchell, Foundations for Programming Languages, The MIT Press, 1998. 14. M. Odersky, “Challenges in Type Systems Research,” ACM Computing Surveys, Vol.28, No.4es, 1996. 15. J. Rehof and T. Mogensen, “Tractable Constraints in Finite Semilattices,” Third International Static Analysis Symposium, LNCS 1145, Springer, Sept., 1996. 16. J. D. Ullman, Elements of ML Programming, Prentice Hall, 1998.

Proof General: A Generic Tool for Proof Development David Aspinall LFCS, University of Edinburgh, U.K. http://www.dcs.ed.ac.uk/home/da

Abstract. This note describes Proof General, a tool for developing machine proofs with an interactive proof assistant. Interaction is based around a proof script, which is the target of a proof development. Proof General provides a powerful user-interface with relatively little effort, alleviating the need for a proof assistant to provide its own GUI, and providing a uniform appearance for diverse proof assistants. Proof General has a growing user base and is currently used for several interactive proof systems, including Coq, LEGO, and Isabelle. Support for others is on the way. Here we give a brief overview of what Proof General does and the philosophy behind it; technical details are available elsewhere. The program and user documentation are available on the web at http://www.dcs.ed.ac.uk/home/proofgen.

1

Background

Proof General is a generic interface for interactive proof assistants. A proof assistant is a computerized helper for developing machine proofs. There are many uses for machine proofs, both during the specification, development, and verification of software and hardware systems, and in the development and teaching of mathematical proof and formal logic. Proof General helps with developing proof scripts. A proof script is a sequence of commands sent to a proof assistant to construct a machine proof. A script is usually stored in a file. Roughly, a proof script is like a program written in a scripting programming language, and in particular, a language which has an interactive interpreter. Proof General uses a technique called script management to help the user write a proof script without using cut-and-paste or repeatedly typing “load file” commands. Proof General has a sophisticated implementation of script management which covers large developments spread across multiple files. A guiding philosophy behind Proof General is to provide an interface which is useful to novices and expert-users alike. Some interfaces for theorem provers are aimed at novices and become infeasible for large developments; others are aimed at experts but have steep learning curves or require changes in work methods, discouraging their take-up. With this in mind, Proof General builds S. Graf and M. Schwartzbach (Eds.): TACAS/ETAPS 2000, LNCS 1785, pp. 38–43, 2000. c Springer-Verlag Berlin Heidelberg 2000

Proof General: A Generic Tool for Proof Development

39

on the programmable text editor Emacs, the powerful everyday editor of many computer scientists. Emacs brings many advantages. It is available on most platforms, including Unix, Linux, and NT. Although it once had a reputation for being hard to learn, modern versions of Emacs are very user-friendly, supporting the whole gamut of current GUI technologies and providing easy customization mechanisms. Another important aspect of Proof General is that it is generic. It provides a uniform interface and interaction mechanism for different back-end proof assistants. It exploits the deep similarities between systems by hiding some of their superficial differences. This generic aspect is no empty claim or untested design goal; Proof General is already in use for three different proof assistants: Coq, LEGO, and Isabelle. Support for more is on the way. The present implementation of Proof General is oriented towards proof assistants based on a single-threaded interactive command interpreter (or shell ), where interaction consists of a dialogue between the user and the system. Several proof assistants have this kind of architecture, allowing more elaborate interfaces to be built on top. As a spin-off, building Proof General has suggested some useful design guidelines for the command protocol which should be implemented in a proof assistant shell. To summarize, Proof General provides a fairly elaborate yet unobtrusive interface. It gives the proof assistant user many useful features, and allows the proof assistant implementor to concentrate on the proof engine.

2

Features of Proof General

Simplified communication. The proof assistant’s shell is hidden from the user. Communication takes place via two or three buffers (Emacs text widgets). The script buffer holds input, the commands to construct a proof. The goals buffer displays the current list of subgoals to be solved. The response buffer displays other output from the proof assistant. The user sees only the output from the latest proof step, rather than a screen full of output. Nonetheless, the user can still access the shell to examine it or run commands. Script management. Proof script editing is connected to the proof process, maintaining consistency between the edit window and the state of the proof assistant. Visual feedback on the state of the assistant is given by colouring the background of the text in the editing windows. Parts of a proof script that have been processed are displayed in blue and moreover can be locked to prevent accidental editing. Parts of the script currently being processed by the proof assistant are shown in red. The screenshot in Figure 1 shows script managament in action. Multiple file handling. Script management also works across multiple files. When a script is loaded in the editor, it is coloured to reflect whether the proof assistant has processed it in this session. Proof General communicates with the assistant to discover dependencies between script files. If I want to edit a file

40

David Aspinall

which has been processed already, Proof General will retract the file and all the files which depend on it, unlocking them. Thus the editor is connected to the theory dependency or make system of the proof assistant. Proof by Pointing. Clicking on a subterm of a goal can apply an appropriate rule or tactic automatically, or display a menu of choices. Proof General relies on support in the assistant to mark-up subterms and generate tactics for this feature, since it is specific to the prover’s syntax and logic. Subterm mark-up also makes it easy to explore compilicated terms, and cut and paste from within them. Syntax highlighting and symbol fonts. Proof scripts are decorated: proof commands are highlighted and different fonts can be used for definitions and assumptions, for example. Symbol fonts can be used to display proper glyphs for logical operators, Greek letters, etc, which occur throughout mathematical proofs. Toolbar and menus. A toolbar includes buttons for examining the proof state, starting a proof, manoeuvring in the proof script, saving a proof, searching for a theorem, interrupting the assistant, and getting help. A menu gives access to further commands, and a useful collection of user preferences. Using the toolbar, you can replay proofs without knowing any low-level commands of the proof assistant or any Emacs short-cuts. Tags and definitions menu. Using a TAGS file, one can quickly locate the definition and uses of an identifier, automatically searching many files. Using a definitions menu, one can quickly navigate within a proof script to find particular definitions, declarations and proofs. Remote proof assistant. A proof assistant can be run remotely, perhaps across the internet, while Proof General and the proof script reside locally.

3

Proof General in Use

Figure 1 shows a screenshot of Proof General running in a single window on the screen. The window is split into two parts. The upper half displays the proof script Group.thy which is being processed. This is a script written for Isabelle using the new Isar proof language [4]. The lower half displays the current list of subgoals which are to be solved to complete the proof. Instead of this split window, it is perfectly possible to have separate windows on the screen, as the user likes. Proof General is even happy to run on a plain console, although graphical facilities will be reduced (e.g. no toolbar). In the script file, the cursor appears at the end of the locked region, which has a blue background to indicate it has already been processed. The arrow buttons on the toolbar are used to manipulate the locked region, by sending commands to the proof assistant, or by issuing undo steps. In this manner, a user can replay


41

Fig. 1. Using Proof General a proof interactively, without needing to know any low-level commands needed to start the proof assistant, or issue proof and undo steps. And without the extreme tedium of cut-and-paste.

4

Further Details

Technical references. Proof General has a detailed user manual [1] which also contains instructions for instantiating it to new proof assistants. The ideas of script management and proof by pointing were adapted from the CtCoq system [3]; proof by pointing in Proof General is described in an LFCS technical report [2]. (Proof General goes beyond CtCoq in some ways, but is less sophisticated in others; the biggest difference is that CtCoq provides its own GUI based on structure editing, which Proof General specifically avoids.) Future papers will describe the architecture of Proof General in more detail, including design guidelines for interactive proof development protocols, and plans for future directions.

42

David Aspinall

Implementation. Proof General is implemented in Emacs Lisp. There is a generic core (about 7000 lines) which implements the toolbar, menus, script management, and process handling features. Each supported proof assistant has some additional Emacs Lisp (30 – 500 lines) for prover-specific configuration: setting regular expressions and command strings, and perhaps providing extra features. For robust operation and features like proof by pointing, the proof assistant may need modification to output special messages for Proof General. Availability and System requirements. Proof General is easy to install, and is available free of charge (with sources and documentation) for research and educational use. The current release is Proof General 3.0. For best results, it requires a recent version of XEmacs (21.1 or later), alongside recent versions of one or more proof assistants: Coq (6.3 or later), Isabelle (version 99 or later), or Lego (version 1.3.1). Details of where to obtain these components can be found on the web page mentioned below. Success is guaranteed with a Unix (or Linux) environment, although XEmacs and some proof assistants are available for other operating systems, and there is nothing operating system specific in Proof General itself.

Acknowledgements Many people have contributed to the design and code, both in the generic basis and for the prover-specific instances. For each instance of Proof General, we try to encourage somebody familiar with the proof assistant to develop and maintain the prover-specific code, perhaps also enhancing to the generic basis. In order of appearance, the main workers on Proof General have been: T. Kleymann, Y. Bertot, D. Sequeira, H. Goguen, D. Aspinall, P. Loiseleur, M. Wenzel, P. Callaghan. Many other people provided useful feedback, including: P. Brisset, R. Burstall, M. Hofmann, J. McKinna, and D. von Oheimb. Thomas Kleymann originated the Proof General project. David Aspinall is the present manager. For more information about Proof General, please visit the home page at http://www.dcs.ed.ac.uk/home/proofgen.

References 1. D. Aspinall, H. Goguen, T. Kleymann, and D. Sequira. Proof General. System documentation, see http://www.dcs.ed.ac.uk/home/proofgen, 1999. 41 2. Yves Bertot, Thomas Kleymann, and Dilip Sequeira. Implementing proof by pointing without a structure editor. Technical Report ECS-LFCS-97-368, University of Edinburgh, 1997. 41 3. Yves Bertot and Laurent Théry. A generic approach to building user interfaces for theorem provers. Journal of Symbolic Computation, 25(7):161–194, February 1998. 41


43

4. Markus Wenzel. Isar — a generic interpretative approach to readable formal proof documents. In Y. Bertot, G. Dowek, A. Hirschowitz, C. Paulin, and L. Thery, editors, Theorem Proving in Higher Order Logics, 12th International Conference, TPHOLs’99, Lecture Notes in Computer Science 1690. Springer-Verlag, 1999. 40

ViewPoint-Oriented Software Development: Tool Support for Integrating Multiple Perspectives by Distributed Graph Transformation Michael Goedicke1, Bettina Enders1, Torsten Meyer1, and Gabriele Taentzer2 1

Specification of Software Systems, Department of Mathematics and Computer Science, University of Essen, Germany {goedicke, enders, tmeyer}@informatik.uni-essen.de 2 Theoretical Computer Science / Formal Specification Group, Department of Computing, Technical University of Berlin, Germany [email protected]

Abstract. Co-operative development of distributed software systems involves to address the multiple perspectives problem: many stakeholders with diverse domain knowledge and differing development strategies collaborate to construct heterogeneous development artifacts using different representation schemes. The ViewPoints framework has been developed for organizing multiple stakeholders, the development processes and notations they use, and the partial specifications they produce. In this contribution we present a tool environment supporting ViewPoint-oriented software development based on a formalization by distributed graph transformation.

1

Introduction and Related Work

In system design the various development stages are visited more than once and quite different notations and process models need to be integrated in order to satisfy the requirements of the different stakeholders’ views and their processes. It is therefore highly desirable to provide flexible conceptual means and related tool support for representing the various cooperating stakeholders’ views and process models. In this contribution we use the ViewPoints framework to represent such views and processes. In addition the ViewPoints framework involves to tolerate inconsistent information in related ViewPoints until it seems necessary or appropriate to check and (re)establish consistency -- at least in some parts of the system [1]. The ViewPoints framework has been used quite successfully and has been documented in the literature [2, 1, 4]. The question which is addressed here is how tool support can be constructed to effectively represent the loosely coupled approach: some local development within a ViewPoint is followed by interaction with related ViewPoints via consistency checks. The approach of distributed graph transformation supports the idea of loosely coupled ViewPoints as outlined above quite naturally. It realizes the separation between

S. Graf and M. Schwartzbach (Eds.) TACAS/ETAPS 2000, LNCS 1785, pp. 43-47, 2000.  Springer-Verlag Berlin Heidelberg 2000

44

Michael Goedicke et al.

the independent development of single local ViewPoints and the configuration and connection of a set of related ViewPoints in a structured way. Distributed graph transformation which is based on the double-pushout approach to algebraic graph transformation is introduced formally in [6]. Using AGG [7] as a computing platform an adequate level of tool support can easily be constructed. The manipulation of representation schemes is expressed as graph transformation rules and the interaction and cooperation of distributed ViewPoints is adequately formulated as distributed graph transformation rules. As a result we gain tool support for ViewPoints and a corresponding formal presentation [5, 4]. As such it provides the possibility for formal analysis and most importantly a great deal of flexibility for integrating new ViewPoints. The ViewPoints framework was devised by A. Finkelstein et al. [2] to describe complex systems. An overview of other approaches related to multiple perspectives in software development can be found in [3]. In [1] a general overview wrt inconsistency management within the ViewPoints framework is given. In the chapter The ViewPoints Framework we introduce briefly our approach to ViewPoint-oriented software development. Based upon this we present tool support for our approach in the chapter The ViewPoint Tool.

2

The ViewPoints Framework

A ViewPoint is defined to be a locally managed object or agent which encapsulates partial knowledge about the system and its domain. It contains partial knowledge of the design process [2]. The knowledge is specified in a particular, suitable representation scheme. An entire system is described by a set of related, distributable ViewPoints which are loosely coupled. A single ViewPoint consists of five slots. The style slot contains a description of the scheme and notation which is used to describe the knowledge of the ViewPoint. The domain slot defines the area of concern addressed by the ViewPoint. The specification slot contains the actual specification of a particular part of the system which is described in the notation defined in the style slot. The fourth slot is called work plan and encapsulates the set of actions by which the specification can be built as well as a process model to guide application of these actions. Two classes of work plan actions are especially important: In-ViewPoint check actions and Inter-ViewPoint check actions are used for checking consistency within a single ViewPoint or between multiple ViewPoints, respectively. The last slot of a ViewPoint called work record contains the development history in terms of the actions given in the work plan slot. A ViewPoint template is a kind of ViewPoint type. It is described as a ViewPoint in which only the style slot and the work plan slot are specified, i.e. the other slots are empty. When creating a new ViewPoint, the developer has the opportunity to use an existing ViewPoint template instead of designing the entire ViewPoint from scratch. The ViewPoints framework is independent from any particular development method and actively encourages multiple representations. Software development methods and techniques are defined as sets of ViewPoint templates which encapsulate

ViewPoint-Oriented Software Development

45

the notations provided as well as the rules how they are used. Integration of methods and views is realized by such rules referring to multiple ViewPoint templates. A more detailed description of the ViewPoints framework and its formalization by distributed graph transformation is given in [4]. In the next section we now present a brief overview of tool support.

3

The ViewPoint Tool

The ViewPoint Tool comprises three main components: the ViewPoint manager, the template editor and the ViewPoint editor. While the ViewPoint manager serves as a central tool to coordinate all activities within using the ViewPoints framework, the template editor allows to design ViewPoint templates – i.e. styles combined with work plan actions – and the ViewPoint editor allows to work with specifications and work records of actual ViewPoints. All ViewPoints used in the ViewPoint editor have to be instantiated from existing ViewPoint templates developed by the template editor. The ViewPoint manager serves to organize all developed ViewPoint templates and all actual ViewPoints (cf. Figure 1). It is used as a starting point to enter the template editor and the ViewPoint editor. First ViewPoint templates can be created which then can be developed further within the template editor. Then actual ViewPoints can be instantiated from a template which are usable within the ViewPoint editor. The template editor allows to edit the work plan slot and the style slot of a ViewPoint template. All actions of the ViewPoint template’s work plan have to be modeled as graph transformation rules (cf. Figure 2). The ViewPoint editor allows to edit a ViewPoint instantiated from a ViewPoint template developed by the template editor. All actions defined in the corresponding template’s work plan can be applied to build an actual specification. Figure 3 depicts a ViewPoint editor window, the actual specification is displayed on the left and all work plan actions are listed on the right.

Fig. 1. ViewPoint manager window.

46

Michael Goedicke et al.

Fig. 2. The work plan window of the template editor.

Fig. 3. The ViewPoint editor.

A more detailed description of the ViewPoint Tool – including distribution aspects and inconsistency management – is given in [7].

ViewPoint-Oriented Software Development

4

47

Conclusion and Further Work

In this contribution we have sketched a brief introduction to the ViewPoints framework and the ViewPoint Tool environment. Various case studies modeling non-trivial applications (e.g., integration of architecture design and performance evaluation views [5]) have shown that our implementation meets all the requirements for supporting the multiple perspectives problem in a flexible ViewPoint environmet. The present version of the ViewPoint Tool is based on the local version of AGG [9]. Currently we are working on integrating the features of a prototype AGG version realizing distributed graph transformation.

References 1. Easterbrook, S. and Nuseibeh, B., “Using ViewPoints for Inconsistency Management”, BCS/IEE Software Engineering Journal, pp. 31-43, 1996. 2. Finkelstein, A., Kramer, J., Nuseibeh, B., Finkelstein, L., and Goedicke, M., “Viewpoints: A Framework for Integrating Multiple Perspectives in System Development”, Int. Journal of Software Engineering & Knowledge Engineering, vol. 2(1), 1992. 3. Finkelstein, A. and Sommerville, I., “The Viewpoints FAQ”, Software Engineering Journal, vol. 11 (1), pp. 2-4, 1996. 4. Goedicke, M., Meyer, T., and Taentzer, G., “ViewPoint-oriented Software Development by Distributed Graph Transformation: Towards a Basis for Living with Inconsistencies”, Proc. th 4 IEEE International Symposium on Requirements Engineering, Limerick, Ireland, 1999. 5. Goedicke, M., Enders, B., Meyer, T. and Taentzer, G., “Tool Support for ViewPointoriented Software Development”, Proc. International Workshop and Symposium AGTIVE, Kerkrade, The Netherlands, 1999, Lecture Notes on Computer Science, Springer, to appear. 6. Taentzer, G., Fischer, I., , Koch, M., and Volle, V., “Distributed Graph Transformation with Application to Visual Design of Distributed Systems”, in Rozenberg, G. (ed.), Graph Grammar Handbook 3: Concurrency & Distribution, World Scientific,1999. 7. Taentzer, G., Ermel, C., and Rudolf, C., “AGG-Approach: Language and Tool Environment”, in Rozenberg, G. (ed.), Graph Grammar Handbook 2: Specification & Programming, World Scientific, 1999.

Consistent Integration of Formal Methods Peter Braun, Heiko L¨ otzbeyer, Bernhard Schätz, and Oscar Slotosch Institut f¨ ur Informatik, Technische Universit¨ at M¨ unchen 80290 M¨ unchen, Germany

Abstract. The usability of formal concepts for system design depends essentially on their integration in the design process. We discuss several possible levels of integration: technical integration of tools considering APIs and tool interfaces, conceptual integration of metamodels of description formalisms combined with hard and soft constraints, semantical integration of semantics of description techniques using a common semantic model, and finally methodical integration by an embedding in the development process. We show the feasibility of such an integrated approach and its advantages presenting AutoFocus/Quest, a formal method CASE-Tool with its levels of integration. Parts of a banking system model are used as example.

1

Introduction

The need for development tools for the design of (embedded) systems has been widely accepted: several programs are available for their construction, often focusing on specific aspects of the design process like building a data-model, verifying system properties, or simulating a designed system. However, generally several of these aspects are important in a thorough design process. An obvious way to obtain a more powerful tool is to combine existing tools and to integrate them. This approach has also been applied to description techniques like the UML. However, the result of the integration is not necessarily satisfying for the user: There can be redundancies (with the possibility to introduce inconsistencies while modeling overlapping aspects of the system), missing integration of concepts (with the need to bridge a gap between the design and the verification tool), or - as the most critical aspect - no integrated method for the user. These problems arise in conventional software development concepts as well as in formal method approaches. In this paper we advocate a new multi-level integration concept. The most sophisticated level is the methodical integration, ideally based on the next level, the semantic integration of the used description techniques. The third level forms the conceptual integration of metamodels, followed by the lowest integration level, the technical integration of tools. Integration on all levels results into powerful

This work was supported by the Bundesamt f¨ ur Sicherheit im Informationswesen (BSI) within the project Quest, and the DFG within the Sonderforschungsbereich 342.


Consistent Integration of Formal Methods

49

tools that provide a lot of features to the user. The layered integration hierarchy makes it easy to connect other programs, provided that the development methods fit together. As an example for this new integration hierarchy we present the tool AutoFocus/Quest, offering many different features, ranging from different graphical description techniques to theorem proving, testing, code generation and model checking. AutoFocus/Quest integrates the CASE tool prototype AutoFocus with the formal tools VSE II, SMV, SATO, and CTE. This paper is structured as follows: after a short overview over the tool AutoFocus/Quest in Section 2, we present (parts of) the banking system of the FM99 tool competition in Section 3 to introduce our description techniques. The main part of this paper (Section 4) describes the different levels of integration that are present in the AutoFocus/Quest tool. We conclude with a comparison with other existing tools.

The AutoFocus/Quest-Tool

2

AutoFocus/Quest has been presented successfully at the Formal Method World Congress 19991. In the following we briefly describe the features of the tool. 2.1

AutoFocus

AutoFocus [HMS+ 98] is a freely available CASE-Tool prototype for the development of correct embedded systems. Similar to other CASE-Tools it supports graphical description of the developed system using several different views. AutoFocus builds upon formal methods concepts. The available views are: – Interface and structure view: By using System Structure Diagrams (SSDs) users define structure and components of the developed system and the interfaces between components and the environment. – Behavior view: State Transition Diagrams (STDs) describe the behavior of a component in the system. – Interaction view: Extended Event Traces (EETs) capture the dynamic interactions between components (and the environment). EETs are used to specify test cases or example runs of the systems and have a Message Sequence Chart-like notation. – Data view: (textual) Data Type Definitions (DTDs) define the data types for the description of structure, behavior and interaction diagrams. We use functional datatypes. All views are hierarchic to support descriptions at different levels of detail. AutoFocus can check the consistency between different views using an integrated consistency mechanism. AutoFocus offers a simulation facility to validate the specifications based on rapid prototyping. 1

AutoFocus/Quest was acknowledged as the leading competitor in the tool competition of FM’99. See http://www.fmse.cs.reading.ac.uk/fm99/ for more information.

50

Peter Braun et al.

2.2

Quest

Within the project Quest several extensions to AutoFocus were achieved.2 The aim of the project [Slo98] was to enrich the practical software development process by the coupling existing formal methods and tools to AutoFocus in order to ensure the correctness of critical parts of systems. The combination with traditional software engineering methods is achieved by specificationbased test methods which facilitate the selection of reasonable test-cases for non-critical components. The tools developed within Quest translate the graphical concepts into other formalisms suitable for verification, model checking or testing (VSE [RSW97], SMV [McM92], SATO [Zha97], CTE [GWG95]) and support the systematic generation of test-cases. To provide an integrated, iterative development process (partial) retranslations from the connected tools were implemented, supporting visualization of counterexamples, generation of test sequences with input values, and the reimport of components that have been corrected during verification. The translations were realized using an API and a textual interface to AutoFocus. This allows to easily connect other tools using interfaces or generators.

3

The FM99-Banking System

In this section we briefly present parts of a model that was presented on the Formal Methods World Conference 1999.3 The banking system example was used to compare different modeling methods and verification tools, presented at FM’99, on a competitive basis. The banking system contains a central (main host) and several tills (automated teller machines) that are communicating independently with the central database. The connections from the central to the tills may be down. Among other requirements it has to be ensured that the amount withdrawn within one day does not exceed a maximum value. We modeled the banking system with the graphical description techniques from AutoFocus/Quest. In the following sections we describe the main structure of the system, some of the datatypes used, the behavior of the connection, and a possible interaction sequence from a connection and the central. 3.1

System Structure

We modeled the system with two tills and two connections. Since the connections have a specific behavior (i.e. they can be down), we modelled connections as components in the system. The structure of the system is described in the Fig. 1. The connections pass transactions (of type Info) from the tills to the central, and in the other direction connections report information to control the behavior of 2 3

The project was carried out for the German “Bundesamt f¨ ur Sicherheit in der Informationstechnik” (Information Security Agency) (BSI). See http://www4.in.tum.de/proj/quest/ for the full model.


Slot1:Card

RadioTime1:Date

Keypad1:Keys Display1:Msg

51

Till1

out1:Info Till1Ack:Signal CentralMsg1:Message

Connection1

inp1:Info Answer1:Message C1Ack:Signal

D

Eject1:Card Money1:Int

Central Slot2:Card

RadioTime2:Date

Keypad2:Keys Display2:Msg

Till2

out2:Info Till2Ack:Signal CentralMsg2:Message

Connection2

inp2:Info Answer2:Message C2Ack:Signal

Eject2:Card Money2:Int

Fig. 1. SSD for Banking System

the till. The messages (of type Message) are defined in a DTD (see Section 3.2). Furthermore the connections have acknowledge channels to indicate the sender of a message that it has been sent successfully. The SSD shows the ports (little circles) of the components, the external ports, and the channels that connect these ports. Reusing port names4 in different components allows us to describe the behavior of each connection with the same state transition diagram. For example the channel out1 connects to the port out of Connection1. 3.2

Datatypes

As simple examples, we show the definition of two datatypes and a function (defined using pattern matching) used within the graphical views: data Message = Money(Int) | NoMoney | Balance | MailSent; data Transaction = TA(Action,Account); fun withdrawMoney(TA(Withdraw(x),acc))=Money(x); 3.3

Behavior

The behavioral description of the system refers to the ports of the components defined by the SSD in Section 3.1. The behavior of both connections are described in Fig. 2. If there are no values on both channels (expressed by the input patterns: out?;Answer?) the connection changes its state to reduce energy usage. This has been introduced to model the fact that connections sometime are down. If the connection is down and receives a value it moves to the state sleeping. If another value is received, then the connection is up, and ready to process the data. 4

Port names are attributes of ports.

52

Peter Braun et al. Answer?m;out?i:CAck!Present;CentralMsg!m;TillAck!Present;inp!i: Up Answer?m;out?:CAck!Present;CentralMsg!m:

Answer?;out?i:TillAck!Present;inp!i: Answer?m::

out?i::

out?;Answer?::

Sleeping

Answer?m::

out?i::

out?;Answer?::

Down

Fig. 2. STD for Connection1

3.4

Interaction Example

To illustrate the interaction from the connections and the central we use the EET in Fig. 3. This is only one example trace of the behavior of the system. All messages between two ticks (dashed lines) are considered to occur simultaneously.

4

Integration

In this section we describe the integrations within AutoFocus/Quest. There are different integration layers: – – – –

methodical integration (on the development process level) semantic integration (on the semantics level) conceptual integration (on the metamodel level) technical integration (on the tool level)

The quality of an integration depends on the reached level, and on the quality of the underlying levels, for example a complete semantic integration is not sufficiently helpful for a user without tool support. 4.1

Metamodel Integration

In our view, integrated metamodels are essential for further integration. Metamodels can be applied to define a modeling language [Met99] and are increasingly used, for instance to define UML [BJR97]. In the case of AutoFocus the syntactic aspects of the modeling techniques, like SSDs and STDs, are described using a metamodel. We use class diagrams as defined by the UML for the description


Connection1

53

Central

inp1.X Till1Ack!Present

Answer.Money(100)

Answer.Money(100)

Answer.Money(100)

CentralMsg!Money(100)

C1Ack.Present

Fig. 3. Execution Example

of metamodels. We consider it essential that the metamodels of different concepts of a modeling language are integrated into one metamodel since otherwise different modeling concepts do not fit together. We show this for the example of SSDs and STDs. Fig. 4 shows a simplified version of the integrated metamodel for SSDs and STDs. An SSD consists of components, ports, channels and relations between them. A component has a name, and can be decomposed in an arbitrary number of subcomponents, and can belong to a supercomponent. This is needed to model hierarchic components. A component is a composition of ports and channels. In the example of Fig. 1 the component Connection1 has four output ports and two input ports and no channels. All channels in Fig. 1 belong to the component Banking System, the supercomponent of the shown components. Below the metamodel of SSDs is the metamodel of STDs. An automaton consists of one state, which may be hierarchic, as the component in the STD metamodel. Similar to the component a state has interface points and transition segments. A transition segment is a composition of a precondition, some input patterns, some actions and output patterns. See the example of Section 3 for an explanation of those elements. We now have two concepts, the concept of system structure diagrams and the concept of automatons. But how do they fit together? In many other tools there will be only an association from components to automata: the dynamic behavior of a component can be described with an automaton. But there is more. In our case the input and output patterns that belong to a transition segment are connected to the ports of the component to which the automaton

54

Peter Braun et al.

0..1

SuperComponent

Component 1

0..*

-Name:String

SubComponents 1

1

0..*

Ports

0..*

Port 1 -Name:String SrcPort

-Direction:Direction -Type:Type

1

-Name:String

OutChannels

-Type:Type 1

0..1

DestPort 1 Port

Channels Channel

0..*

InChannel

SSD-Metamodel

Port

0..1 Automaton -Name:String

0..1

1 Input

Output

-Pattern:Term

0..*

-Expression:Term

Inputs

0..*

0..1

State

Outputs

-Name:String

SuperState

-Predicate:Term -IsInitial:boolean

0..* SubStates

1

1

1

0..*

TransitionSegments

TransitionSegment

0..*

-Name:String -IsOuter:boolean

1

PreCondition Condition

-Expression:Term

0..* 1

InSegments 0..* OutSegments

1

1

DestPoint

InterfacePoints

InterfacePoint

-Name:String 1 -Direction:Direction

SrcPoint

1

0..*

PostConditions Action

-Variable:LocVariable -Value:Term

STD-Metamodel

Fig. 4. Integrated Metamodel for SSDs and STDs


55

belongs. So an input to the automaton of component Connection1 in Fig. 1 can only come from the ports Answer or out restricting what is considered a correct model. Thus for specifying a new input pattern one might want to only choose from ports of the related component or to create a new port, which then automatically belongs to the related component. Note that the constraint, that a port belongs to the right component, is not modelled in the class diagram of Fig. 4. There, only the fact is expressed, that every input has a relation to an arbitrary port. The constraint that the automaton belongs to the same component as the ports of the input and output patterns, is expressed in a logical constraint that belongs to the metamodel. Up to now AutoFocus uses its own syntax for these expressions. However, a prototype exists using OCL [WK98], the constraint logic of UML [BJR97]. Beside the integration of the concepts of SSDs and STDs there are other concepts integrated in AutoFocus/Quest. For instance, datatypes are modelled and used. In Fig. 4 attributes with types like term or type are shown. These are actually relations, like the ones from input and output to port, to classes in other parts of the integrated metamodel. So we do not only have different concepts, but we have merged them tightly together. But sometimes the user is handicapped by a very strict link between the different views of a system. So we tolerate the possibility that the model might be inconsistent at some stages of the development. For example, when specifying an SSD, it is sometimes desirable that datatypes can be used that are not yet defined. Thus, especially for the links between different concepts, we tolerate inconsistencies. Hard constraints like the need for a channel to have relations to a source-port and a destination-port may not be violated. 4.2

Semantic Integration

As with the conceptual level, where all system views are mapped onto a common metamodel, all description techniques are also mapped onto one semantic model. Thus, all descriptions are semantically integrated on the mathematical or the model level as sketched in the following subsection. However, this is a very low level of integration not suitable for system development. Instead we need to express the semantics of the described systems in terms of the techniques and actions performed by the user. The highest form of integration is achieved if the user can completely stay within the level of formalization used in the specification process so far, for instance, to SSDs, STDs, EETs, and DTDs, as described in the second subsection. However, this is not generally possible and thus other forms of integration adding new formalisms or techniques must be used as described in the last subsection. Semantic Model As already suggested by the STD description formalism, we use a stepwise computation mechanism to model the behavior of a system or component. Each step consists of two substeps: reading the input ports of a component and processing the input, and generating the output. After each step

56

Peter Braun et al.

the output of a component is transferred from its output ports along its channels to the input ports of the corresponding channels. The behavior of a component or a system is formalized by sequences of those steps. One of the major incentives in choosing this semantic model is its simplicity. Furthermore, it is compliant with other approaches – both from the engineering and the formal methods domain – that are widely accepted. The concept of stepwise, cyclic computations with unbuffered variables (channels) is, for example found, in programming languages for PLCs (programable logical controllers) as well as in TLA (temporal logic of actions). This straight-forward yet expressive semantic model seems to be best suited for the domain of hardware oriented embedded systems compared to approaches using more complex concepts, for example state charts with the concept of OR- and AND-states. Nevertheless, other semantic models can be adapted to fit the basic principles of AutoFocus/Quest, adding concepts like buffering channels suitable for other domains like telecommunication. Consistent Specifications As already mentioned on the conceptual level of the metamodel, during a development process inconsistencies in system specifications may occur. This is especially the case using a view-based approach where the specification is simultaneously presented on different levels of abstraction and spread over different aspects like structure (SSDs), behavior (STDs) or interactions (EETs). Then mechanisms must be offered to support the user in finding those inconsistencies. Those inconsistencies may occur on the conceptual level, for example if the type of a port does not meet the value sent on it. On the conceptual level those checks are comparably simple and can be carried out automatically. However, even in the semantical level different inconsistencies may occur: Abstract vs. concrete behavior: As mentioned in section 4.1, a component (or system) may be realized by a number of subcomponents using an SSD. Accordingly, the system designer can assign behavior to both the component and its subcomponents using STDs. In the AutoFocus/Quest development methodology the assignment of behavior to the ‘black box’ and ‘glass box’ view of a system is considered as a refinement step performed by the designer. Thus, it should be checked that the abstract component including its behavior is refined by the concrete subcomponents and their behavior given by their STDs. Since this is a refinement step, the concrete behavior must fulfill the requirements of the abstract behavior, or - in other words any behavior exhibited by the concrete system must also be possible in the abstract version. Behavior vs. interaction: As mentioned in section 3 the views used in the AutoFocus/Quest approach are not completely independent and may share common aspects. On the semantic level, both SSDs combined with STDs and EETs express behavior of a system (or component). Again, support is needed to aid the user during the development process in detecting such inconsistencies. Again, those checks should be performed as au-


57

tomatic as possible. If the state space of the specified system is finite, in general model checking can be used to perform those checks. We used the model checker µcke [Bie97] to implement a prototype of such an automatic check ([SH99], [Bec99]. Naturally, the performability of such checks is heavily influenced by the size and the complexity of such a system. For the second check, i.e., verifying that an interaction described by EET corresponds with the behavior of a system characterized by SSDs and STDs, another proof method can be applied using a bounded model checking approach. Here, the model checker SATO is used to check that form of consistency (see [Wim00]). Further Integration As mentioned above, automatic checks can not always be performed. In that case, other forms of integration must used. One possible solution is to exchange the model checker by a theorem prover, as it was done with AutoFocus/Quest using VSE. This integration adds a new description formalism, the logical formalism of the theorem prover, to the existing set of description techniques. Thus, this approach requires the user to get familiar with another formalism as well as an additional tool, the prover. While this results in a weaker integration from the user’s point of view, it extends consistency checks to more general systems with an infinite state space. Another possibility is to add another description formalism to express semantic properties of a component or system and integrate a suitable tool for this formalism. In AutoFocus/Quest both SATO (see [Wim00]), and SMV (see [PS99]) were integrated. This approach adds a new description formalism, the temporal logic, and does not treat the inconsistencies mentioned in the previous subsection. However, it offers two advantages for easy integration in the tool environment: – The checks can be performed automatically, thus - from the user’s point of view - there is no need for another tool. – The check either passes or results in a counter example expressed in form of an EET. Thus, besides the temporal logics, no other formalism is needed. 4.3

Methodical Integration

The last sections dealt with the integration of the semantical concepts behind the conceptual layer. Integrated and consistent semantics are not only a well founded basis but also a prerequisite for a continuous and straight-forward software development process. As a prime requisite to up-to-date system development, the AutoFocus/Quest method covers the development process from the graphical description of the system over system verification using theorem proving to code generation. Beyond that, however, the methodical integration of different software development concepts is essential for a successful tool integration. An adequate integration of different methods will make any integrational tool worth more than the single parts from which it was made. Generally, the development process is divided into phases like requirements, modeling, validation, prototyping, and test. In our approach, while each phase

58

Peter Braun et al.

may use different techniques, they all work on the same metamodel with a common semantics. This enables the developer to switch between different phases like specification, verification, or testing, and the corresponding tasks without the need for complex manual transformations. Due to the versatility of the model based approach, there are no restrictions introduced by the model which complicate the combination of those tasks or integration of new methods in the process. The next paragraphs discuss the different phases in detail and show how they fit into the integrated metamodel and the given semantics. The requirements phase generally deals with informal documents and fuzzy specifications. We provide extended event traces (EET, see Section 2.1) that allow the specification of use cases as exemplary interaction sequences. EETs, an AutoFocus description technique, represent a first, generally incomplete, specification of the system. In the next phase, the modeling phase, the skeleton of the system specification is enlarged and refined to get a more defined structure and behavior model. This is done by applying the AutoFocus development method (See [HMS+ 98]). If one or more EETs already exist, it is also possible to derive the first version of the interface and the system structure from the axes and messages of the EETs. In the validation phase the following tasks are supported: – – – –

consistency checks (see Section 4.1), simulation (see [HMS+ 98]), model checking (see [PS99]), bounded model checking (see [Wim00]) and theorem proving.

AutoFocus/Quest provides simulation of components. So, faults in the specifications can be detected and located directly while the simulation is running. Beyond that, the simulation also generates system traces which are displayed as EETs and can be later used for conformance testing. In case of developing safety critical systems, validation by simulation is not sufficient. Often formal proofs are required to show the correctness of the specifications. With model checking it is possible to prove safety critical properties of components automatically. Therefore model checking became very popular. Model checking does not only check properties as valid, but also produces counter examples if the property does not hold. If the model checker finds a counter example, it is retranslated and displayed as an EET. Abstraction techniques are a further example for a method integration. They extend the power of model checking to large and infinite systems (we use [M¨ ul98]). Simple proof obligations are generated (for VSE) to ensure that the model checked property in the abstract system also holds in the concrete systems. The design task, to find correct abstractions, is supported within AutoFocus/Quest. Besides the model checking approach, AutoFocus/Quest also allows to translate the specification to a representation understood by the VSE system, a theorem prover for a temporal logic similar to TLA supporting hierarchic components like AutoFocus/Quest [RSW97]. Within the VSE system a formal founded validation of the specification can be performed. It is also possible to


59

make small changes of the specification in the VSE system and the re-import to AutoFocus/Quest. Beside system validation AutoFocus/Quest supports the test phase. Testing in AutoFocus/Quest focuses on conformance testing between a specification and its manually coded implementation. The most challenging task within software testing is a tool-supported test case generation. Therefore we have integrated the classification tree editor CTE [GWG95]. The CTE allows the classification of arbitrary datatypes with trees and the selection of certain combinations as test input classes. The construction of the classification trees is assisted by the classification tree assistant (CTA) which can be set up individually. In AutoFocus/Quest we generate the CTA from datatype definitions, system structure, and automata. So the tester does not need to start from scratch, but can use the suggested standard classifications. The classification tree method is combined with a sophisticated test sequentialization which computes test cases, i.e. sequences of input/output data. Test cases are coded as EETs. A simple test driver allows the execution of the generated test cases with Java components. The implementation phase is supported with Java and C code generators. A well done methodical integration of different software development methods does not restrict the development process but gives more freedom. In AutoFocus/Quest EETs play an important role in integration. EETs are a kind of multi-functional description technique. They serve as use cases, interaction description, counter examples, as well as test cases. 4.4

Tool Integration

In the previous section we have shown the methodical integration of the development process. Through the different phases of the development process we have to use different tools, like AutoFocus, model checkers, theorem provers and test tools. So we designed AutoFocus/Quest not to be one monolithic tool, but rather to be a collection of different specialized tools which are based on the same integrated metamodel. One big advantage of having many different tools is, that they are small, easier to understand and to replace. One example for this is the connection to the model checkers SMV and SATO. You can use each one or both for AutoFocus/Quest or we can build another connection to a new model checker, which replaces the other two connections. To link our tool-collection together we use a central repository with a conceptual schema, which is defined by the integrated metamodel. Every other tool can use the repository via an API. The API offers methods for e.g. importing or exporting a complete repository to a text file or to do some consistency checks on a model or a part of it. Note that the consistency checker bases on the core API, so that different tools to check the consistency of our models can be used. Since we would like to integrate other tools, we want to have a flexible metamodel, and we want to be able to change things in the metamodel or to add new concepts to the metamodel without having to recode the central repository and without the need to touch every tool even if it is not affected by the change. So the core repository, which offers an API to create, modify or delete objects, is

60

Peter Braun et al.

completely generated. As the core API the textual importer and exporter are generated [Mar98]. Thus we only have to change tools which are directly affected by the change. The generated core repository also ensures that our hard constraints are not violated. Every programmer using the API can rely on the fact that the hard constraints are not violated in any model, making programming considerably easier. A common, well documented model is also important for integration of new tools. To connect a new tool to AutoFocus/Quest directly the repository API or a translation from the model data in the repository to the data needed by the tool can be used. Consistency checks can be used to ensure some constraints that are a prerequisite for the translation. Besides this a retranslation of results or model changes to AutoFocus/Quest might be needed. The spectrum of currently available tools in the field of embedded systems ranges from those tool focused on formal based design including verification techniques to tools concentrating on software engineering aspects including viewbased system description, code generation and simulation. Consider, for example, Atelier B [Abr96] on the one hand, StateMate [Har90] or SDT [Tel96] on the other hand. Generally, those tools only partially integrate those aspects. An integrated combination of clearly defined but simple modeling concepts, an underlying welldefined semantic model for verification purposes, industrial-oriented notations supporting view-based development, prototyping for requirements validation, code generation for system implementation as well as test cases generation for system validation. On the SW-engineering side, this is often due the fact that system modeling approaches like UML [BJR97] using different, graphical notation for the description of systems lack a sound conceptual and semantical basis. As a consequence, in many cases tools like Rational Rose [Rat98] and Rhapsody [i-L97] supporting this notation are missing a suitable formal semantics. Thus, while those notations and tools do offer support for checking syntactic consistency conditions, no such support is available on the semantic side. Those observations even hold for notations and tools based on more formally defined approaches like SDL and corresponding tools like SDT [Tel96]. On the other side, tools originating in formal approaches like STeP [BBC+ 95] or Atelier B [Abr96] often lack methodical or engineering functionality like the splitting of complete system descriptions into well-defined views of the system, combining these descriptions on different levels of abstraction as well as relating those views to form a consistent description. The goal for developing AutoFocus was not to build another tool but rather to investigate how the experiences gained in several basic research projects could be consequently applied to the development of embedded systems. Some aspects were considered as major topics: the use of well-defined description techniques, the modularity and expressiveness of those description techniques supporting different levels of abstractions and view-points, as well as the methodical integration of those techniques for integrated development approach. Those aspects also are the features distinguishing AutoFocus from other tools in this area.


61

For example, approaches like StateMate mix different views (system structure and behavior by using AND- and OR-states). Furthermore, there a semantical basis is not applied to support model checking or theorem proofing. While other tools avoid those mixing of aspects, they are somewhat lax in the use of complete and clearly defined description techniques. Thus, for example, in ObjecTime, the diagrams for behavioral description are annotated with program code fragments to for a complete description. Since ROOM [SGW94] and ObjecTime were developed without a clear semantical model, in the end the meaning of diagrams is only described by the generated executable models, leaving the possibility for open questions concerning modeling concepts as well as lacking the requirements for formal support by theorem proofing or model checking. The combination of the above mentioned aspects and the resulting methodical consequences are central incentives for the development of AutoFocus. AutoFocus supports a lean subset of description techniques based on a common mathematical model. These description techniques are independent of a specific method or a tool, while offering the essential aspects of similar description techniques, and can therefore be combined with a wide rage of methods and development processes.

5


Integration of formal techniques is more than just integrating formal (and semiformal) tools; nevertheless, tool integration is one important step. Several tool platforms that can be readily connected to AutoFocus/Quest, including NuSMV, Proovers, STeP, or Isabelle. Since the ultimate goal is the methodical integration, more steps have to be taken on this level: Code generators for C and Java are currently under development. Further work is needed in requirements phase, to support methods for requirements tracing (as found in the DOORS tool). Furthermore, in the modeling phase the use of graphical support for model based development steps (refinement, splitting of transitions, combining channels, etc.) in AutoFocus must be investigated.

References J.-R. Abrial. The B-Book: Assigning Programs to Meanings. Cambridge University Press, 1996. 60 BBC+ 95. Nikolaj Bjorner, Anca Browne, Eddie Chang, Michael Colon, Arjun Kapur, Zohar Manna, Henny B. Sipma, and Tomas E. Uribe. STeP: The Stanford Temporal Prover (Educational Release) User’s Manual. STAN-CS-TR 951562, Computer Science Department Stanford University, 1995. 60 Bec99. Roland Bechtel. Einbettung des µ-Kalk¨ ul Model Checkers µ-cke in AutoFocus. Master’s thesis, Institut f¨ ur Informatik, Technische Universit¨ at M¨ unchen, 1999. 57 Bie97. Armin Biere. Effiziente Modellpr¨ ufung des µ-Kalk¨ uls mit bin¨ aren Entscheidungdiagrammen. PhD thesis, Universit¨ at Karlsruhe, 1997. 57

Abr96.

62

Peter Braun et al.

G. Booch, I. Jacobson, and J. Rumbaugh. UML Summary. Rational Software Cooperation, January 1997. Version 1.0. 52, 55, 60 GWG95. M. Grochtmann, J. Wegner, and K. Grimm. Test Case Design Using Classification Trees and the Classification-Tree Editor. In Proceedings of 8th International Quality Week, San Francisco, pages Paper 4–A–4, May 30June 2 1995. 50, 59 Har90. D. Harel. Statemate: A working environment for the development of complex reactive systems. IEEE Transactions on Software Engineering, 16(4):403– 414, 1990. 60 atz, O. Slotosch, and A. Vilbig. Traffic Lights HMS+ 98. F. Huber, S. Molterer, B. Sch¨ An AutoFocus Case Study. In 1998 International Conference on Application of Concurrency to System Design, pages 282–294. IEEE Computer Society, 1998. 49, 58 i-L97. i-Logix. Rhapsody Reference Version 1.0, 1997. 60 Mar98. Frank Marschall. Konzeption und Realisierung einer generischen Schnittstelle f¨ ur metamodell-basierte Werkzeuge. Master’s thesis, Institut f¨ ur Informatik, Technische Universit¨ at M¨ unchen, 1998. 60 McM92. K.L. McMillan. The SMV system, Symbolic Model Checking - an approach. Technical Report CMU-CS-92-131, Carnegie Mellon University, 1992. 50 Met99. MetaModel. http://www.MetaModel.com/, 1999. 52 M¨ ul98. Olaf M¨ uller. A Verification Environment for I/O-Automata Based on Formalized Meta-Theory. PhD thesis, Institut f¨ ur Informatik, Techn. Univ. M¨ unchen, 1998. 58 PS99. J. Philipps and O. Slotosch. The Quest for Correct Systems: Model Checking of Diagramms and Datatypes. In Asia Pacific Software Engineering Conference 1999, pages 449–458, 1999. 57, 58 Rat98. Rational. Rational Rose 98 Product Overview. http://www.rational.com/products/rose/, 1998. 60 RSW97. G. Rock, W. Stephan, and A. Wolpers. Tool Support for the Compositional Development of Distributed Systems. In Proc. Formale Beschreibungstechniken f¨ ur verteilte Systeme,GI/ITG-Fachgespr¨ ach. GMD-Studien Nr. 315, ISBN: 3-88457-514-2, 1997. 50, 58 SGW94. Bran Selic, Garth Gullekson, and Paul Ward. Real-Time Object-Oriented Modeling. John Wiley and Sons, 1994. 61 SH99. Bernhard Sch¨ atz and Franz Huber. Integrating Formal Description Techniques. In Jeanette Wing, Jim Woodcock, and Jim Davies, editors, FM’99 - Formal Methods, pages 1206–1225. Springer, 1999. 57 Slo98. O. Slotosch. Quest: Overview over the Project. In D. Hutter, W. Stephan, P Traverso, and M. Ullmann, editors, Applied Formal Methods - FM-Trends 98, pages 346–350. Springer LNCS 1641, 1998. 50 Tel96. Telelogic AB. Telelogic AB: SDT 3.1 Reference Manual, 1996. 60 Wim00. G. Wimmel. Using SATO for the Generation of Input Values for Test Sequences. Master’s thesis, Technische Universit¨ at M¨ unchen, 2000. 57, 58 WK98. Jos Warmer and Anneke Kleppe. The Object Constraint Language. AddisonWesley, 1998. 55 Zha97. H. Zhang. SATO: An efficient propositional prover. In William McCune, editor, Proceedings of the 14th International Conference on Automated deduction, volume 1249 of LNAI, pages 272–275, Berlin, July 13–17 1997. Springer. 50 BJR97.

An Architecture for Interactive Program Provers J¨ org Meyer and Arnd Poetzsch-Heffter Fernuniversit¨ at Hagen, D-58084 Hagen, Germany {Joerg.Meyer,Arnd.Poetzsch-Heffter}@fernuni-hagen.de Abstract. Formal specification and verification techniques can improve the quality of programs by enabling the analysis and proof of semantic program properties. This paper describes the modular architecture of an interactive program prover that we are currently developing for a Java subset. In particular, it discusses the integration of a programming language-specific prover component with a general purpose theorem prover.

1

Introduction

Specification and verification techniques can improve the quality of programs by enabling the analysis and proof of semantic program properties. They can be used to show the absence of exceptions and to prove that a program satisfies certain interface properties or a complete interface specification. This is particularly interesting for the emerging market of software components. As we illustrate in Section 2, tool support is crucial for the application of such formal techniques. The paper motivates and describes the modular architecture of an interactive program prover that we are currently developing for a Java subset. In particular, it discusses the integration of a programming language-specific prover component with a general purpose theorem prover. The goal of this research is to provide a powerful and flexible tool that – supports complete a posteriori program verification; – provides assistance in top-down program development, e.g. for deriving specifications of auxiliary procedures; – allows one to specify and check certain simple, but in general undecidable properties, such as the absence of null pointer dereferencing and out-ofbounds access to arrays. As illustrated by the last aspect, we are not only interested in algorithm verification, but as well in showing the absence of certain (language dependent) program errors. In particular, we have to deal with sharing and abstraction. We build on an object-oriented language, because it supports encapsulation on the level of types and because subtyping simplifies reuse. Overview. The paper is organized as follows. Section 2 provides the technical background for specification and verification, motivates our approach, and discusses related work. Section 3 presents the overall architecture for the interactive verification environment. Section 4 focuses on the realization of the program prover component and describes its application by an example. S. Graf and M. Schwartzbach (Eds.): TACAS/ETAPS 2000, LNCS 1785, pp. 63–77, 2000. c Springer-Verlag Berlin Heidelberg 2000

64

J¨ org Meyer and Arnd Poetzsch-Heffter

2

Verification of Realistic Programs

Verification of realistic programs is a fairly complex task. The goal of this section is to illustrate where this complexity comes from and to give an overview of tool-based approaches to cope with this complexity. The first subsection sketches state-of-the-art specification techniques and the involved formal background that has to be mastered by verification tools. The second subsection summarizes mechanical approaches to formal program verification from the literature. 2.1

Specifying Object-Oriented Programs

Program specifications should describe the behavior of program components in a formal and abstract way: Formality is a prerequisite for computer-aided verification. Abstraction is needed to achieve implementation independency and to simplify verification. In the following we summarize formal techniques to achieve abstraction in OO-languages. We build on the Larch approach to program specification (cf. [GH93]) that uses type invariants and pre- and postconditions for procedures/methods. The following Java program fragment shows an interface type Set1 and an implementation of this type based on arrays. interface Set { boolean add( Object o ); boolean contains( Object o ); int size(); ... }

class ArraySet implements Set { private Object[] elems; private int setsize; boolean add( Object o ){ ... } ... }

Since the interface Set may have several implementations and since it should be possible to modify implementations without changing the specification, the specification of Set cannot refer to any implementation parts, i.e., it has to be given in abstract terms. We specify the behavior of type Set using an abstract data type with main sort SET and the usual operations, and an abstraction function aSet. aSet maps a Set object X and an object store to a value of sort SET. The object store is needed to capture the objects referenced by X. Method add can thus be specified as follows where $ is a variable denoting the current object store and the caret-operator yields the value of a variable in the prestate: boolean add( Object o ) pre o = null post result = (o ∈ aSet (this, $ˆ) ) ∧ aSet (this, $) = {o} ∪ aSet (this, $ˆ) ∧ ∀ Object X : ¬inRepSet (X, this, $ˆ) ⇒ unchanged (X, $, $ˆ)

The first conjunct of the postcondition states that add yields true if and only if the object to be inserted is already contained in the set. The second conjunct specifies that after execution the implicit parameter this refers to the enlarged set. The third conjunct describes that the states of all objects not belonging to the representation of the input set remain unchanged. The representation of an 1

A simplified version of the Set type as contained in the Java library.

An Architecture for Interactive Program Provers

65

abstract value comprises all objects that are used to represent the value in the object store. Since abstraction functions and the predicate inRepSet depend on implementations, they have to be explicitly defined. E.g., the provider of class ArraySet has to define an abstraction function and the predicate inRepSet for objects of type ArraySet. (For a set represented by an ArraySet-object Y , the representation consists of Y and the referenced array object.) The above example illustrates the basic aspects needed in a realistic framework for formal program specification and verification. A more detailed presentation of the specification techniques can be found in [PH97b,MPH99]. In summary, such a framework has to provide the following features: – To express abstraction, it is necessary to define and reason about abstract data types that are specified outside the programming language (e.g. SET). – To specify modifications of the object store and to formulate properties on the program level (e.g. absence of null pointer dereferencing), a formalization of objects and the object store has to be provided by the framework. – The abstract and program levels have to be integrated to be able to specify abstraction functions, representation predicates, and abstract data types that are based on types of the programming language (e.g. the abstract data type SET refers to elements of type Object). The Java interactive verification environment Jive that is described in this paper supports all of the above features (cf. Section 3 and 4). 2.2

Computer-Aided Program Verification

In the literature, we can essentially find three approaches to computer-aided program verification. Verification Based on Language Semantics. This technique works as follows: Translate the program into a general specification framework (e.g. HOL) in which the semantics of the programming language is defined. Then state the program properties directly within this framework and use the rules of the language semantics for verification. This techniques is e.g. applied in [JvdBH+ 98]. The advantage of this approach is that existing frameworks equipped with powerful tools can be used without extensions (e.g., PVS [COR+ 95] or Isabelle [Pau94]). Only the translation process has to be implemented (and verified). The main disadvantage is that specification and verification on the semantics level is very tedious, because the abstraction step gained by an axiomatic language definition once has to be done in semantics level proofs again and again. Verification Condition Generation. VCG was the classical approach to program verification. Based on a weakest precondition semantics, a program specification is transformed into a (weakest) precondition formula guaranteeing that a program satisfies its postcondition; i.e., program dependent aspects are eliminated by the wp-transformation. The precondition formula (verification condition) can

66


be proved by a general theorem prover. This is the technique used in systems like e.g. the Standford Pascal Verifier [Com79]. The advantage of this approach is again that program dependent aspects are eliminated automatically and that the proper verification task can be done using standard tools. The disadvantage is that in realistic settings (cf. Section 2.1) the verification conditions become huge and very complex. There are essentially three reasons for that: (recursive) procedure/method calls, aliasing operations on the object store, and abstraction. As an example, consider an invocation site of method add of interface Set. If we use the specification of add to compute a weak precondition for a formula Q, the resulting precondition has about the size of the method specification plus the size of Q. The reason for this is that the postcondition of add does usually not match Q and that simplification is not trivial. Having several method invocations in a statement sequence easily leads to unmanagable preconditions. Working with verification condition generation has two further disadvantages: a) If the generated condition cannot be proved, it is often difficult to find out why this is the case and which program statement causes to fail (cf. [GMP90] for a discussion of this issue). b) VCG is fairly inflexible and only applicable in an a-posteriori verification. E.g., in top-down program development, one would like derive the needed properties of a used method from the specification of the calling method. Interactive Program Verification. Interactive program verification applies ideas from general tactical theorem proving to programming logics like e.g. to Hoare logic (see below) or dynamic logic (cf. [Rei95]). The main advantage of this approach is that program proofs can be developed around the program, i.e. as annotations to the program. The intuition about the program can be directly used for the proof. Strengthening and weakening steps can be applied where most appropriate. In particular, such steps can be done before and after method invocations to adapt method specifications to the needs at the invocation site. This way the described problem of VCG can be avoided. In addition to this, it is usually easy to detect program errors from failing proofs. Furthermore an advantage is that the interactive program prover “knows” the programming language and can provide appropriate views. On the other hand, a language dependent program prover has to be developed which is quite an engineering challenge. Because of the described disadvantages of the first and second approach, we decided to construct an interactive, tactical prover for program verification. Within this prover, weakest precondition techniques can be implemented by tactics and used where appropriate without giving up flexibility. Depending on the goals, other combinations of the verification approaches sketched above are investigated in the literature. E.g. in [Gor89], Gordon demonstrates the development of programming logics based on a general HO-theorem prover showing the strength of HO-reasoning. However, he cannot exploit the specific relation between programs and program proofs. In the Extended Static Checker for Java (ESC/Java, cf. [DLNS98]), the translational approach is combinded with VCG for automatic checking of a restricted class of specifications.


3

67


This section presents our architecture for interactive program provers. The architecture is based on the following requirements: The functional properties as described in Section 2.1 have to be fulfilled. The newly implemented program prover component should only be responsible for proof tasks that are directly related to the program. General specification and verification aspects should be delegated and performed by state-of-the-art theorem provers. This comprises in particular the definition of the object store and abstraction functions. In the following, we first analyse the consequences of combining general provers with language-specific provers. Then, we explain the overall architecture. Communicating Provers. There are two architectural alternatives for combining a general prover and a programming language specific prover component within a verification system: a) The general theorem prover is encapsualed by the system and hidden to users. b) Both prover components are accessible by users and the communication between them is visible. For the following reasons, we decided for the second alternative. It provides more flexiblity and is easier to react to new developments w.r.t. the general theorem prover. The implementation is less expensive. For third party users, the programming interfaces of existing theorem provers are not sufficiently powerful to control all prover operations by an external process. The disadvantage of this solution is that users of the resulting system have to handle two interactive components: the program prover component and the theorem prover component. The communication between Type check request the two prover components is ilProof request lustrated in Figure 1. The proProgram Prover Theorem Prover gram prover sends type checking Component Component and proof requests to the general Result theorem prover. Type checking of pre- and postformulas is done Fig. 1. Basic prover components. in the general theorem prover, as these formulas contain logical variables and make use of abstract data types specified as theories in the syntax of the general theorem prover. Proof requests result from strengthening and weakening steps in program proofs. They are formulas not refering to a special program part and are verified online or offline in the theorem prover component. The information whether such proof obligations have been proven or not is sent back to the program proof component. This way, the program proof component can check whether program proofs are complete. The communication between program prover and theorem prover is based on a communication interface that allows one to send formulas from the program prover to the theorem prover. Type check requests differ from proof requests in that they are usually2 solved automatically whereas proof requests typically need user interaction. 2

The subtyping of the used specification language (PVS) is in general undecidable.

68


The Jive Architecture. This subsection describes the overall architecture of Jive. Jive supports the sequential kernel of the Java language including recursive methods, classes, abstract classes, interfaces, thus inheritance and subtyping, static and dynamic binding, aliasing via object references, and encapsulation constructs. Exception handling and some of the predefined data types (in particular float and char) are not yet supported (cf. [MPH99] for a precise description). In addition to the Java subset, Jive supports annotations like that shown in Section 2.1. The common language for programs and annotations is called Anja (annotated Java). In the following, we explain the architectural components and the input sources of proof sessions based on the overview given in Figure 2.

PVS Prelude

Anja Prelude

Program to prove

Formalization of Object Store

Predefined Classes

Program

Abstract Data Types

Specification

Specification

Program Dependent Theories Type check request Theorem Prover Component Type check, Proof request Views (Controls)

Program Prover Component

Syntax Analysis Component Proof obligations

Program information

Program Information Server

Program information request

A C

B : B needs Anja source from A D : D imports PVS theory from C

Fig. 2. The Jive architecture System Components. The architecture is based on five components: 1.) The syntax analysis component that reads in and analyzes annotated programs and generates the program proof obligations. 2.) The program information server that makes the static program information gathered in the analysis phase available to other parts of the system. 3.) The program prover component managing the program proofs. 4.) Views to visualize program proofs and to control proof construction. 5.) The theorem prover to solve program independent proof obligations. In our current implementation, we use PVS for general theorem proving. The program proof component encapsulates the construction of program proofs. It provides two things: (1.) A container which stores all information about program proofs and (2.) an interface which provides operations to create and modify proofs within this container. Since the content of the proof container represents the program proof state, it is strongly encapsulated to the rest of the system. Modifications of the proof state can only be achieved by operations of


69

the container interface (see Section 4). Therefore correctness of proofs is ensured by the correctness of the basic container operations. During program proof construction, various information about the underlying program is needed by the program proof component: The structure of the abstract syntax tree, results of binding and type analysis, and the program unparsing for visualization. This kind of information is provided by the program information server. In contrast to a compiler frontend, all information computed during static program analysis has to be available online after the analysis. Proof Setup. The verification of a program is based on three formal texts: 1.) The PVS prelude containing two parts: (a) the formalization of the objectstore; (b) the specification of abstract data types used in program annotations. Whereas the former part is program independent, the latter may be program dependent. 2.) The Anja prelude containing the specifications of predefined and library classes and interfaces. 3.) An Anja program, i.e. a program in our Java subset together with a suitable interface specification. Annotations are formulated in a language based on the specification language of the underlying theorem prover, i.e. PVS in our case. As illustrated in Section 2, they may refer to program variables and use abtract data types specified in the PVS prelude. From the described sources, the syntax analysis component generates three things: 1. The program proof obligations which need to be proven to guarantee that the program fulfills its specification. They are entered into the proof container. 2. Program dependent theories formalizing some of the declaration information of the program for the theorem prover. 3. The abstract syntax tree decorated with information of the static analysis. It is managed by the program information server. After syntax and static analysis, the system is set up for interactive proof construction. The user constructs program proofs using basic proof operations and tactics (see Section 4). The views and controllers provide access to the proof state. Program independent proof obligation are verified with the general theorem prover. The program prover monitors the overall proof process and signals the completion of proof tasks.

4

The Program Prover

Program proofs in Jive are based on a Hoare logic for object-oriented programs (cf. [PHM99]). Hoare logic is sufficient for our purposes and enables us to visualize proof parts as program annotations. This section first describes how the basic proof operations of the proof container are derived from the logic and how tactics can be formulated. Then, it explains the user interface for proof construction and visualization and sketches a simple proof done within Jive. 4.1

Mechanizing the Programming Logic

As the supported programming language provides recursive methods, the Hoare logic deals with sequents of the form A { P } comp { Q } where A denotes a

70


set of method specifications (the assumptions), P and Q are first-order formulas, and comp denotes a statement or a method, the so-called program component of the sequent. Program components are represented by references to the abstract program syntax tree. A rule in the logic consists of a finite number of antecedents and a sequent as conclusion. The antecedents are either sequents or first-order formulas. Rules without antecedents are called axioms. As examples, we show the rule to verify if-statements and the assumpt-intro-rule to introduce assumptions: A { e ∧ P } stmt1 { Q } , A { ¬e ∧ P } stm2 { Q }

AA

A { P } if (e) { stm1 } else { stm2 } { Q }

A0 , A A

Basic Proof Operations. As usual, proof trees are constructed from rule instances. A tree node has as many children as the rule has antecedents. There are two ways to construct proof trees. 1. A forward proof step takes several proof trees and combines them with a new root node. 2. A backward proof step adds a new node to one of the leaves. A proof tree is closed if all leaves are instances of axioms or first-order formulas that are proved by the theorem prover component. To gain the flexibility explained in Section 2, Jive supports operations for forward and backward proof steps. These operations have to be distinguished, because different directions require different context checks for formulas, program components, and parameters. The if-rule serves as an example: Forward proving combines two proof trees S1 and S2 to a new proof tree, backward proving refines a proof goal G of an if-statement into two subgoals for the then- and else-branch. The context conditions of the if forward and if backward operations are as follows: Forward Proof: 1. S1 and S2 have to be roots of proof trees. 2. The assumptions of S1 and S2 have to be equal. 3. e has to be a conjunct of S1 . 4. ¬e has to be a conjunct of S2 . 5. The preconditions of S1 and S2 have to be equal modulo the conjuncts e and ¬e resp. 6. The postconditions of S1 and S2 have to be equal. 7. stmt1 and stmt2 have to be the then- and elsebranch of the same if-statement.

Backward Proof: 1. G has to be the leaf of a proof tree. 2. The program component of G has to be an if-statement.

Proof operations are executed as follows: First, the context conditions are checked. If they are met, the proof operation is applied and leads to a new proof tree, and thus to a modified state in the proof container. Otherwise, an appropriate exception is raised that can be used in tactics (see below). Because operations first check all necessary context conditions, correctness of proofs is provided by the correctness of operations. The Jive system is currently based on a Hoare logic with 26 rules and axioms. Thus, it provides 52 basic proof operations. In addition, Jive provides a cut operation to remove, a copy operation to copy, a paste operation to combine proof tree parts, and operations to inspect parts of the proof tree or to navigate within proof trees. These operations allow for


71

comfortable interactive work with program proof information, e.g., they enable one to cut off failing proof parts. Tactics. Program proofs are constructed by successively using proof operations as described above. To simplify proof construction, sequences of proof operations, e.g. to apply a weakest precondition strategy, can be combined to form tactics. As an example, we show a tactic that eliminates the assumptions of an open leaf of the proof tree by iterating the assumpt-intro-rule unless all assumptions are eliminated3 . Since the proof operations of Jive are implemented in Java (see Section 4.4), tactics are formulated as Java programs invoking proof operations. The getPre(), getPost(), and getComp() operations return the precondition, the postcondition and the program component of the triple t: public ProofTreeNode eliminate_assumptions(ProofContainer c, ProofTreeNode ptn) throws ContextException { Enumeration e = ptn.getAssumptions().elements(); while(e.hasMoreElements()) { Triple t = (Triple)e.nextElement(); ptn = c.assumpt_intro_backward( ptn,t.getPre(), t.getCompRef(), t.getPost() ); } return ptn; }

4.2

User-Interfaces of the Program Prover

Interactive program proof construction with proof operations enforces users to work explicitly with several kinds of information like formulas, program structures, textual program representation, etc. A graphical user interface is required (1.) for an appropriate visualization of the proof state and of the related information as well as (2.) for convenient selection, input, and application of operations and tactics. Currently Jive provides a so-called tree view and a text view to program proofs4 . Of course, both views can be used together within one proof. Tree View. The tree view (Figure 4 shows a screen shot) presents the information contained in the proof container in a graphical way. All parts of proof trees can be examined, selected, copied, combined, extended and deleted. Compared to the text view (see below), the tree view shows all details of proof trees. In particular, it enables the user to inspect proof steps that cannot be presented as proof outlines and shows the complete proof structure. It supports the structural operations on trees (cut, copy, paste) and proof operations that take several trees as arguments which are not related to one program component. Since proof trees are in general large structures, tree views enable to work with scalable clippings of trees, i.e., the user interface displays only relevant information. 3 4

Applying the assumpt-intro-rule backward eliminates an assumption. At time of submission of this paper, the text view was still under construction.

72


Text View. To provide a more compact view to program proof information and to enable an embedding of program proof information into the program text, text views display selected proof information within a textual program representation (Figure 3 shows a screen shot). This technique is based on so called proof outlines (cf. [Owi75]). The text view allows the user to consider proofs (or at least most of the central proof steps) as annotations to the program text. This turns out to be very helpful for interactive program proofs as the program structure is well-known to the user and simpler to handle. In particular, it allows the direct selection of program components which is needed for forward proofs. In addition to this, well-designed proof outlines are a good means for program and proof documentation. 4.3

Using the Program Prover

In this section, we illustrate the use of the program prover by an example explaining in particular the interaction of automated and manual proof construction. Using an interface of a singly linked integer list, we want to prove a simple recursive sort method: interface List { public List rest() pre aL(this,$) = L; post aL(result,$) = rst(L) AND result /= null; pre $=OS; post $=OS;

class Sort { public static List sort(List l) pre l/=null AND L=aL(l,$); post aL(result,$)=a_sort(L); { List lv,res; boolean bv; int ev;

public int first() pre aL(this,$) = L; post aI(result) = fst(L); pre $=OS; post $=OS; public pre post pre post }

bv = l.isempty(); if(bv) res = l; else { lv = l.rest();ev = l.first(); lv = Sort.sort(lv); res = Sort.sortedIns(ev,lv); } return res; } static List sortedIns(int e, List l) pre aL(l,$)=a_sort(L) AND aI(e)=E AND l/=null; post aL(result,$) = a_sort(app(E,L)); { ... }

boolean isempty() aL(this,$)=L; aB(result)=isempt(L); $=OS; $=OS;

}

In the given Anja source, we use logical variables (written with capital letters) to bind values in the precondition for use in the postcondition. Each list method is specified by two pre-post-pairs. The first pair expresses the functional behavior using the abstraction function aL mapping objects to an abstract list


73

data type. The second pair states that each method does not change the object store. Method sort of class Sort implements insertion sort using sortIns as auxiliary method; a sort sorts an abstract list. We sketch the proof of method sort assuming the correctness of the list interface. sort is a static method, i.e. behaves like procedures in imperative languages. The logical aspects of dynamic binding cannot be discussed here (cf. [PHM99]). Starting the Jive system with the given example yields the following two proof obligations for methods sort and sortedIns:

We start the verification of sort by applying the SWP-tactic to the goal 0. This tactic realizes a simple weakest-precondition-strategy. For the example, it reduces the method specification to a pre-post-pair for the statement sequence in the body. In our logic, this corresponds to two elementary proof steps that in particular conjoin “this = null” to the precondition. Then, the SWP-tactic tries to verify the resulting pre-post-pair by forward proof steps starting with the rightmost innermost statement (according to the AST of the program), i.e., it starts at the end of the program text and works to the beginning. In our case, it automatically handles the return-statement and the then-branch of the if-statement. In the else-branch, it cannot procede because the postcondition of the if-statement does not match the postcondition of the specification for sortedIns. The corresponding proof state is illustrated by the screen shot of the text view in Figure 3. The system uses colors to distinguish program text from annotations and open proof slots (red) from verified triples (green). In the figure, this is indicated by brackets left to the screen shot. The red triple corresponds to the open leaf of the overall proof. The two green triples correspond to needed proof parts that have been constructed by the SWP-tactic. The proof state after termination of a tactic can be interactively manipulated by the user. He or she can add further proof parts using other tactics or basic proof operations and then rerun the original tactic on the original goal. Typically, user interaction is necessary at method invocation sites, because there may be more than one specification for a method and it is not obvious which of them has to be used or how they have to be combined. How to handle such situations is demonstrated with the invocation of method first in the example. We show three states of a forward proof: 1. After instantiating the method specifications at the invocation site (one basic proof step). 2. After conjoining the resulting triple (one basic proof step). 3. After adding of an invariant term (one basic proof step) and eliminating the logical variable OS (several basic proof steps, done by a tactic). For space reasons, we leave out the surrounding window context:

74


• State 1:

• State 2: • State 3: The other method invocations in the else-part of method sort are processed accordingly. The overall proof of method sort is constructed by approx. 90 basic proof operations where currently 20 of them are performed by tactics; 10 mostly trivial implications from weakening and strengthening remain to be verified by the general theorem prover. The tactics are still fairly primitive. With improved tactics and a refined specification technique, we aim to drastically reduce the amount of needed user interaction.

red green

green

Fig. 3. The text view after applying the SWP-tactic.

The presented example shows three important aspects of the system: 1. Forward and backward proving is combined to gain the flexibility needed to encode typical proof strategies. 2. User-guided and automated proof construction by


75

tactics can be freely mixed so that automation can be done where possible and user interaction can focus on the critical points. 3. Different views are needed that allow one to inspect the proof parts on different levels of abstraction. Even in the simple example, there exist up to 7 proof fragments at one time with 17 open proof slots and proof tree depth up to 20. This amount of information is conveniently abstracted by the text view. If detailed information is needed, the user can refer to the tree view (see Figure 4).

Fig. 4. A clipping of the proof tree view 4.4

Technical Issues

This section describes implementation issues concerning the Jive system. System Implementation. As shown in the table below, the Jive system is implemented using a variety of tools and languages, mostly Java. Java combines several necessary properties, which are useful to implement heterogeneous tool environments. In particular, we make use of the Java Native Interface for C, of the API for TCP interfaces to connect to the theorem prover, and of the Swing library as graphical user interface. The central program proof component with the proof operations (as Java Methods) and auxiliary implementations parts such as formula handling is completely implemented in Java. Tactics are implemented as Java classes and can be dynamically loaded into the system. All other components are attached using the above mentioned interfaces. Generative reuse techniques. One major design decision was to use as much as possible generative techniques to implement the system. This is possible because many subtasks to be solved are directly derived from compiler construction. 1. We use flex and bison for the syntax analysis of Anja programs. 2. The program information server is based on attributed abstract syntax trees for programs and annotations. It is generated by the MAX tool (cf. [PH97a]). 3. ANTLR [PQ95] is a compiler generation tool for Java and is used to examine

76


the structure of formulas given as arguments to proof operations. ANTLR is used as it can directly produce Java objects as output. Integration of the PVS Theorem Prover. As explained above, Jive uses PVS for type checking and for the verification of non-Hoare formulas. We use the techniques described in [But97] for the communication between PVS and the program prover. The connection to the proof system is implemented as a TCP connection with the PVS host system Emacs. Because of restrictions in the interface of the PVS system, our current implementation enforces that the user acknowledges in PVS that a proof obligation sent by the program prover has been received. Support for asynchronous communication would be desirable to reduce the need for user interaction. Implementation State and Further Work. The current version of Jive enables one to verify specified program properties of Anja programs as described in Section 3 and 4. We implemented tactics to support weak precondition reasoning for statements and tactics for simplifying method calls. As further implementation steps we consider: 1. The development of more powerful tactics to make reasoning more comfortable. 2. Improvements of the user interface, in particular of the text view. 3. Enhancements to the programming logic, in particular for exception handling. Tool/Language Lines of code Java code 13078 MAX specification 2524 C Code 1768 flex & bison specification 1218 ANTLR specification 854 Emacs lisp code 274 PVS standard prelude for Jive 482 Anja standard prelude for Jive 158

5

Conclusion

Verification of program properties for object-oriented programming languages requires tool support, because the formal framework can hardly be handled by hand. In this paper, we presented the architecture of the interactive program verification environment Jive. Jive combines properties of different approaches to software verification. It divides program proving into a program proving and a theorem proving task. This enables the use of existing theorem provers for the proof steps that are not related to the program. For the program proving tasks, we described a technique to implement a given Hoare logic by basic proof operations supporting forward and backward proofs. Based on these proof operations, powerful tactics can be defined. We sketched the main user interface aspects of the system and described some implementation issues. (Current information about Jive can be obtained at www.informatik.fernuni-hagen.de/pi5/jive.html) Acknowledgments We thankfully acknowledge helpful comments from the reviewers and fruitful discussions with Peter M¨ uller.


77

References But97.

B. Buth. An interface between Pamela and PVS. Technical report, Universit¨ at Bremen, 1997. Available from http://www.informatik.uni-bremen.de/~bb/bb.html 76 Com79. Computer Science Department, Stanford University. Stanford PASCAL Verifier - User Manual, 1979. 66 COR+ 95. J. Crow, S. Owre, J. Rushby, N. Shankar, and M. Srivas. A Tutorial Introduction to PVS, April 1995. 65 DLNS98. D. L. Detlefs, K. R. M. Leino, G. Nelson, and J. B. Saxe. Extended static checking. Research Report 159, Digital Systems Research Center, 1998. 66 GH93. J. V. Guttag and J. J. Horning. Larch: Languages and Tools for Formal Specification. Texts and Monographs in Computer Science. SpringerVerlag, 1993. 64 GMP90. D. Guaspari, C. Marceau, and W. Polak. Formal verification of Ada programs. IEEE Transactions on Software Engineering, 16(9):1058–1075, September 1990. 66 Gor89. M. J. C. Gordon. Mechanizing programming logics in higher order logic. In G. Birtwistle and P.A. Subrahmanyam, editors, Current Trends in Hardware Verification and Automated Theorem Proving. Springer-Verlag, 1989. Kopiensammlung. 66 JvdBH+ 98. B. Jacobs, J. van den Berg, M. Huisman, M. van Berkum, U. Hensel, and H. Tews. Reasoning about Java classes. In Proceedings of ObjectOriented Programming Systems, Languages and Applications (OOPSLA), 1998. Also available as TR CSI-R9812, University of Nijmegen. 65 MPH99. P. M¨ uller and A. Poetzsch-Heffter. Modular specification and verification techniques for object-oriented software components. In G. Leavens and M. Sitaraman, editors, Foundations of Component-Based Systems. Cambridge University Press, 1999. 65, 68 Owi75. S.S. Owicki. Axiomatic proof techniques for parallel programs. Technical report, Computer Science Dept., 1975. 72 Pau94. Lawrence C. Paulson. Isabelle: a generic theorem prover, volume 828 of Lecture Notes in Computer Science. Springer-Verlag Inc., New York, NY, USA, 1994. 65 PH97a. A. Poetzsch-Heffter. Prototyping realistic programming languages based on formal specifications. Acta Informatica, 34:737–772, 1997. 75 PH97b. A. Poetzsch-Heffter. Specification and verification of object-oriented programs. Habilitation thesis, Technical University of Munich, January 1997. 65 PHM99. A. Poetzsch-Heffter and P. M¨ uller. A programming logic for sequential Java. In D. Swierstra, editor, ESOP ’99, LNCS 1576. Springer-Verlag, 1999. 69, 73 PQ95. Terence J. Parr and Russell W. Quong. ANTLR: A predicated-LL(k) parser generator. Software—Practice and Experience, 25(7):789–810, July 1995. 75 Rei95. W. Reif. The KIV approach to software verification. In M. Broy and S. J¨ ahnichen, editors, Korso: Methods, Languages, and Tools for the Construction of Correct Software, volume 1009 of Lecture Notes in Computer Science. Springer-Verlag, 1995. 66

The PROSPER Toolkit Louise A. Dennis1 , Graham Collins1 , Michael Norrish2 , Richard Boulton3 , Konrad Slind2 , Graham Robinson1 , Mike Gordon2 , and Tom Melham1 1

Department of Computing Science, University of Glasgow, G12 8QQ, UK 2 Computer Laboratory, University of Cambridge, CB2 3QG, UK 3 Division of Informatics, University of Edinburgh, EH1 1HN, UK

Abstract. The Prosper (Proof and Specification Assisted Design Environments) project advocates the use of toolkits which allow existing verification tools to be adapted to a more flexible format so that they may be treated as components. A system incorporating such tools becomes another component that can be embedded in an application. This paper describes the Prosper Toolkit which enables this. The nature of communication between components is specified in a languageindependent way. It is implemented in several common programming languages to allow a wide variety of tools to have access to the toolkit.

1

Introduction

Modern system design, both for hardware and software, must meet everincreasing demands for dependable products of high quality, with shorter design times and early error detection. Incremental improvements to conventional design methods and tools are not enough. More powerful techniques of specification and analysis based on formal techniques are essential parts of new methods for design. Formalisms provide specification and analysis at high levels of abstraction, so that designers can express and check a wider range of properties than with conventional techniques. This permits better structuring of complex systems, earlier detection of errors (leading to lower time to market), and higher quality. Making effective use of formal techniques does not have to mean doing ‘total verification’ against ‘complete formal specifications’ or designing step-by-step with a formal refinement theory. This rather modernist Formal Methods programme has still to deliver significant benefits to large-scale design practice, and verification has, in consequence, remained largely an academic activity regarded sceptically by industry. Instead, one can view formal analysis (or ‘propertychecking’) of systems as an advanced or more effective form of testing—whose objective is not necessarily to have a strong assurance of correctness, but rather to eliminate more bugs, earlier in the design process [10]. At present, a developer wishing to incorporate verification capabilities into a CAD or CASE tool, or any application, will face a difficult choice between

Work funded by ESPRIT Framework IV Grant LTR 26241


The PROSPER Toolkit

79

creating a verification engine from scratch and adapting parts of one or more existing tools. Developing a verification engine from scratch is time-consuming and will usually involve re-implementing existing techniques. Existing tools, on the other hand, tend not to be suitable as components that can be patched into other programs. Furthermore, a design tool should embed verification in a way that is natural to a user, i.e. as an extension to the design process (much like debugging is an extension to the coding process). The verification engine must be customised to the application. The Prosper project1 is addressing this issue by researching and developing a toolkit that allows an expert to easily and flexibly assemble proof engines to provide embedded formal reasoning support inside applications. The ultimate goal is to make the reasoning and proof support invisible to the end-user—or at least, more realistically, to incorporate it securely within the interface and style of interaction they are already accustomed to. This paper describes the Prosper toolkit and the methodology of building systems with it. §2 gives a high level view of the toolkit and what a resulting system may look like. While it is inappropriate to give much technical detail here,2 §3 tries to give a flavour of the specification for communication. §4 discusses the methodology for building systems with the toolkit. §5 presents a case study. §6 gives an overview of related work.

2

Design Tools with Custom Proof Engines

A central part of Prosper’s vision is the idea of a proof engine—a custom built verification engine which can be operated by another program through an Application Programming Interface (API). A proof engine can be built by a system developer using the toolkit provided by the project. A proof engine is based upon the functionality of a theorem prover with additional capabilities provided by ‘plugins’ formed from existing, off-the-shelf, tools. The toolkit includes a set of libraries based on a language-independent specification for communication between components of a final system. The theorem prover’s command language is treated as a kind of scripting or glue language for managing plugin components and orchestrating the proofs. The central component is based on a theorem prover because this comes with ready made concepts of term, theorem, and goal, which are important for managing verifications. A side benefit is that all the functionality in the theorem prover (libraries of procedures, tactics, logical theories, etc.) becomes available to a developer for inclusion in their custom proof engine. This does not prevent theorem proving being very lightweight if desired. A toolkit has been implemented based around HOL98, a modern descendent of the HOL theorem prover [11]. HOL98 is highly modular which suits the Prosper approach of building up a proof engine from a set of components (be 1 2

http://www.dcs.gla.ac.uk/prosper Technical documentation is available from the authors.

80

Louise A. Dennis et al.

they HOL libraries or external plugins). It also contains a number of sophisticated automatic proof procedures. HOL’s command language is ML [19] (a strict functional programming language) extended with HOL’s own theorem proving functions which extend ML to include the language of higher order logic [6]. This allows a developer to have a full programming language available in which to develop custom verification procedures. Proof procedures programmed in the proof engine are offered to client applications in an API. This API can be accessed as a verification library in another programming language. The toolkit provides several plugin components based on external tools which offer APIs to a proof engine. It also provides support to enable developers of other verification tools to offer them as Prosper plugins. The application, proof engine and plugins act as separate components in the final system (Figure 1). In the first prototype they are also separate processes.

SMV Plugin API Proof Engine API Design Tool or other Application

Plugin eg. SMV

Proof Engine

ACL2 Plugin API

Plugin eg. ACL2

Fig. 1. A system built with the Prosper toolkit

Communication between them is treated in a uniform manner specified by the Prosper Integration Interface. Work is currently underway to use this technology to add verification capabilities to IFAD’s VDM-SL Toolbox [8]. The project is also building a Hardware Verification Workbench. This will allow specifications in Verilog and VHDL to be checked by a proof engine that incorporates a model checker. Example 1. The IFAD VDM-SL Toolbox is a software design tool supporting the specification language, VDM-SL. The proposed extensions to the Toolbox centre around the discharge of proof obligations generated by type invariants. Invariants are undecidable, so the automatic type checking functionality of IFAD’s toolbox does not check their truth. Many invariants can be discharged by first order logic decision procedures. To utilise these, the invariant condition needs to be translated from VDM-SL into first order logic. In particular, any user-defined functions must be simplified away. More complex simplification and theorem proving techniques can be used when the conditions fall outside the domain of first order logic. If an automatic proof attempt fails then a user must be able to intervene and guide a proof by hand.

The PROSPER Toolkit

81

This analysis suggests that the VDM-SL Toolbox requires a first order logic plugin; a proof engine with an embedding of the semantics of VDM-SL in higher order logic, specialised procedures for simplifying and translating VDM-SL expressions into first order logic (a subset of higher order logic) and some more complex proof techniques; procedures for the automatic generation of invariant proof obligations in the Toolbox itself, and a Toolbox specific interface to the proof guidance facilities provided by HOL. These elements can all be constructed together into the IFAD Toolbox using the Prosper toolkit.

3

The Prosper Integration Interface

A major part of our methodology is the Prosper Integration Interface (PII), a language-independent specification of communication for verification. This specification is currently implemented in several languages (C, ML, Java and Python) allowing components written in these languages to be used together. The PII consists of several parts. The first is a datatype, called interface data, for all data transferred between an application and a proof engine and between a proof engine and its plugins. A major part of the datatype is the language of higher order logic used by HOL and so any formula expressible in higher order logic can be passed between components. Many plugins operate with logical data that is either already a subset of higher order logic (e.g. predicate calculus and propositional logic) or embeddable in it (e.g. CTL). The second part consists of a datatype for the results of remote function calls and support for installing and calling procedures in an API. There are also parts for managing low level communication, which are largely invisible to an application developer. The PII distinguishes between clients and servers. An application is a client of a proof engine which is a client of any plugins it may have. Any server built using the toolkit offers an API to clients. This API describes its functionality in terms of interface data and a result type (which signals whether a function succeeded or failed and returns interface data). As far as an application or verification tool developer is concerned, all components talk the language of these datatypes; The details of translating calls made between components into and out of the raw communication format are entirely invisible. The PII can be viewed as consisting of the layers in Figure 2. The lower layers deal with communication (handling interrupts and so on). The translation layer takes the raw data passed along the communication channel and translates it into the language’s implementation of interface data. The application support layer supplies functions for working with interface data, starting and managing communication between components, and support for working with the API. On top of this sits the target application, proof engine or plugin. The application support layer is the highest specified by the PII. 3.1

Interface Data

Interface data is the high level language passed between components of the system. It can be used to represent a large number of types and expressions.

82


Component Application Support Layer Translation Layer Communication Handling Layer Transport Layer

The Prosper Integration Interface

Physical Transport Mechanism

Fig. 2. The layers of the PII

The PII gives an abstract specification for interface data, but the exact form of the operations and their usage depends on the implementation language. Each element of interface data has three operations, a constructor, a destructor, and a query (is a) function which can be used to establish how an expression has been constructed. Interface data consists of elements based on several standard types (booleans, integers, strings, etc.) and lists (allowing tree structures). It also contains special elements for handling proof concepts (logical terms, the types of logical terms and theorems). Logical Terms and Types. Logical terms are central to the Prosper toolkit and are not a standard feature of any programming language. Logical terms are based on the syntax of classical higher order logic [6] and are the basic expressions for communicating logical information (e.g. conjectures that need proving). As usual with Church-style formulation, there are four basic elements for variables, constants, function applications and lambda abstractions (with associated constructor, destructor and query operations). Higher order logic is typed so it is also possible to query a term for its logical type. These four elements are too low level for everyday use. This is reflected in HOL which supplies derived syntax to provide a usable set of constructors for common term structures. This approach is also adopted by the interface data specification. The interface data derived syntax consists of the usual logical connectives and quantifiers plus a few other common constructs. 3.2

API Support

The PII application support layer provides functions to allow client and server components to handle remote procedure calls. It uses a datatype, interface data result, with constructors mk succeeded:interface data -> interface data result and mk failed:interface data -> interface data result to report back the results of calls.

The PROSPER Toolkit

83

A client can use the operation, call server, which calls a function in another component’s API, referenced by a string, and supplies it with interface data as arguments. It returns an interface data result. A server has some database manipulation functions for using an API database containing functions of type interface data -> interface data result referenced by strings. These are used to process calls from a client. 3.3

Connection Support and Lower Layers

The PII application support layer includes client side functions for connecting to and disconnecting from servers. At present a server has to be started and stopped manually, externally to the client. In future we intend to allow servers to be started and stopped by the client. The low level details of communication handling are only relevant to those wishing to implement the PII in various languages. The underlying communication is currently based on Internet sockets.

4

Using the Toolkit

The basic Prosper toolkit consists of relatively little: a small subset of HOL, called the Core Proof Engine. This consists of a theorem type, inference rules for higher order logic and an ML implementation of the PII. The Core Proof Engine forms the core of all proof engines built using the Prosper Toolkit. A developer can write extensions to the Core Proof Engine and place them in an API to form a custom API. Many applications will require a version of the PII in an implementation language other than ML. The toolkit currently includes PII implementations in several languages and a couple of pre-made plugins (the SMV model checker [17] and Prover Technology’s proof tool [23,22]) which can be added into proof engines. Third party plugins are already also available for ACL2 [4]3 and Gandalf [25,14]. Developing an application using the toolkit is, potentially, a large task involving several languages and programs. We have identified three aspects of working with the toolkit which separate out the tasks involved. These partition the effort into the areas most likely to be undertaken by distinct groups of people. The three aspects also help identify which parts of a final system should be responsible for which tasks. 4.1

The Theorem Prover Aspect

The theorem prover aspect (Figure 3) mainly involves ML programming. This programming effort focuses on developing custom procedures and placing them in an API which extends the Core Proof Engine. A developer will have access to the entire command language of the theorem prover and a set of entrypoints into 3

Currently unpublished, but available at http://www.cl.cam.ac.uk/users/ms204/

84


as many plugins and theories as they might wish and are available. They will be able to develop custom verification procedures and theories within a strongly typed, LCF-style, environment. The outcome will be a custom proof engine with an API that can be passed on to the developer of an application as a verification library.

Custom Proof Engine Plugins HOL ML

Libraries

Core Proof Engine

Fig. 3. The Theorem Prover Aspect

On the logical side, a custom proof engine will probably include an embedding of the formalism used by the application into higher order logic. It will also include automated proof procedures tailored for the application. These procedures may well use plugin decision procedures (e.g. for predicate or propositional logic) or even include, as plugins, verification tools previously developed as support for the application. Construction of such procedures may be a simple process of linking together highly-developed proof libraries and/or plugins or it may require more complex development. Although implementations of the PII provide basic functions for calling proof engine APIs from clients, any serious application will want to wrap up the API with language-specific bindings (e.g. In an object oriented language it would be natural to present functions in a proof engine’s API as methods in some verification class, thus hiding all instances of call server from the application aspect developer). This can only be done if the implementation language of the target application is known. Example 2. In hardware verification there exist many decision procedures for verifying designs. Prosper sees its main application here as verification tasks that can be handled automatically through combinations of plugin decision procedures and theorem proving (see §6). These combined procedures will be developed in the theorem prover aspect and presented as the API to a custom proof engine.

The PROSPER Toolkit

4.2

85

The Application Aspect

The application aspect (Figure 4) focuses on the incorporation of a custom proof engine into an application so that it appears as a natural extension of the application’s functionality. A developer will have access to an API offered by a proof engine already customised to their tool.

Application Application

Programming

API Custom Proof Engine

Language

API wrapper

Fig. 4. The Application Aspect

The aim of Prosper is that verification should fit as seamlessly as possible into the design flow. We envisage that most of the programming at this stage will focus on this task. Example 3. The project is investigating the use of a natural language interface [13] to the Hardware Verification Workbench that will translate statements about circuits, in the normal technical language of engineers, into CTL propositions that a proof engine can verify. This will allow engineers to be largely unaware of the mathematical verification that is taking place. 4.3

The Plugin Aspect

The Prosper toolkit supports a third aspect (Figure 5). The developer of a verification tool can adapt it so that it can be used as a Prosper plugin. A plugin developer programs both in ML and in the plugin’s own implementation language. The developer will place chosen entrypoints to the plugin into an API database. In the plugin’s implementation language they will translate any arguments needed by these functions into interface data. In the theorem prover’s command language they will need to unpackage these entrypoints again so they present themselves as language-specific bindings in that language (ML). In particular any additional theories required (i.e. an embedding of the logic used by the plugin into higher order logic) should be provided by the plugin developer. The plugin aspect is analogous to the theorem prover aspect except that it is assumed that the underlying functionality for the API is already implemented and provision of language-specific bindings is strongly recommended since the target language is known.

86


Prospective Proof Engine

Tool Language

ML

Programming

API Bindings

PII Implementation

Verification Tool

PII Implementation (Tool language)

(ML)

Fig. 5. The Plugin Aspect

It is also possible to run a verification tool in a ‘harness’ provided by the Prosper toolkit. This talks to a tool’s command line. This allows almost any tool to be used as a plugin, although the tool must be treated as a black box. 4.4

A Complete System

An application developer’s view of a complete system should be something like Figure 6. Components are accessible to each other via their APIs. Communication is made possible by low-level functionality irrelevant to the developer. Components can be subdivided into those parts that provide important functionality, databases of functions in the component’s API, and modules expressing the functionality of some other component’s API.

Interface data

API Data Base

Application

API Bindings

Low Level Details

Interface data

API Data Base

Proof Engine

PlugIn API ML Bindings

Low Level Details

Fig. 6. A complete system

Plugin

The PROSPER Toolkit

87

Someone working with such a system can issue an instruction which invokes verification. Such an instruction may arise automatically in response to certain actions they take in the process of design. This instruction states some conjecture which is translated into interface data and passed to a function in the API of the proof engine. This function may, by way of example, break the conjecture down into a number of sub-problems some of which are dealt with by procedures in the proof engine and some of which are passed on as interface data to a function in the API of a plugin. The plugin function executes and returns a result. The proof engine takes the result and may do some more processing on it before passing back its own result to the application. If this is successful and the verification arose automatically the user may not even be aware that anything has taken place. If it is unsuccessful then the user might receive a warning message about the actions they have just performed.

5

Case Study

We present a case study of the use of the Prosper toolkit to embed some simple verification into a well known, existing application. Excel is a spreadsheet package marketed by Microsoft [18]. Its basic constituents are rows and columns of cells into which either values or formulae may be entered. Formulae refer to other cells, which may contain either values or further formulae. Users of Excel are likely to have no interest in using or guiding mathematical proof, but they do want to know that they have entered formulae correctly. They therefore have an interest in ‘sanity checking functions’ that they can use to reassure themselves of correctness. As a simple case study, the Prosper toolkit developers undertook to incorporate a sanity checking function into Excel. We chose to implement an equality checking function which would take two cells containing formulae and attempt to determine whether these formulae were equal for all possible values of the cells to which they refer. Simplifying assumptions were made for the case study. The most important were that cell values were only natural numbers or booleans and that only a small subset of the functions available in Excel (some simple arithmetical and logical functions) appeared in formulae. Given these assumptions, less than 150 lines of code were needed to produce a prototype. This prototype handled only a small range of formulae, but it demonstrated the basic functionality. While the resulting program is clearly not marketable (requiring two machines using two different operating systems) it was pleasing to find it so easy to embed some verification into an existing program. 5.1

Architecture

The main difficulty in the case study was that Excel is Windows based, whereas the prototype toolkit had been developed for UNIX machines.4 A subsidiary 4

We intend to port a future version to Windows.

88


difficulty was that the PII was not implemented in Visual Basic, the macro language of Excel. These problems were solved by using a Python implementation of the PII. Python has library support for COM (a middleware component standard which is also supported by Visual Basic and is a common way to add functionality to Excel). Python also has a freely available socket library, allowing a Python program on Windows to communicate via sockets with a proof engine on UNIX. The decision was taken not to implement the PII in Visual Basic but to call a Python COM server to handle the tasks in the application aspect and communicate both as a client to the proof engine running under Linux and as a server to an Excel COM client running under Windows. The easiest way to access Excel’s formulae is as strings. It would have been necessary, whatever the approach taken, to parse these into interface data logical terms and it was unimportant whether this effort was made in Visual Basic or in Python. We hope that a Python based COM component implementing the PII will be of more general interest and use than a Visual Basic implementation of the PII would have been. A view of the architecture is shown in Figure 7.

Strings Excel

COM Server/ PII Client

Interface Data Proof Engine

Prover Plugin

Windows

UNIX

Fig. 7. The architecture of Excel with embedded verification

5.2

The Theorem Prover Aspect

The initial custom procedure is very simple-minded. It uses an arithmetic decision procedure provided by HOL98 and a propositional logic plugin decision procedure (based on Prover Technology’s proof tool [23,22]) to decide the truth of formulae. While the approach is not especially robust, it is strong enough to handle many simple formulae. This proved to be a very small piece of code (approx. 45 lines of ML were needed to write the function and place it in the API database). A more developed version of such a proof engine would require longer, more specialised code. 5.3

The Application Aspect

A function, ISEQUAL, was written using Excel’s macro editor. Once written, it automatically appears in Excel’s function list as a User Defined Function and

The PROSPER Toolkit

89

can be used in a spreadsheet like any other function. ISEQUAL takes two cell references as arguments. It recursively extracts the formulae contained in the cells as strings (support for this already exists in Excel) and passes them on to the Python object. The Python component parses the strings to interface data logical terms, which it passes on to the decision procedures in the proof engine. It returns the result of the proof attempt as true, false, or ‘unable to decide’, which is displayed in the cell containing the ISEQUAL formula. The application aspect consisted of roughly 30 lines of Visual Basic code and 30 of Python code. We feel that the case study illustrated the relative speed and simplicity with which a prototype of embedded verification can be produced using the Prosper toolkit.

6

Related Work

Combined Tools. There are many decision procedures available as verification tools, especially for use with hardware verification. They all have practical limits on the size of design with which they can cope. There has also been a great deal of recent work in combining decision procedures (in particular model checkers) with automated theorem proving to increase the size of design that can be dealt with [1,15,20,21]. The Hardware Verification Workbench, that the Prosper project plans to produce, will hopefully make use of much of the knowledge and techniques developed for integrating model checkers and theorem proving. In a slightly different vein the HOL/CLAM project [3] linked HOL to CLAM [5], a proof planning system which specialises in automating inductive proof. The HOL/CLAM project is, in some ways, a predecessor to Prosper and much has been learned from it. All this work has focused on producing one customised solution whereas Prosper hopes to provide a framework in which many such interactions can be investigated. Integration Architectures. There are several projects that provide a generic framework for the integration of tools. Ωmega [2] is a system developed to act as a mathematical assistant. Like Prosper, Ωmega makes use of other reasoning systems (e.g. resolution theorem provers and computer algebra systems). These are all incorporated into a distributed MathWeb [9] and there is work in progress to produce a standard interface for integrating components. ETI [24], the Electronic Tool Integration platform, is an ambitious project aimed at allowing both the easy and rapid comparison of tools purporting to do similar jobs, and also the rapid prototyping of combinations of such tools (any software tool, not just verification tools). ETI has its own language, HLL, which acts much like Prosper’s combination of ML and interface data to provide a scripting language for tool integration. It is also possible to automatically generate glue code from easily written specifications. The ETI’s implementation

90


is based on C++, which allows all tools written in C++ to be treated in a glass box fashion, just as Prosper allows all tools written in the languages which implement the PII to be treated as glass boxes. The OMRS project aims to develop an open architecture for reasoning systems to be integrated together relatively easily. This architecture consists of three components: the logic of the system [12], the control strategies used by the system [7], and the interaction mechanisms supported by the system. Its framework forces systems to identify clearly what are the sequents, inference rules, control information, etc. and so makes them more open and extensible. The intention is that future reasoning systems will be developed using the OMRS architecture. At the same time work is underway to re-engineer popular existing tools, most notably ACL2 [4], so that they conform to the OMRS specifications. These systems all allow the integration and combination of verification components ranging from an entirely black box treatment to an entirely glass box treatment in the case of OMRS. We prefer an easier and more flexible approach than OMRS allowing off-the-shelf integration rather than re-engineering. This means it is easier to build an unsound tool with our toolkit. We are not ignoring the logical issues but intend to solve them on an ad hoc basis. ETI is wider in scope but less specific than Prosper. It is forced to treat some components as black boxes, which is inappropriate for many of the interactions Prosper wishes to study. On the other hand, in many cases it is simple to experiment with coordination of several tools using ETI because of its automatic synthesis features. Design Tools with Embedded Verification. The UniForM project aims to encourage the development of reliable software for industrially relevant tasks by enabling suitable tool-supported combinations of formal methods. The UniForM Workbench [16] is intended to be a generic framework, instantiated with specific tools. The project has produced a workbench for software design that gives access to the Isabelle theorem prover plus other verification tools through their command lines. The various components are held together by Concurrent Haskell, which is used as a sophisticated encapsulation and glue language. The UniForM project is similar to Prosper, with its focus on the integration of component based verification into design tools, its use of a functional language to manage the various components, and the provision of a theorem prover to perform logical tasks. But, the Workbench is a design tool in its own right rather than a toolkit for embedding verification into a design tool. The Workbench also treats plugin decision procedures as black boxes. We are not aware of any project, other than Prosper, which easily allows the integration of existing components with the view to producing an embeddable customised proof engine.

7

Conclusions

For embedded (possibly invisible) verification engines to gain widespread acceptance and use, verification tools must be customisable and combinable. We

The PROSPER Toolkit

91

believe the way forward draws on many of the standard aspects of component technology but also requires dedicated support for building custom proof engines, such as language-independent datatypes for communicating logical concepts. We hope that the work on Prosper has been a significant step forward in establishing the nature of the support needed to encourage embedded verification. The focus of future work centres around three areas: basic improvements of the underlying implementation; case studies of the effectiveness of the toolkit (we are interested not only in the ease with which theorem proving can be embedded in an application but also in the benefits gained from the combination of theorem proving and decision procedures) and the development of generic proof support for integrated verification (procedures for handling certain classes of plugin effectively, methodologies for ensuring soundness, etc.). Most importantly, we believe the way to encourage the incorporation of formal verification within design flows is not through the provision of some large tool that can perform a wide range of verification tasks but through the provision of a toolkit that allows the development of specialised proof engines.

References 1. M. D. Aagaard, R. B. Jones, and C.-J. H. Seger, Lifted-FL: A Pragmatic Implementation of Combined Model Checking and Theorem Proving. Y. Bertot, G. Dowek, A. Hirshowitz, C. Paulin and L. Théry (eds), Theorem Proving in Higher Order Logics, Lecture Notes in Computer Science 1690, Springer-Verlag, pp. 323–340, 1999. 89 2. C. Benzm¨ uller, L. Cheikhrouhou, D. Fehrer, A. Fiedler, X. Huang, M. Kerber, M. Kohlhase, A. Meirer, E. Melis, W. Schaarschmidt, J. Siekmann, and V. Sorge, Ωmega, Towards a mathematical assistant. 14th Conference on Automated Deduction, W. McCune (ed), Lecture Notes in Artificial Intelligence 1249, SpringerVerlag, pp. 252–255, 1997. 89 3. R. Boulton, K. Slind, A. Bundy, and M. Gordon, An interface between CLAM and HOL. J. Grundy and M. Newey (eds), Proceedings of the 11th International Conference on Theorem Proving in Higher Order Logics, Lecture Notes in Computer Science 1479, Springer-Verlag, pp. 87–104, 1998. 89 4. B. Brock, M. Kaufmann, and J Moore, ACL2 Theorems about Commercial Microprocessors. M. Srivas and A. Camilleri (eds), Proceedings of Formal Methods in Computer-Aided Design (FMCAD’96), Springer-Verlag, pp. 275–293, 1996. 83, 90 5. A. Bundy, F. van Harmelen, C. Horn, and A. Smaill, The Oyster-Clam system. 10th International Conference on Automated Deduction, M. E. Stickel (ed), Lecture Notes in Artificial Intelligence 449, Springer-Verlag, pp. 647–648, 1990. 89 6. A. Church, A Formulation of the Simple Theory of Types. The Journal of Symbolic Logic, vol. 5, pp. 56–68, 1940. 80, 82 7. A. Coglio, The Control Component of OMRS: NQTHM as a Case Study. Extended abstract in Proceedings of the First Workshop on Abstraction, Analogy and Metareasoning, IRST, Trento, Italy, pp. 65–71, 1996. 90 8. J. Fitzgerald and P. G. Larsen, Modelling Systems: Practical Tools and Techniques in Software Development, Cambridge University Press, 1998. 80 9. A. Franke, S. M. Hess, C. G. Jung, M. Kohlhase, and V. Sorge, Agent-Oriented Integration of Distributed Mathematical Services. Journal of Universal Computer Science, 5(3), pp. 156–187, 1999. 89

92


10. J. A. Goguen and Luqi, Formal methods and social context in software development. Proceedings TAPSOFT’95, Lecture Notes in Computer Science 915. Springer-Verlag, pp. 62–81, 1995. 78 11. M. J. C. Gordon and T. F. Melham (eds), Introduction to HOL: A theorem proving environment for higher order logic, Cambridge University Press, 1993. 79 12. F. Giunchiglia, P. Pecchiari, and C. Talcott, Reasoning Theories: Towards an Architecture for Open Mechanized Reasoning Systems. F. Baader and K. U. Schulz (eds), Frontiers of Combining Systems—First International Workshop (FroCoS’96), Kluwer’s Applied Logic Series (APLS), pp. 157–174, 1996. 90 13. A. Holt and E. Klein, A semantically-derived subset of English for hardware verification. 37th Annual Meeting of the Association for Computational Linguistics: Proceedings of the Conference, Association for Computational Linguistics, pp. 451– 456, 1999. 85 14. J. Hurd, Integrating Gandalf and HOL. Y. Bertot, G. Dowek, A. Hirshowitz, C. Paulin and L. Théry (eds). Theorem Proving in Higher Order Logics, Lecture Notes in Computer Science 1690, Springer-Verlag, pp. 311–321, 1999. 83 15. J. Joyce and C.-J. Seger, Linking BDD based symbolic evaluation to interactive theorem proving. ACM/IEEE Design Automation Conference, June 1993. 89 16. B. Kreig-Br¨ ukner, J. Peleska, E.-R. Olderog, and A. Baer, The UniForM WorkBench, a Universal Development Environment for Formal Methods. J. M. Wing, J. Woodcock and J. Davies (eds), FM’99—Formal Methods, vol. 2, Lecture Notes in Computer Science 1709, pp. 1186–1205, 1999. 90 17. K. L. McMillan, Symbolic Model Checking, Kluwer Academic Publishers. 1993. 83 18. Microsoft Corporation, Microsoft Excel, http://www.microsoft.com/excel. 87 19. R. Milner, M. Tofte, R. Harper and D. MacQueen, The Definition of Standard ML (Revised), MIT Press, 1997. 80 20. J. O’Leary, X. Zhao, R. Gerth, and C.-J. H. Seger, Formally verifying IEEE compliance of floating-point hardware. Intel Technology Journal, First Quarter, 1999. Online at http://developer.intel.com/technology/itj/. 89 21. S. Rajan, N. Shankar, and M. Srivas, An integration of model checking and automated proof checking. International Conference on Computer-Aided Verification, Lecture Notes in Computer Science 939, Springer-Verlag, pp. 84–97, 1995. 89 22. M. Sheeran and G. St˚ almarck, A tutorial on St˚ almarck’s proof procedure for propositional logic. The Second International Conference on Formal Methods in Computer-Aided Design, Lecture Notes in Computer Science 1522, Springer-Verlag, pp. 82–99, 1998. 83, 88 23. G. St˚ almarck and M. S¨ aflund, Modelling and Verifying Systems and Software in Propositional Logic. Proceedings of SAFECOMP ’90, Pergamon Press, pp. 31–36, 1990. 83, 88 24. B. Steffen, T. Margaria, and V. Braun, The Electronic Tool Integration Platform: concepts and design. International Journal on Software Tools for Technology Transfer, 1(1 + 2), pp. 9–30, 1997. 89 25. T. Tammet, A resolution theorem prover for intuitionistic logic. 13th International Conference on Automated Deduction, Lecture Notes in Computer Science 1104, Springer-Verlag, pp. 2–16, 1996. 83

CASL: From Semantics to Tools Till Mossakowski Department of Computer Science and Bremen Institute for Safe Systems, Universit¨ at Bremen, P.O. Box 330440, D-28334 Bremen [email protected]

Abstract. CASL, the common algebraic specification language, has been developed as a language that subsumes many previous algebraic specification frameworks and also provides tool interoperability. CASL is a complex language with a complete formal semantics. It is therefore a challenge to build good tools for CASL. In this work, we present and discuss the Bremen HOL-CASL system, which provides parsing, static checking, conversion to LATEX and theorem proving for CASL specifications. To make tool construction manageable, we have followed some guidelines: re-use of existing tools, interoperability of tools developed at different sites, and construction of generic tools that can be used for several languages. We describe the structure of and the experiences with our tool and discuss how the guidelines work in practice.

1

Introduction

During the past decades a large number of algebraic specification languages have been developed. Unfortunately, these languages are based on a diversity of basic algebraic specification concepts. The presence of so many similar specification languages with no common framework had hindered the dissemination and application of research results in algebraic specification. In particular, it had made it difficult to produce educational material, to re-use tools and to get algebraic methods adopted in industry. Therefore, in 1995, an initiative, CoFI1 , to design a Common Framework for Algebraic Specification and Development was started [18]. The goal of CoFI is to get a common agreement in the algebraic specification community about basic concepts, and to provide a family of specification languages at different levels, a development methodology and tool support. The family of specification languages comprises of a central, common language, called CASL2 , various restrictions of CASL, and various extensions of CASL (e.g. with facilities for particular programming paradigms). The definition of CASL and some of its sublanguages has been finished [8]. Moreover, a complete formal semantics of CASL [9] has been developed in parallel with design of the language and indeed, the development of the semantics has given important feedback to the language design. 1 2

CoFI is pronounced like ‘coffee’. CASL is an acronym for CoFI Algebraic (or Axiomatic) Specification Language and is pronounced like ‘castle’.


94

Till Mossakowski

Now that design and semantics of CASL have been finished, it is essential to have a good tool support. Tools will be essential for the goal of CoFI to get CASL accepted in academic communities (in the short run), and, in the long run, in industry. This holds even stronger since CASL is a language with a formal semantics: many people believe that such a language cannot or will not be used in practice: “The best semantics will not win.” [13] Since CASL was designed with the goal to subsume many previous frameworks, it has become a powerful and quite complex language. This complexity makes it harder to build tools covering the whole language. In this work, we will show that it is possible to build tools for a complex language with strong semantics in a reasonable time. In order to achieve this, we have followed several guidelines: – As much as possible, re-use existing tools, instead of building new ones. – Build tools in such a way that tools developed at different sites can be integrated; thus, not every site has to develop all the tools. – Make tools as generic as possible. After all, CASL only is the central language in a whole family of languages, and it would be tedious to have to re-implement the same things for each language separately. All these guidelines are even more important in a non-commercial environment as the CoFI initiative is, where only very limited (wo)man-power is available, and therefore collaborative effort is essential. Moreover, an explicit goal within the design of CASL was to provide a common language in order to achieve a better interoperability of (already existing) tools. We will discuss these guidelines, reporting how well they work in practice and which difficulties arise with them. The paper is organized as follows: Section 2 gives a brief overview over CASL and its semantics. Section 3 explains the general architecture of the Bremen HOL-CASL tool. In section 4, tool interoperability using a common interchange format is discussed. Section 5 describes the problems with parsing CASL’s mixfix syntax. Section 6 recalls the encoding of CASL in higher-order logic from [17], while section 7 reports our practical experiences when using this encoding to create an interface from CASL to Isabelle/HOL. In section 8, some difficulties of encoding CASL structured specifications into Isabelle are discussed. Section 9 describes several user interfaces for HOL-CASL. Finally, section 10 contains the discussion how the guidelines work in practice, and directions for future work. This work is based on [17], but considerably extends the work begun there.

2

CASL

CASL is a specification language that can be used for formal development and verification of software. It covers both the level of requirement specifications, which are close to informal requirements, and of design specifications, which are close to implemented programs. CASL provides constructs for writing

CASL: From Semantics to Tools

95

– basic specifications (declarations, definitions, axioms), – structured specifications (which are built from smaller specifications in a modular way), – architectural specifications (prescribing the architecture of an implementation), and – specification libraries, distributed over the Internet. Basic CASL specifications consist of declarations and axioms representing theories of a first-order logic in which predicates, total as well as partial functions, and subsorts are allowed. Predicate and function symbols may be overloaded [4]. Datatype declarations allow to shortly describe the usual datatypes occurring in programming languages. Structured specifications allow to rename or hide parts of specifications, unite, extend and name specifications. Moreover, generic specifications and views allow to abstract from particular parts of a specification, which makes the specification reusable in different context. Architectural specifications allow to talk about implementation units and their composition to an implementation of a larger specification (or, vice versa, the decomposition of an implementation task into smaller sub-tasks). Structured and architectural specifications together with libraries will be also referred to as CASL-in-the-large, while basic specifications will be referred to as CASL-in-the-small. The semantics of CASL follows a natural semantics style and has both rules for static semantics (which are implemented by a static semantic checker) and model semantics (which are implemented by theorem-proving tools).

spec List [sort Elem;] = :: (head :? Elem; tail :? List[Elem]); free type List[Elem] ::= nil | %list [ ], nil , :: op ++ : List[Elem] × List[Elem] → List[Elem]; :: < ++ %prec vars e : Elem; K , L : List[Elem] • %[concat nil ] nil ++L = L • %[concat cons] (e :: K ) ++L = e :: K ++L end

Fig. 1. Specification of lists over an arbitrary element sort in CASL

Consider the specification of lists over an arbitrary element sort in Fig. 1. The free type construct is a concise way to describe inductive datatypes. The semantic effect is the introduction of the corresponding constructor (here nil and :: ) and (partial) selector (here head and tail) functions, and of a number of axioms: a so-called sort generation constraint stating that the datatypes

96

Till Mossakowski

are inductively generated by the constructors and possibly by parameter sorts (here: the sort Elem), and first-order axioms expressing that the constructors are injective and have disjoint images and that the partial selectors are one-sided inverses of the corresponding constructors. :: allows to write lists in the form The annotation %list [ ], nil, [t1 , . . . , tn ]. This notation is not restricted to lists: with %list, one also can introduce abbreviating notations for sets, bags, etc.

3

Tool Architecture

Formatted CASL Text

CASL Text

LaTEX System

Parser

TEX Code

Aterms

LaTEX Formatter

Static Checker

other parser

Aterms Encoding into FOL/HOL

other rewriting engine other theorem prover

Aterms Transformation System

Isabelle/HOL Prover

Fig. 2. Architecture of the HOL-CASL system

The Bremen HOL-CASL system consists of several parts, which are shown in Fig. 2. The parser checks the syntactic correctness of a specification (CASL Text) according to the CASL grammar and produces an abstract syntax tree (coded as ATerms). The static checker checks the static semantic correctness (according to the static semantics) and produces a global environment (also coded as ATerms) that associates specification names with specification-specific information such as the signature. The LATEX formatter allows to pretty print CASL specifications (which are input in ASCII format), using the CASL LATEX package from Peter Mosses [19]. For example, the specification in Fig. 1 has been generated from the ASCII input shown in Fig. 4. Finally, the encoding is a bridge from CASL to first- or higher-order logic (FOL/HOL). It throws out subsorting and partiality by encoding it [17], and thus allows to re-use existing theorem proving tools and term rewriting engines for CASL. Typical applications of a theorem prover in the context of CASL are


97

– checking the model-semantic correctness of a specification (according to the model semantics) by discharging the proof obligations that have been generated during static semantic analysis, – validate intended consequences, which can be added to a specification using an annotation. This allows a check for consistency with informal requirements, – prove correctness of a development step (in a refinement).

4

Tool Interoperability

The are quite a number of existing specifications languages and tools for them. CASL was designed with the goal of providing a common language for better tool interoperability. This is reflected by having a common interchange format for CASL tools, the ATerm format [3]. ATerms are an easy-to-handle format with libraries in several languages (C, Java) available. The main reason for chosing ATerms was that the untyped term structures are very flexible, and their easy syntax makes it very easy to write parsers and printers for them (we needed to implement these in our implementation language, ML, which has been done very quickly). Thus, ATerms are used as (untyped) low level tool format for data exchange between CASL tools. Based on this format, several (strongly typed) formats have been designed: the CasFix format [26] for abstract syntax trees, and a format for the global environment, containing the static semantic information. A problem with ATerms is that the textual representation gets very large (the ATerm representation of the global environment for the CASL basic data types is about 10 MB). [3] have solved this problem by providing a compact binary format with full sharing of subterms. This format can deal efficiently even with Gigabyte-sized structures. However, parsers and printers for this format are more complex. Thus, we are using converters between the textual and the binary ATerm format written in C as a workaround, until an ML-based ATerm library dealing also with the binary format becomes available. By providing conversions from and to ATerms at all intermediate points in the tool architecture, the Bremen HOL-CASL system can be used as a front-end or back-end in combination with other tools. Actually, it has been combined as a back-end with the Amsterdam CASL parser [27], and as a front-end with several theorem proving tools: ELAN [21], PVS [2] and Isabelle (see section 7). See also the CoFI Tools Group home page [10].

5

Parsing and Static Semantic Analysis

Apart from having a relatively complex grammar, CASL has several features that cause some difficulties for parsing and static analysis:

98

Till Mossakowski

1. CASL’s syntax allows user-defined mixfix syntax, 2. CASL allows mutually recursive subsort definitions, causing loops within a naive subsorting analysis, and 3. CASL allows overloading, and formulas which have a unique overload resolution up to semantical equivalence. Concerning mixfix syntax, we separate parsing into two steps: The first pass of parsing produces an abstract syntax tree where formulas and terms (i.e. those parts of the specifications that may contain mixfix symbols) remain in their unparsed textual form. Mixfix grouping analysis can be done only after a first phase of static semantic analysis has collected the operation and predicate symbols (among them the mixfix symbols). The CASL grammar is then extended dynamically according to the mixfix declarations, and formulas and terms are parsed with the generic Isabelle parser, which uses the well-known Cocke-Younger-Kasami algorithm for context-free recognition [11]. This grammar-parameterised algorithm has a complexity of O(n3 ), which is quite acceptable, since formulas and terms in CASL specifications are not that long. However, it turned out to be too slow to do the first pass of parsing with this approach. Therefore, we moved to ML-yacc for the first pass. After having done the parsing of terms and formulas, those resulting parse trees are selected that are precedence correct with respect to the user-specified precedence relations. If more than one parse tree remains, the corresponding term or formula is ambiguous, and the possible disambiguations are output to the user. To obtain a concise output, not all pretty-printed forms of the parse trees are shown, but only the local places at which they actually differ. The definition of precedence correctness follows the one of [1], generalized to CASL’s pre-order based precedences ([1] uses number based precedences). Concerning static semantic analysis, the treatment of subsorts and overload resolution needs a careful algorithmic design in order not to run into an exponential time trap. The details of this have already been worked out in [17].

6

Encoding CASL into HOL

In this section, we briefly recall the encoding from CASL into HOL from [17]: At the level of CASL basic specifications, the encoding into higher-order logic proceeds in three steps: 1. The CASL logic, subsorted partial first-order logic with sort generation constraints (SubPCFOL), is translated to subsorted first-order logic with sort generation constraints (SubCFOL) by encoding partiality via error elements living in a supersort. 2. Subsorted first-order logic with sort generation constraints (SubCFOL) is translated to first-order logic with sort generation constraints (CFOL) by encoding subsorting via injections (actually, this is built-in into the CASL semantics [4]).


99

3. First-order logic with sort generation constraints (CFOL) is translated to higher-order logic (HOL) by expressing sort generation constraints via induction axioms. These encodings are not only translations of syntax, but also have a modeltheoretic counterpart3 , which provides an implicit soundness and completeness proof for the re-use of HOL-theorem provers for theorem proving in the CASL logic SubPCFOL. This is also known as the “borrowing” technique of Cerioli and Meseguer [5], which allows to borrow theorem provers across different logics.

7

The Interface to Isabelle/HOL

Using the encoding described in the previous section, we have built an interface from CASL to Isabelle/HOL. We have chosen Isabelle [20] because it has a very small core guaranteeing correctness. Furthermore, there is over ten years of experience with it (several mathematical textbooks have partially been verified with Isabelle). Last but not least, Isabelle is generic, i.e. it supports quite a number of logics, and it is possible to define your own logic within Isabelle. Despite the genericity of Isabelle, we have refrained from building the CASL logic directly into Isabelle – this would violate our guideline to re-use existing tools as much as possible: we would have to set up new proof rules, and instantiate the Isabelle simplifier (a rewriting engine) and tableau prover from scratch. Instead, we re-use the Isabelle logic HOL, for which already sophisticated support is available, with the help of the encoding described in section 6. This encoding has a clear semantical basis due to the borrowing (most other encodings into Isabelle/HOL do not have an explicit model-theoretic counterpart). However, a good semantic basis does not imply that there are no practical problems: First, the encoding of CASL in Isabelle/HOL as described in [17] produces too complex output. We had to fine-tune the output by suppressing superfluous parts (for example, trivial subsort injections), while retaining its mathematical correctness. Another problem with borrowing is that the HOL-CASL user really works with the encoding of a CASL specification, and not with the CASL specification itself. In particular, goals and subgoals are displayed as HOL formulas, and the proof rules are of course the Isabelle/HOL proof rules. However, a typical user of the tool will probably be more familiar with CASL than with Isabelle/HOL. Therefore, we have decided to display goals and subgoals in a CASL-like syntax as much as possible. For example, an injection of a term t from a subsort s1 to a supersort s2 is displayed as t : s2, as in CASL, and not as injs1,s2 (t), as the encoding would yield. In this way, we get a CASL-like display syntax of Isabelle/HOL. Let us call this display syntax “CASLish Isabelle/HOL”. However, note that the CASLish Isabelle/HOL omits some information, e.g. the information that an injection injs1,s2 (t) starts from s1. In some practical example proofs, this turned out to be rather confusing (while in others, the longer 3

Formally, they are institution representations in the sense of [16,24]

100

Till Mossakowski

form injs1,s2 (t) is just tedious), and one would like to go back to the “pure Isabelle/HOL” view of the subgoals instead of using the “CASLish Isabelle/HOL”. Therefore, we plan to let the user choose among several pretty printing “views” on his or her encoded CASL specification. Another example for the mixture of CASL and Isabelle/HOL are Isabelle’s two different kinds of free variables, which may occur in CASL formulas during a proof. Isabelle one one hand has object variables, which cannot be instantiated during a proof. They are used for proofs of universally quantified sentences. The other kind of variables are meta variables, which can be instantiated during a proof. They are used for proofs of existentially quantified sentences (cf. Prolog, narrowing). For example, when trying to prove ∃ x : N at • x + 9 = 12 by elimination of the existential quantifier, one gets ?x + 9 = 12 and then ?x is instantiated with 3 during the proof (while the goal x + 9 = 12 would not be provable, since ∀ x : N at • x + 9 = 12 is false).

Level 0 ((K ++ L) ++ M) = (K ++ (L ++ M)) 1. ((K ++ L) ++ M) = (K ++ (L ++ M)) Level 1 ((K ++ L) ++ M) = (K ++ (L ++ M)) 1. !!x1 x2. ((x2 ++ L) ++ M) = (x2 ++ (L ++ M)) =>(((x1 :: x2) ++ L) ++ M) = ((x1 :: x2) ++ (L ++ M)) 2. ((nil ++ L) ++ M) = (nil ++ (L ++ M)) Level 2 ((K ++ L) ++ M) = (K ++ (L ++ M)) No subgoals!

Fig. 3. Proof of forall K,L,M:List[Elem] . (K++L)++M=K++(L++M)

Fig. 3 shows a proof of the associativity of the concatenation of lists, using the specification from Fig. 1. Level 0 shows the original goal. In the first proof step (level 1), the goal was resolved with the sort generation constraint for lists. The two subgoals are the inductive arguments for :: and nil, respectively. In the second step, both subgoals can be proved feeding the axioms concat nil and concat cons into Isabelle’s simplifier (a rewriting engine).


101

Another problem is that of input of goals. Goals are of course input in the CASL syntax (only during a proof, they get redisplayed in CASLish Isabelle/HOL syntax). One would like also to be able to input goals in Isabelle/HOL, for example when one needs to prove a lemma that is formulated in Isabelle/HOL. We solve this by providing Isabelle/HOL as a theory within our interface, and we parse goals that are input for this theory always with the Isabelle/HOL parser, and not with the CASL parser.

8

Encoding of CASL Structured Specifications

The encoding of structured specifications is almost orthogonal to that of basic specifications and therefore can be done in a generic, logic-independent way. When encoding CASL structured specification into Isabelle, the problem arises that the structuring mechanism of CASL and Isabelle are rather different. In particular, Isabelle’s mechanisms are considerably weaker: Extensions and unions of specifications are available in Isabelle (though the union is defined is a slightly different way), while for CASL’s renamings, hidings, and generic specifications, nothing similar is available in Isabelle. Currently, we solve this problem by just flattening structured specifications to basic specifications, that is, we literally carry out all the renamings, unions etc. Hidings can be treated by renaming the symbol which shall be hidden with a unique name that cannot be input by the user. However, this is not very satisfactory, since flattening destroys the structural information of a specification and thus makes theorem proving in the specification harder. In some cases, the loss of structural information makes it practically infeasible to do proofs which are doable when the structuring is kept. Therefore, we have asked the Isabelle implementors to improve Isabelle’s structuring mechanisms, and they have promised to do something in this direction. In principle, an alternative way would be to use a deep encoding of CASL, which means to directly describe the semantics of CASL within higher-order logic. However, this would not be very nice, since theorem proving in a deep encoding is relatively far away from proving in the encoded logic. In contrast, we use a shallow encoding, where proving in the encoding comes close to proving in the encoded logic. The advantage of a deep encoding would be that one can prove meta-properties about the semantics of CASL, but in our view, this does not outweigh the disadvantages. An exceptional case are CASL’s free specifications. One can hardly expect to implement them in a logic-independent way, since they depend on an involved construction in the model categories of the logic. All that one can expect here is to simulate the semantics of free specifications in a particular logic within higher-order logic, along the lines of [23]. Encoding of architectural specifications is beyond the scope of this paper – it will be dealt with elsewhere. As described in the previous section, libraries are an orthogonal matter. However, there is one important incompatibility between CASL and Isabelle at this

102

Till Mossakowski

Fig. 4. The web interface of the HOL-CASL system

point: CASL text files may contain libraries consisting of several specifications, while Isabelle text files always consist of exactly one Isabelle theory. We solve this problem by just splitting a CASL library into small files containing one specification each, and feeding these files into Isabelle. Or course, we also have to maintain the information associating a CASL library with the split files.

9

User Interface

We provide several user interfaces to the Bremen HOL-CASL system. Actually, it has turned out that for the first contact with our tool, the most important user interface is the web-based interface4 , where the user can just type in a specification, and parse it, perform the static analysis and/or conversion to LATEX. Most users want to try out this easy-to-use interface before taking the effort to download the stand-alone version (even if the latter effort is very small). The web-interface has even been used as a front-end in a prototype translation to PVS [2] (although it is much more convenient to use the stand-alone version in this case). 4

You can play around with it: http://www.informatik.uni-bremen.de/cgi-bin/ casl2.cgi.


103

The small stand-alone version of our tool5 provides the full functionality shown in Fig. 2, except the Isabelle theorem proving environment. It has been quite crucial to exclude Isabelle here, since Isabelle is quite large, and users who want to use the tool as a front-end or back-end do not want to download the whole Isabelle system. The stand-alone tool can be called as a Unix command, and the different entry points and phases of analysis and encodings of the tool (cf. Fig. 2) can be selected with optional flags. In particular, it is also possible to select the encoding into FOL/HOL without having to use Isabelle (this is useful when combining our tool with theorem provers for first- or higher-order logic). We also plan to make the different steps of the encoding (see section 6) separately available, so that one can choose to “encode out” just partiality and keep the subsorting (this will be useful, for example, in connection with Maude [6] which supports subsorting). The Unix interface works quite well when using the tool in combination with other tools, although we plan to provide a fully-fledged applications programmer interface (API) in the future. The full stand-alone version of the tool6 also provides the Isabelle theorem prover, and the generic graphical user interface IsaWin [15,14], which has been built on top of Isabelle. We have instantiated IsaWin with our HOL-CASL encoding of CASL into Isabelle/HOL. In Fig. 5, you can see a typical IsaWin window. The icons labelled with (Σ, E) are CASL specifications (more precisely, their encodings in HOL). Note that the theory HOL itself also is available at this level. The icon labelled with a tree is an open proof goal. By double-clicking on it, you can perform proof steps with this goal. This is done by dragging either already proven theorems (those icons marked with A) or simplifier sets (icons marked with {l → r}) onto the goal. The effect is the resolution of the goal with the theorem thrown onto it, or the rewriting of the goal with the chosen simplifier set. After the proof of a goal is finished, it turns into a theorem. You can then use it in the proof of other theorems, or, if it has the form of a rewrite rule, add it to a simplifier set. Actually, some users explicitly told us that they feared to have to install Isabelle to run our tool. However, even the full version including Isabelle and IsaWin is completely stand-alone (apart from the need to install Tcl/Tk, which has already been installed on many sites).

10


We have shown that it is possible to write tools for a complex language with strong semantical bias (though it turns out to be a complex task). We could reduce the amount of work by re-using existing tools as much as possible. Moreover, by using a common tool interchange format, we have created a tool which can be used in connection with other tools as a front end or back end. Cur5 6

Available at http://www.informatik.uni-bremen.de/∼cofi/CASL/parser/ parser.html. Available at http://www.informatik.uni-bremen.de/∼cofi/CASL/.

104

Till Mossakowski

Fig. 5. The HOL-CASL instantiation of the IsaWin system

rently, our tool has been used in connection with two theorem provers (PVS and Isabelle) and one rewriting engine (ELAN). We have followed three guidelines when implementing the HOL-CASL system. The first guideline was to re-use existing tools, rather than create a new tools. In practice, this has turned out to be very hard: Building an interface from CASL to an existing tool is quite a complex task, which not only deals with an input-output-transformation, but also has to take the interactive behaviour and the display of intermediate results into account. Nevertheless, we think that it is worth the effort to re-use existing tools, since these tools have evolved and improved over time, and in a sense we borrow this maturity from other tools, which otherwise would only have been achieved through a long process of testing, use and maintenance. Of course, our bridges


105

to other tools also have to become mature, but since the target of the bridging tools are already mature, the whole effort can start from a higher level. Currently, we have re-used Isabelle/HOL for having a quick prototype of theorem proving environment for CASL, at the price to get a very HOLish CASL. In future work, we will develop derived rules and tactics for CASL (especially for the computation of normal forms w.r.t. the overloading axioms that state coincidence of overloaded functions on sub- and supersorts). With this, we will try to make the encoding to look more CASL-like by eliminating the need to work with HOL rules and instead provide a complete set of rules for CASL. Perhaps in a further step, we will even encode CASL directly in the generic Isabelle meta logic. Anyway, this step would probably have been too complicated in the first place, and working with Isabelle/HOL has the advantage of faster having a prototype. Concerning the guideline of genericity, we have made the experience that the use of generic tools at some points can lead to inefficiencies: we had to replace the generic Isabelle parser by ML-yacc to obtain an efficient parsing. Yet, we have to use the generic parser for parsing user-defined mixfix syntax. Another experience was with the IsaWin system: it has been designed as a generic window-based interface to Isabelle, but when instantiating it to HOL-CASL, several changes to IsaWin were needed to make it actually useful. Nevertheless, the genericity was a great help in comparison to implementation from scratch. Regarding genericity of our own tool, we have made the encoding of structured specifications independent of the underlying logic. One important future point will be to make also the static analysis of CASL structured and architectural specifications truly generic, i.e. also parameterized over a logic (this is possible because the semantics is already parameterized over a logic). This would allow to re-use the tool also for other logics than the logic underlying CASL (for example, higher-order CASL, reactive CASL, temporal logic, or just your own favourite logic). Concerning interoperability, the use of ATerms helped a lot to interconnect our parser and static analysis with several theorem proving and rewriting tools at different other sites. Here, it was essential to use the very easy-to-handle textual ATerm representation to get quick prototypes of such interconnections, although for larger applications, the more complex binary format is needed. Another use of the ATerm format will be the comparison of outputs of different tools for the same purposes that have been developed at different sites. We hope that also tools developed by others will be integrated to work with our tools in the future. Currently, we have ATerm-based formats for parse trees and global static environments. For the integration of different theorem proving and rewriting tools, on would also need ATerm-based formats for proofs, proof states and possibly also transformations. An even better integration can be achieved with the UniForM workbench [12], which also provides library management and access to a generic transformation application system [15,14] that will be instantiated to CASL.

106

Till Mossakowski

Future work will turn our tool into a theorem proving environment that can be used for practical problems. On the way to this goal, we have to implement proof management, dealing with proof obligations, intended consequences and refinement. Moreover, special simplifiers and proof tactics for CASL will have to be developed an tested. A first case study will be the verification of proof obligations and intended consequences for the libraries of CASL basic datatypes [22]. Another direction of research will further exploit the possibility of the generic analysis of CASL-in-the-large. It is possible to extend CASL to a heterogeneous specification language, where one can combine specifications written in several different logics, see [25] for some first ideas. Tool support for such a language would extend the generic analysis of CASL-in-the-large with an analysis of structuring mechanisms for moving specifications between different logics.

Acknowledgements I would like to thank Kolyang for an intensive cooperation lasting for several years. Christoph L¨ uth and Burkhart Wolff patiently helped with all kinds of questions about Isabelle and IsaWin. Pascal Schmidt did the implementation of the conversion from and to ATerms and of the LATEX pretty printer. Markus Roggenbach wrote the first larger specifications in CASL, which were extensively used and tested with the tools. Bernd Krieg-Br¨ uckner provided a good working environment and discussions about the general directions of this work.

References 1. A. Aasa. Precedences in specifications and implementations of programming languages. Theoretical Computer Science, 142(1):3–26, May 1995. 98 2. D. Baillie. Proving theorems about CASL specifications. Talk at the 14th Workshop on Algebraic Development Techniques, Bonas, France, September 1999. 97, 102 3. M. Brand, H. Jong, P. Klint, and P. Olivier. Efficient Annotated Terms. Technical report, CWI, 1999. Accepted by SPE. 97 4. M. Cerioli, A. Haxthausen, B. Krieg-Br¨ uckner, and T. Mossakowski. Permissive subsorted partial logic in Casl. In M. Johnson, editor, Algebraic methodology and software technology: 6th international conference, AMAST 97, volume 1349 of Lecture Notes in Computer Science, pages 91–107. Springer-Verlag, 1997. 95, 98 5. M. Cerioli and J. Meseguer. May I borrow your logic? (transporting logical structures along maps). Theoretical Computer Science, 173:311–347, 1997. 99 6. M. Clavel, F. Dur´ an, S. Eker, P. Lincoln, N. Mart´ı-Oliet, J. Meseguer, and J. F. Quesada. The Maude system. In P. Narendran and M. Rusinowitch, editors, Proceedings of the 10th International Conference on Rewriting Techniques and Applications (RTA-99), pages 240–243, Trento, Italy, July 1999. Springer-Verlag LNCS 1631. System Description. 103


107

7. CoFI. The Common Framework Initiative for algebraic specification and development, electronic archives. Notes and Documents accessible by WWW7 and FTP8 . 107 8. CoFI Language Design Task Group. CASL – The CoFI Algebraic Specification Language – Summary. Documents/CASL/Summary, in [7], Oct. 1998. 93 9. CoFI Semantics Task Group. CASL – The CoFI Algebraic Specification Language – Semantics. Note S-9 (version 0.95), in [7], Mar. 1999. 93 10. CoFI Task Group on Tools. The CoFI-Tools group home page. http://www.loria.fr/∼hkirchne/CoFI/Tools/index.html. 97 11. J. Hopcroft and J. D. Ullman. Introduction to Automata Theory, Language, and Computation. Addison–Wesley, Reading, MA, 1979. 98 12. B. Krieg-Br¨ uckner, J. Peleska, E.-R. Olderog, D. Balzer, and A. Baer. The UniForM Workbench, a universal development environment for formal methods. In FM99: World Congress on Formal Methods, volume 1709 of Lecture Notes in Computer Science, pages 1186–1205. Springer-Verlag, 1999. 105 13. P. G. Larsen. VDM and proof rules for underdetermined functions. Talk at the IFIP WG 1.3 meeting, Bonas, France, September 1999. 94 14. C. L¨ uth, H. Tej, Kolyang, and B. Krieg-Br¨ uckner. TAS and IsaWin: Tools for transformational program developkment and theorem proving. In J.-P. Finance, editor, Fundamental Approaches to Software Engineering FASE’99. Joint European Conferences on Theory and Practice of Software ETAPS’99, number 1577 in LNCS, pages 239–243. Springer Verlag, 1999. 103, 105 15. C. L¨ uth and B. Wolff. Functional design and implementation of graphical user interfaces for theorem provers. Journal of Functional Programming, 9(2):167–189, Mar. 1999. 103, 105 16. J. Meseguer. General logics. In Logic Colloquium 87, pages 275–329. North Holland, 1989. 99 17. T. Mossakowski, Kolyang, and B. Krieg-Br¨ uckner. Static semantic analysis and theorem proving for CASL. In F. Parisi Presicce, editor, Recent trends in algebraic development techniques. Proc. 12th International Workshop, volume 1376 of Lecture Notes in Computer Science, pages 333–348. Springer, 1998. 94, 96, 98, 99 18. P. D. Mosses. CoFI: The Common Framework Initiative for Algebraic Specification and Development. In TAPSOFT ’97: Theory and Practice of Software Development, volume 1214 of LNCS, pages 115–137. Springer-Verlag, 1997. Documents/Tentative/Mosses97TAPSOFT, in [7]. 93 19. P. D. Mosses. Formatting CASL specifications using LATEX. Note C-2, in [7], June 1998. 96 20. L. C. Paulson. Isabelle - A Generic Theorem Prover. Number 828 in LNCS. Springer Verlag, 1994. 99 21. C. Ringeissen. Demonstration of ELAN for rewriting in CASL specifications. Talk at the 14th Workshop on Algebraic Development Techniques, Bonas, France, September 1999. 97 22. M. Roggenbach and T. Mossakowski. Basic datatypes in CASL. Note M-6, in [7], Mar. 1999. 106 23. P. Y. Schobbens. Second-order proof systems for algebraic specification languages. In H. Ehrig and F. Orejas, editors, Recent Trends in Data Type Specification, volume 785 of Lecture Notes in Computer Science, pages 321–336, 1994. 101 7 8

http://www.brics.dk/Projects/CoFI ftp://ftp.brics.dk/Projects/CoFI

108

Till Mossakowski

24. A. Tarlecki. Moving between logical systems. In M. Haveraaen, O. Owe, and O.-J. Dahl, editors, Recent Trends in Data Type Specifications. 11th Workshop on Specification of Abstract Data Types, volume 1130 of Lecture Notes in Computer Science, pages 478–502. Springer Verlag, 1996. 99 25. A. Tarlecki. Towards heterogeneous specifications. In D. Gabbay and M. van Rijke, editors, Frontiers of Combining Systems, 2nd International Workshop. Research Studies Press, 1999. To appear. 106 26. M. van den Brand. CasFix – mapping from the concrete CASL to the abstract syntax in ATerms format. http://adam.wins.uva.nl/∼markvdb/cofi/casl.html, 1998. 97 27. M. G. J. van den Brand and J. Scheerder. Development of parsing tools for CASL using generic language technology. Talk at the 14th Workshop on Algebraic Development Techniques, Bonas, France, September 1999. 97

On the Construction of Live Timed Systems Sébastien Bornot, Gregor G¨ oßler, and Joseph Sifakis Verimag, 2 rue Vignate, 38610 Gières, France Abstract. We present a method that allows to guarantee liveness by construction of a class of timed systems. The method is based on the use of a set of structural properties which can be checked locally at low cost. We provide sufficient conditions for liveness preservation by parallel composition and priority choice operators. The latter allow to restrict a system’s behavior according to a given priority order on its actions. We present several examples illustrating the use of the results, in particular for the construction of live controllers.

1

Introduction

Building systems which satisfy given specifications is a central problem in systems engineering. Standard engineering practice consists in decomposing the system to be designed into a set of cooperating components or processes. A key problem is the coordination of the components so that the global behavior satisfies given specifications. Usually, ad hoc design methodologies are used leading to solutions that must be validated by verification and testing. In some cases, it is possible to solve the coordination problem by synthesizing a controller or supervisor that restricts the behavior of the components [3,1]. Both validation and synthesis techniques have well-known limitations due to their inherent complexity or undecidability, and cannot be applied to complex systems. As an alternative to cope with complexity, compositional description techniques have been studied. However, the results obtained so far for reactive systems are in general difficult to exploit. They boil down either to heuristics of limited application or to general methods formulated as systems of rules with undecidable premises. Timed systems are models of real-time systems consisting of a discrete control structure (automaton) extended with clocks, variables measuring the time elapsed since their initialization. At semantic level, they can be considered as transition systems that can perform either discrete timeless actions or time steps of some real-valued duration. For a timed system to model a real-time system, it is necessary that it is timelock-free that is, in any maximal run time diverges. Another essential property for timed systems modeling real-time applications such as controllers, schedulers, etc. is that any maximal run contains infinitely many actions. We call this property livelock-freedom as it implies deadlock-freedom and excludes indefinite waiting. We call live a timed system which is both timelock-free and livelock-free. We propose a method for building live systems as the composition of live components by using parallel composition and priorities. S. Graf and M. Schwartzbach (Eds.): TACAS/ETAPS 2000, LNCS 1785, pp. 109–126, 2000. c Springer-Verlag Berlin Heidelberg 2000

110

Sébastien Bornot et al.

The method is based on a key idea that motivated several papers on the compositional description of timed systems [6,7,8]. It consists in enforcing the satisfaction of properties by appropriate structural restrictions preserved by composition operations. This leads to consider structural properties, intrinsic properties of the system which can be checked locally at low cost. We define a structural property called structural liveness which implies liveness and can be easily checked on components as the conjunction of three more elementary structural properties. We combine two kinds of constructs to build structurally live systems from structurally live components. – Parallel composition operators defined in [6,7,8]. We provide sufficient structural liveness preservation conditions for and-synchronization. – Priorities allowing to restrict the behavior of a timed system according to a given order relation on its actions. We consider timed systems with priority orders defined in [6,7,8] and show that priority orders preserve structural liveness. This is a basic result used to build live timed systems, as priority orders play a central role in our approach. They are used to achieve coordination in a system by appropriately restricting the behavior of its components. As an illustration of this idea, we show how priority orders can be used to specify mutual exclusion constraints by preserving structural liveness. The use of the results for the design of live real-time controllers is illustrated by several examples. The paper is organized as follows. Section 2 presents the properties of liveness and structural liveness, as well as sufficient conditions for guaranteeing this property. Section 3 presents priority orders, their properties and results about structural liveness preservation when priorities are applied. Section 4 presents compositionality results for systems of communicating processes. Section 5 presents a method for the compositional description of mutual exclusion properties by using priorities.

2 2.1

Timed Systems and Their Properties Background

Let X be a set of real-valued variables called clocks. Clocks will be used as state variables measuring time progress. Their valuations will be denoted by the letter v. true (resp. f alse) denotes the predicate that is true (resp. false) for any valuation v. For any non-negative real t, we represent by v + t the valuation obtained from v by increasing by t the values of all the clocks. Definition 1 (Left- and right-closure). A predicate p is called left-closed if ∀v . ¬p(v) ⇒ ∃ > 0 . ∀ ≤ . ¬p(v + ) It is called right-closed if it satisfies the previous expression where p(v + ) is replaced by p(v − ).

On the Construction of Live Timed Systems

111

Notice that these two definitions correspond to the usual notions if we consider p as a function of time, where v is a clock valuation. Definition 2 (Rising and falling edge). Given a predicate p on clocks X, we define the rising edge of p, noted p↑ by: p↑(v) = p(v) ∧ ∃ > 0 . ∀ ∈ (0, ] . ¬p(v − ) ∨ ¬p(v) ∧ ∃ > 0 . ∀ ∈ (0, ] . p(v + ) The falling edge of p, noted p↓, is defined by the same formula where v − and v + are exchanged. Definition 3 (Modal operators). Given a predicate p on real-valued variables X, we define the modal operator ✸k p (“eventually p within k”) for k ∈ R+ ∪ {∞}. ✸k p (v) if ∃t ∈ R+ 0 ≤ t ≤ k. p(v + t) We write ✸p for ✸∞ p and ✷p for ¬✸¬p. Notice that the operators ✸k are just a notation for existential quantifications over time and should not be confused with temporal logic operators. Expressions with modal or edge operators can be reduced to predicates on X whenever quantification over time can be eliminated e.g., when the operators are applied to linear constraints on X. 2.2

Timed Systems

Definition 4 (Timed systems). A Timed System is: – An untimed labeled transition system (S, →, A) where • S is a finite set of control states • A is a finite vocabulary of actions • →⊆ S × A × S is an untimed transition relation – A finite set X of clocks, real-valued variables defined on the set of non negative reals R+ . The set of the valuations of X, isomorphic to Rn+ for some n, is denoted V . – A labeling function h mapping untimed transitions of → into timed transitions: h(s, a, s ) = (s, (a, g, d, f ), s ), where • g and d are predicates on X called respectively the guard and the deadline of the transition. We require that d ⇒ g. • f : V → V is a jump. According to the above definition, a timed system can be obtained from an untimed one by associating with each action a, a timed action b = (a, g, d, f ). Definition 5 (Semantics of timed systems). A state of a timed system is a pair (s, v), where s ∈ S is a control state and v ∈ V . We associate with a timed system a transition relation →⊆ (S ×V )×(A∪R+ )×(S ×V ). Transitions labeled by elements of A are discrete transitions while transitions labeled by non-negative reals are time steps. Given s ∈ S, if {(s, ai , si )}i∈I is the set of all the untimed transitions issued from s and h(s, ai , si ) = (s, (ai , gi , di , fi ), si ) then:

112

Sébastien Bornot et al. a

– ∀i ∈ I ∀v ∈ R+ . (s, v) →i (si , fi (v)) if gi (v). t – (s, v) → (s, v + t) if ∀t < t . cs (v + t ) where cs = ¬ i∈I di . For the states, we denote by guards and deadlines respectively the predicates i∈I gi and i∈I di . Notice that for time steps we have the following time additivity property. If t +t for some t1 , t2 ∈ R+ and some state (s, v), (s, v) 1→ 2 (s, v + (t1 + t2 )) then t1 t2 (s, v) → (s, v + t1 ) → (s, v + (t1 + t2 )), and conversely. Due to this property any sequence of time steps can be reduced into a time step of cumulated duration. ∞ If from some state (s, v) indefinite waiting is allowed, we write (s, v) → (s, ∞). Timed systems are a variant of TAD [6] with an additional relaxation of usual syntactical restrictions ensuring decidability. The simplest timed system is a single transition labeled with the timed action (a, g, d, f ). The guard g characterizes the set of states from which the timed transition is possible, while the deadline d characterizes the subset of these states where the timed transition is enforced by stopping time progress. The relative position of d within g determines the urgency of the action. For a given g, the corresponding d may take two extreme values: d = g meaning that the action is eager, and d = f alse, meaning that the action is lazy. A particularly interesting case is the one of a delayable action where d = g↓ is the falling edge of a right-closed guard g (cannot be disabled without enforcing the action). The differences between these actions are illustrated in fig. 1.

g τ =

eager

τ =δ

delayable

τ =λ

lazy

Fig. 1. Types for guards It has been shown in [7] that any timed system can be described by a bisimilar system with only eager and lazy timed actions. In practice, we use the notation g , g δ and g λ to denote a guard g of an action that is respectively eager (d = g), delayable (d = g↓) and lazy (d = f alse). The containment of deadlines in guards (d ⇒ g) is necessary for avoiding timelocks as it will be explained later. Example 1. Consider the timed system of fig. 2 representing a process of period T and execution time E. The process has three control states s (sleep), w (wait) and e (execute). The clocks t and x are used to impose the period T > 0 and


113

rl (x = E)τ3 s

aw (t = T )τ1 , t := 0

w

go (t ≤ T − E)τ2 , x := 0

e

Fig. 2. A simple process the execution time E ≤ T , respectively. The guards (t = T ), (t ≤ T − E) and (x = E) specify when discrete transitions can occur. According to the type of urgency for the actions (denoted by τ1 , τ2 , and τ3 in the figure), the waiting times at control states may change. For instance, if all guards are lazy then it is possible for the system to remain stuck forever at one of the states s, w, or e. When all guards are eager, discrete transitions are taken as soon as they are enabled, which means in particular that the action go is always executed when t = 0 (no waiting allowed at w). On the contrary, when go is delayable, this action is possible at any time t, 0 ≤ t ≤ T − E. Finally, notice that the behavior remains unchanged if eager punctual guards such as x = E are considered as delayable. Definition 6 (Initial clock valuations). Let s be a control state of a timed system and {(si , bi , s)}i∈I with bi = (ai , gi , di , fi ) the non-empty set of the ingoing timed transitions. The set of the initial clock valuations at s is defined as the predicate post(bi ) ins = i∈I

where post(bi ) is the most liberal post-condition of the i-th transition defined by post(bi )(v) = ∃v , gi (v ) ∧ v = fi (v ) When I = ∅, we take ins to correspond to the valuation where all the clocks are set to zero. Notice that in most practical cases where guards are linear constraints and jumps are linear functions, the quantifier in the expression of post(bi ) can be eliminated. For the process of fig. 2, ins = (x = E), inw = (t = 0) and ine = (0 ≤ t ≤ T − E) ∧ (x = 0). Definition 7 (Run). A run of a timed system is a maximal sequence of alternating time steps and discrete transitions starting from (s0 , v0 ) such that ins0 (v0 ). t

a

t

t

ai+1

0 1 i (s0 , v0 ) → (s0 , v0 + t0 ) →1 (s1 , v1 ) → . . . (si , vi ) → (si , vi + ti ) → (si+1 , vi+1 ) . . .

Notice that due to time additivity of the transition system, any execution sequence of the model can be represented as a run (where some time steps may be of duration zero).

114

2.3


Structurally Live Timed Systems

In this section, we study three basic structural properties of timed systems. Definition 8 (Timelock-freedom). A timed system is timelock-free if in any ai+1 t0 a ti run (s0 , v0 ) → (s0 , v0 + t0 ) →1 . . . → (si , vi + ti ) → . . ., i ti diverges. Definition 9 (Livelock-freedom). A timed system is livelock-free if in any run some action occurs infinitely often. Definition 10 (Liveness). A timed system is called live if it is both timelockfree and livelock-free. Definition 11 (Structural non-Zenoness). A timed system is structurally non-Zeno if in any circuit of the discrete transition graph at least one clock is reset, and it is tested against some positive lower bound. Structural non-Zenoness implies that there is a positive lower bound to the execution time of any circuit, and is the same as strong non-Zenoness in [16]. The periodic process of fig. 2 is structurally non-Zeno since T > 0. Definition 12 (Local timelock-freedom). A timed system is called locally timelock-free if for any state s, for any timed transition (a, g, d, f ) exiting from s, d↑ ⇒ guards . Notice that timed systems with left-closed deadlines are locally timelockfree, as d↑ ⇒ d ⇒ g. Consequently, the timed system of fig. 2 is timelock-free independently of the type of urgency of the actions. Lemma 1. At any state (s, v) in a locally timelock-free timed system, time can progress or some action is enabled. (Proof omitted.) Lemma 2. Any structurally non-Zeno and locally timelock-free timed system is timelock-free. (Proof omitted.) Definition 13 (Local livelock-freedom). A timed system is called locally livelock-free if for any state s, ins ⇒ ✸deadlines, i.e., from any initial state some transition will be eventually taken. Proposition 1. Any locally timelock-free and locally livelock-free timed system is livelock-free. (Proof omitted.) Definition 14 (Structural liveness). A timed system is structurally live if it is locally timelock-free, locally livelock-free, and structurally non-Zeno. Clearly, structural liveness is a particular case of liveness that can be characterized by means of three properties easy to check. Example 2. The process of fig. 2 is not locally livelock-free if one of the actions is lazy. Furthermore, even when the actions are delayable or eager, the requirement for local livelock-freedom fails for state s, since ins = (x = E), which does not imply ✸(t = T ) = (t ≤ T ). However, if the guard of rl is strengthened to (x = E ∧ t ≤ T ), the behavior is not modified, and the system is locally livelockfree. So, the system is structurally live for τi ∈ {δ, }, i = 1, 2, 3.


3 3.1

115

Timed Systems with Priorities Motivation

In system specification, it is often convenient to consider that some priority is applied when from a state several actions are enabled. This amounts to restricting the guards of the action of lower priority to leave precedence to actions of higher priority. Consider for example, two timed transitions (s, (ai , gi , di , fi ), si ), i = 1, 2 with common source state s. If a1 has lower priority than a2 , then the transition labeled by a1 becomes (s, (a1 , g1 , d1 , f1 ), s1 ) with g1 ⇒ g1 and d1 ⇒ d1 while the other remains unchanged. Commonly, g1 is taken equal to g1 ∧ ¬g2 which means that when a1 and a2 are simultaneously enabled in the system without priorities only a2 is enabled in the prioritized system. However, for timed systems it is possible to define priority relations leaving precedence to an action if it is known that it will be enabled within some finite time. Coming back to the previous example, we can take g1 = g1 ∧ ¬✸k g2 for some finite k, or even g1 = g1 ∧ ¬✸g2 . In the former case a1 gives priority up to a2 if a2 is eventually enabled within k time units. In the latter case, a1 is enabled if a2 is disabled forever. This motivates a notion of priority within a given delay. As an example, consider that g1 = 0 ≤ x ≤ 3 ∨ 5 ≤ x ≤ 8 and g2 = 2 ≤ x ≤ 7 for some clock x. We get the following decreasing values for g1 as the priority delay increases.

g2 g1

g1

a1 ≺0 a2

g1

a1 ≺1 a2

g1

a1 ≺∞ a2 0

1

2

3

4

5

6

7

8

9

Fig. 3. Different priorities for a2 over a1 g1 = g1 ∧ ¬g2 = 0 ≤ x < 2 ∨ 7 < x ≤ 8 (immediate priority) g1 = g1 ∧ ¬✸1 g2 = 0 ≤ x < 1 ∨ 7 < x ≤ 8 (priority within a delay of 1) g1 = g1 ∧ ¬✸g2 = 7 < x ≤ 8 (priority within an unbounded delay). Fig. 3 illustrates the above example. The following definition of priority order has been introduced and studied in [7].

116


Definition 15 (Priority order). Consider the relation ≺⊆ A × (R+ ∪ {∞}) × A. We write a1 ≺k a2 for (a1 , k, a2 ) ∈≺ and suppose that ∀k ∈ R+ ∪ {∞}: – ≺k is a partial order – a1 ≺k a2 implies ∀k < k. a1 ≺k a2 – a1 ≺k a2 ∧ a2 ≺l a3 implies a1 ≺k+l a3 for all l ∈ R+ ∪ {∞} Property: The relation a1 ≺≺ a2 = ∃k a1 ≺k a2 is a partial order relation. Definition 16 (Timed system with priorities). A timed system with priorities is a timed system T S = (S, →, A, X, h) having all its guards and deadlines left- and right-closed, equipped with a priority function pr. The priority function pr associates with each state s ∈ S a priority order pr(s) such that if {(ai , gi , di , fi )}i∈I is the set of the timed actions labeling transitions issued from s, then ✸gi ⇒ ✸di for any ai which is not a minimal element of pr(s). A timed system with priorities (T S, pr) represents the timed system T S = (S, →, A, X, h ) with the same discrete transition structure and such that if h(s1 , a, s2 ) = (s1 , (a, g, d, f ), s2 ) then h (s1 , a, s2 ) = (s1 , (a, g , d , f ), s2 ) where g is defined in the following manner. For a given state s, let ≺ denote the priority order pr(s), and {(ai , gi , di , fi )}i∈I be the set of the timed actions labeling transitions of T S exiting from s. The corresponding set of prioritized timed actions in T S is then {(ai , gi , di , fi }i∈I defined by gi = gi ∧ ¬✸k gj di = di ∧ gi aj ∈I, k∈R+ ∪{∞} ai ≺k aj

This definition simply says that the guard gi of a prioritized action ai is not enabled if there is some action aj such that ai ≺k aj that will become enabled within k time units. The requirement ✸g ⇒ ✸d for non-minimal actions means that they cannot be disabled forever without becoming urgent. It is necessary to avoid overriding of deadlines to preserve local livelock-freedom. In fact, the restriction of guards (and deadlines) of low priority would violate local livelock-freedom if actions of higher priority were lazy. Notice that for typed timed actions, it is sufficient to consider priority orders where non-minimal elements are either eager or delayable actions. We call T S the prioritized timed system corresponding to (T S, pr). We denote by guards and deadlines the restrictions of guards and deadlines in T S . 3.2

Preservation of the Structural Properties

Theorem 1. If T S satisfies one of the structural properties local timelock-freedom, local livelock-freedom, or structural non-Zenoness, then (T S, pr) satisfies the same property. Thus, priority orders preserve structural liveness.


117

Proof. – Local timelock-freedom: priority orders transform a left-closed guard g either into left-closed guards g or into a guard g such that another guard g1 of higher priority is true at the rising edge of g (see definition of timed system with priorities). Thus d↑ ⇒ g ∨g1 . By induction on the priority order it is then possible to show that local timelock-freedom is preserved. – Local livelock-freedom: priority orders do not change the discrete transition structure of timed systems, and restrict guards of timed actions. Consequently, for each state s, the set of transitions entering s does not change, and ins is restricted. If we note ins the set of initial clock values of s in the prioritized system, and as the non prioritized system is locally livelock-free, we have ins ⇒ ins ⇒ ✸deadlines . If a deadline d of an action a is restricted to a deadline d = d, then it is restricted by some transition (a1 , g1 , d1 , f1 ) such that a ≺k a1 , for some k ∈ R+ ∪{∞}. This implies d∧¬d ⇒ ✸k g1 ⇒ ✸g1 . Since a1 is not minimal, ✸g1 = ✸d1 . Thus d ⇒ d ∨ ✸d1 . It follows that ✸deadlines = ✸deadlines . Thus local livelock-freedom is preserved. – Strong non-Zenoness: priority orders do not change the discrete transition structure of timed systems, and do not affect jumps. So any circuit in the prioritized system is a circuit in the initial one, and the clock resets are the same. Moreover, guards are restricted by priority orders, so a lower bound in a guard may only increase. Consequently, if the non prioritized system is structurally non-Zeno, then the prioritized one is structurally non-Zeno, too. It is often desirable to restrict a timed system T S with respect to several priority functions pri . At this end, we define a partial operation on priority orders. Given ≺1 , ≺2 priority orders on A, we represent by ≺1 ⊕ ≺2 the least priority order, if it exists, that contains both ≺1 and ≺2 , i.e., – ≺1 ∪ ≺2 ⊆≺1 ⊕ ≺2 – if (a1 , k1 , a2 ), (a2 , k2 , a3 ) ∈≺1 ⊕ ≺2 , then (a1 , k1 + k2 , a3 ) ∈≺1 ⊕ ≺2 . The partially defined operator ⊕ is associative and commutative. We extend ⊕ on priority functions pri : ∀s ∈ S.(pr1 ⊕ pr2 )(s) = pr1 (s) ⊕ pr2 (s). In order to simplify notations, we extend priority orders to sets of actions: A1 ≺k A2 :⇔ ∀a1 ∈ A1 ∀a2 ∈ A2 .a1 ≺k a2 . In the rest of the paper, we show how to build live systems from live components.

4

Systems of Communicating Processes

We use the following general framework for the composition of timed systems studied in [6,7] and based on the use of an associative and commutative parallel composition operator . Consider timed systems of the form T Si = (Si , Ai , →i , Xi , hi ). For sake of simplicity, we assume that they have disjoint sets of control states Si , disjoint sets

118


of actions Ai , and disjoint sets of clocks Xi . Furthermore, we consider an action vocabulary A, Ai ⊆ A, with an operator | such that (A, |) is a commutative semigroup with a distinguished absorbing element ⊥. The action a1 |a2 represents the action resulting from the synchronization of a1 and a2 (if a1 |a2 = ⊥). Definition 17 (Parallel composition). The parallel composition (T S1 , pr1 ) (T S2 , prs ) of two timed systems with priorities (T S1 , pr1 ) and (T S2 , pr2 ) is the timed system with priorities (T S, pr) defined by a

– T S = (S1 × S2 , A, →, X1 ∪ X2 , h) where if si →i i si and hi (si , ai , si ) = (si , bi , si ) with bi = (ai , gi , di , fi ), i = 1, 2, then a

a1 |a2

a

• (s1 , s2 ) →1 (s1 , s2 ), (s1 , s2 ) →2 (s1 , s2 ), and (s1 , s2 ) → (s1 , s2 ) if a1 |a2 = ⊥. That is, the transitions of → are obtained by interleaving or by synchronization. • If a1 |a2 = ⊥, then ✸gi = ✸di , i = 1, 2. • h((s1 , s2 ), a1 , (s1 , s2 )) = ((s1 , s2 ), b1 , (s1 , s2 )) h((s1 , s2 ), a2 , (s1 , s2 )) = ((s1 , s2 ), b2 , (s1 , s2 )) h((s1 , s2 ), a1 |a2 , (s1 , s2 )) = ((s1 , s2 ), b1 |b2 , (s1 , s2 )) where b1 |b2 is an extension of | on timed actions, defined later. – pr = pr1 ⊕ pr2 ⊕ pr12 , where ∀(s1 , s2 ) ∈ S1 × S2 . a a pr12 (s1 , s2 ) = {{a1 , a2 } ≺∞ a1 |a2 | a1 |a2 = ⊥ ∧ ∃s1 , s2 . s1 →1 s1 ∧ s2 →2 s2 } if pr1 ⊕ pr2 ⊕ pr12 is defined. The composition principle is illustrated in fig. 4. Priorities are used to achieve

s1

(s1 , s2 )

s2 b1

b1

b2

≺∞

∞

b2

b1 |b2 s1

s2

(s1 , s2 )

(s1 , s2 )

(s1 , s2 )

Fig. 4. Composition principle maximal progress, that is, interleaving transitions will be taken only when synchronization is not possible. In [6,7] a general method is provided to extend the operator | on timed actions, preserving associativity and commutativity. We consider here a particular case of timed action synchronization, called and-synchronization, which is defined as follows: For bi = (ai , gi , di , fi ), i = 1, 2 if a1 |a2 = ⊥, then b1 |b2 = (a1 |a2 , g1 ∧ g2 , (g1 ∧ g2 ) ∧ (d1 ∨ d2 ), f1 ∪ f2 ). This simply means that synchronization takes place only when both actions are enabled. The synchronization action becomes urgent


119

whenever it is enabled, and one of the synchronizing actions becomes urgent. Finally, f1 ∪ f2 denotes the composition of jumps (for disjoint state spaces of the components). Notice that is an associative and commutative partial operation on timed systems with priorities. We trivially consider a timed system T S as a timed system with priorities (T S, pr∅ ), where pr∅ is the priority function associating the empty priority order with any state. Theorem 2. If T S1 and T S2 are structurally live, then T S1 T S2 is structurally live. Proof. If (T S, pr) = T S1 T S2 , then it is sufficient to consider T S by application of Theorem 1, as for synchronizing actions (which are not minimal in pr(s) for all s), ✸gi = ✸di . We show that if T S1 and T S2 are structurally live, then T S is structurally live. – Structural non-Zenoness: since each transition (interleaving or synchronization) corresponds to a transition in T S1 or T S2 or both, each circuit in the product contains a set of transitions forming a circuit in T S1 or T S2 . If T S1 and T S2 are structurally non-Zeno, then in all these circuits some clock is reset and tested against a positive lower bound. Then this is the case for all the circuits of T S too. The bounds of a synchronization action may increase, but can not decrease. – Local timelock-freedom: conjunction and disjunction preserve closure of guards and deadlines, so guards and deadlines of synchronizations are closed as well as those of interleaving actions. This guarantees local time-lock freedom. – Local livelock-freedom: since interleaving transitions are transitions of the components, and synchronization guards are conjunctions of guards of the components, if T S1 and T S2 are locally livelock-free we have in(s1 ,s2 ) ⇒ ins1 ∨ ins2 ⇒ ✸deadlines1 ∨ ✸deadlines2 ⇒ ✸deadline(s1 ,s2 ) Thus, the product system is locally livelock-free. Example 3. Consider two structurally live processes P1 and P2 with execution times Ei and periods Ti , i = 1, 2, running in parallel, as shown in fig. 5. Each process Pi can procrastinate the goi action, which models the start of its execution, as long as enough time remains for execution before the end of the period. In order to let the processes exchange data, however, one wishes to coordinate them by a common go1 |go2 action whenever this is possible without violating the timing constraints of any of P1 and P2 . This is done by synchronizing the go1 and go2 actions. Maximal progress is ensured in (w1 , w2 ) by the priorities go1 ≺∞ go1 |go2 and go2 ≺∞ go1 |go2 , and guarantees that the two processes will synchronize if they manage to be in (w1 , w2 ) at the same time. The resulting

120


aw1 (t1 = T1 )δ t1 := 0

w1 go1 (t1 ≤ T1 − E1 )δ x1 := 0

s1 rl1 (x1 = E1 ∧ t1 ≤ T1 )δ

e1

w2

aw2 (t2 = T2 )δ t2 := 0

go2 (t2 ≤ T2 − E2 )δ x2 := 0

s2

e2

rl2 (x2 = E2 ∧ t2 ≤ T2 )δ

Fig. 5. Two processes with flexible synchronization timed actions in the product system with priorities have typed guards g1 , g2 , and g12 , respectively, for go1 , go2 , and go1 |go2 : g1 = ((x1 ≤ T1 − E1 ) ∧ ¬✸(x2 ≤ T2 − E2 ))δ = ((x1 ≤ T1 − E1 ) ∧ (x2 > T2 − E2 ))δ g2 = ((x2 ≤ T2 − E2 ) ∧ ¬✸(x1 ≤ T1 − E1 ))δ = ((x2 ≤ T2 − E2 ) ∧ (x1 > T1 − E1 ))δ g12 = ((x1 ≤ T1 − E1 ) ∧ (x2 ≤ T2 − E2 ))δ .

The product system is structurally live. An important property in the previous example is individual livelock-freedom of the components in the product system. Liveness of the product does not imply that in any run, an action of some component occurs infinitely often. This remark motivates the following definition and theorem. Definition 18 (Individual livelock-freedom). A component (T Si , pri ) is livelock-free in a timed system (T S, pr) = (T S1 , pr1 )(T S2 , pr2 ) if in each run of (T S, pr), some action of (T Si , pri ) occurs infinitely often. Theorem 3. If both (T S1 , pr1 ) and (T S2 , pr2 ) are structurally live and each synchronizing guard g is bounded (that is, ✸✷¬g), then both T S1 and T S2 are livelock-free in (T S1 , pr1 )(T S2 , pr2 ). (Proof omitted.) Example 4. Both processes of Example 3 are livelock-free in the product system. Remark 1. Notice that for liveness preservation, the systematic use of “escape” actions (aborted communications) in the product system is instrumental. Our parallel composition operator allows a process to proceed unsynchronized on any action for which the communication will not be ready in its current state sometime in the future. This is different from usual “strong” parallel composition where synchronization is enforced by the use of restriction operators as in CCS [15] or by allowing interleaving only for internal (non communicating) actions as in CSP [12]. Such operators enforce synchronization at the risk of deadlock, particularly in the case of timed systems.


5

121

Mutual Exclusion

Consider a timed system initially composed of a set of interacting components. The goal is to restrict the behavior of the components by using priorities so that the global behavior satisfies a given mutual exclusion constraint. We study a method to obtain a structurally live system satisfying mutual exclusion from structurally live components. The following notion of persistence will be central in this section. Definition 19 (Persistence). A control state s is called persistent if ins ⇒ ✸✷guards . This property means that at state s, maybe after some waiting, it is always possible to execute an action. It is instrumental for avoiding deadlocks when guards are restricted by using priorities. Consider a timed system (T S, pr) = T S1 . . . T Sn , where T Si = (Si , Ai , →i , Xi , hi ), and T S = (S, A, →, X, h), as in section 4. We suppose that a mutual exclusion constraint is specified as a set M ⊆ i Si containing pairwise mutually exclusive states. We define two predicates on the product space S: – badM (s1 , . . . , sn ) = ∃i, j, i = j.si ∈ M ∧ sj ∈ M – criticalM (s1 , . . . , sn ) = ¬badM (s1 , . . . , sm ) ∧ a ∃a ∈ A, (s1 , . . . , sn ) ∈ S . (s1 , . . . , sn ) → (s1 , . . . , sn ) ∧ badM (s1 , . . . , sn ). badM characterizes all the states violating the mutual exclusion constraint, whereas criticalM characterizes all the legal states from which mutual exclusion can be violated by executing one transition. For a given M ⊆ i Si we define •M and M ◦ as the set of actions entering M and the set of actions originating in M : a

•M = {a | ∃i ∃s, s ∈ Si , s ∈ M ∧ s ∈ M ∧ s →i s } a

M ◦ = {a | ∃i ∃s, s ∈ Si , s ∈ M ∧ s →i s } The set of waiting states of component Si with respect to M is the set of states from which some action entering M is issued: {s ∈ Si − M |∃a ∈ Ai , s ∈ a Si ∩ M s.t. s →i s }. Theorem 4 (Mutual exclusion). Let T S1 . . . , T Sn be a set of structurally live timed systems with persistent waiting states w.r.t. a mutual exclusion constraint M ⊆ i Si , and (T S, pr) = T S1 . . . T Sn be the parallel composition of the components with ∀a1 ∈ •M ∀a2 ∈ A.a1 |a2 = ⊥. Then, the timed system with priorities (T S, pr ⊕ prM ), where •M ≺∞ M ◦ if criticalM (s) ∀s ∈ S . prM (s) = (1) ∅ otherwise is structurally live, and satisfies the mutual exclusion constraint.

122


Proof (sketch). – Structural liveness: Let us first show that (pr ⊕ prM )(s) is a partial order for all s ∈ S.¬badM (s). Suppose that a1 ≺∞ a2 ∈ pr (i.e., a2 is a synchronizing action), and that a2 ≺∞ a1 ∈ prM . This is not possible, since synchronizing actions are maximal in prM . Hence, pr⊕prM is a priority function. Structural liveness follows from Theorems 2 and 1. – Mutual exclusion: No synchronization action can lead (T S, pr ⊕ prM ) from a safe state s ∈ S.¬(criticalM (s) ∨ badM (s)) into a badM state violating mutual exclusion. Let s = (s1 , . . . , sn ) be a state of T S with criticalM (s), such that there a exist sk , si , sk ∈ M and ∃a ∈ Ai .si → si with si ∈ M . Thus, a is an action leading (T S, pr) into a bad state. Since a ∈ •M , we have ai ≺∞ {sk }◦ ⊆ prM (s). Let us show that from any initial clock valuation of sk , some action issued from sk will eventually be enabled, which means that a is disabled due to priority choice semantics. From the livelock-freedom assumption about T Sk , insk ⇒ ✸deadlinesk , one can deduce that in the product (T S, pr), for any state satisfying insk there exists an action in Ask = {sk } ◦ ∪{a1 |a2 | a1 ∈ {sk } ◦ ∧a2 ∈ A ∧ a1 |a2 = ⊥} with deadline d such that ✸d. This property remains true as long as T Sk is in state sk in (T S, pr). The same argument can be applied for sk in (T S, pr ⊕ prM ), as the actions of Ask are not restricted by the priority function prM . Intuitively, equation (1) says that from critical states, M must be left before a new process can enter. The persistence of the waiting states makes sure that no process becomes deadlocked while waiting to enter M . Remark 2. Notice that the above construction minimally restricts the untimed transition structure in the following manner: if from a state s = (s1 , . . . , sn ), a a ¬badM (s) there exist transitions s →1 s and s →2 s with a1 ∈ •M and a2 ∈ M ◦, then criticalM (s), and badM (s ). Definition 20 (Individual deadlock-freedom). A component T Si of a timed system (T S, pr) = T S1 . . . T Sn is deadlock-free in T S if for each run of T S, some action of T Si is enabled infinitely often. Theorem 5. Let T S1 . . . , T Sn be a set of structurally live timed systems, and M ⊆ i Si a mutual exclusion constraint, as in Theorem 4. If for each T Si , any run of T Si contains infinitely many occurrences of states in Si − M , the actions in M ◦ do not synchronize, and T Si is livelock-free in (T S, pr) = T S1 . . . T Sn, then all components are deadlock-free in (T S, pr ⊕ prM ). (Proof omitted.) Remark 3. Let T Si be a structurally live timed system, and M a mutual exclusion constraint. A sufficient structural condition for the runs of T Si to contain infinitely many occurrences of states in Si − M is that the untimed transition graph of T Si has no cycles in M .


123

Theorem 6. Let {Mi }i∈I be a set of mutual exclusion constraints on a structurally live timed system (T S, pr). If prMi are the priority functions ensuring mutual exclusion according to Theorem 4, and π = pr ⊕ i∈I prMi is a priority function, then (T S, π) is structurally live and respects all mutual exclusion constraints Mi . (Proof omitted.) Example 5. Consider two processes of periods T1 , T2 and execution times E1 , E2 as in fig. 6. Each one of the processes is structurally live and remains livelock-

aw1 (t1 ≥ T1 ) t1 := 0

w1 go1 (t1 ≤ T1 − E1 )δ ∪ (t1 ≥ T1 − E1 ) x1 := 0 go2 (t2 ≤ T2 − E2 )δ ∪ (t2 ≥ T2 − E2 ) x2 := 0

s1 rl1 (x1 = E1 )δ

w2

e1

#

aw2 (t2 ≥ T2 ) t2 := 0 s2

e2

rl2 (x2 = E2 )δ

Fig. 6. Two processes with mutual exclusion between e1 and e2 free in the interleaving product of the two processes, which is structurally live. We apply the mutual exclusion constraint M = {e1 , e2 } on the interleaving product and obtain •M ≺∞ M ◦, i.e., {go1 , go2 } ≺∞ {rl1 , rl2 } for the critical states (w1 , e2 ), (e1 , w2 ). This practically means that release-actions rl have higher priority than begin-actions go. According to Theorem 4, the product system with priorities is structurally live, and both processes are deadlock-free in it, due to the persistent waiting states w1 and w2 . Notice that in order to compute (T S1 . . . T Sn , pr), it is not necessary to compute explicitly the product T1 . . . Tn . Priority choice can be applied “on the fly” to states of the product. The construction of Theorem 4 can be generalized for mutual exclusion constraints of the type m-out-of-n for m < n, where criticalM (s) (badM (s)) denotes the set of control states where exactly m (more than m) components are in M . Example 6 (Resource allocation). Consider the well-known example of fig. 7, where two interleaving processes P1 and P2 use two shared resources R1 and R2 . P1 allocates resource R1 , then R2 , while it still holds R1 , before releasing both resources. P2 tries to allocate the resources in the inverse order. An action pij means that process Pi allocates resource Rj , and a vi -action means that process Pi frees both resources. Mutual exclusion over R1 is modeled by the set M1 = {s2 , s3 , s7 }, and mutual exclusion over R2 by M2 = {s3 , s6 , s7 }, as indicated by arrows in the figure. Critical states are those characterized by criticalM1 = (s2 ∨ s3 ) ∧ s6 ∨ s1 ∧ s7 , and criticalM2 = s3 ∧ s5 ∨ s2 ∧ (s6 ∨ s7 ) (where the name of a component state is used as a proposition which is true if

124


s5

s1 p11 (x ≥ 3) s2 p12 true x := 0 s3

s6 # # #

p21 true y := 0

s7

s4

v2 (y = 2)δ r2 s8 (y ≤ 3)δ

P1

P2

v1 (x = 1)δ r1 (x ≤ 2)δ

p22 (y ≥ 4)

Fig. 7. Crossover resource allocations the component system is in that state). Mutual exclusion on Mi is guaranteed for (T S, prMi ), if T S is the interleaving product of P1 and P2 . The priority functions prMi (i = 1, 2) are defined by prMi (s) = •Mi ≺∞ Mi ◦ for criticalMi (s), ∅ otherwise. We have ∀s ∈ S: {p11 , p21 } ≺∞ {p12 , v1 , v2 } if criticalM1 (s) prM1 (s) = ∅ otherwise {p12 , p22 } ≺∞ {p21 , v1 , v2 } if criticalM2 (s) prM2 (s) = ∅ otherwise Both mutual exclusion constraints M1 and M2 are respected by (T S, prM1 ⊕ prM2 ), if prM1 ⊕prM2 is defined. However, in state (s2 , s6 ) — P1 has allocated R1 and waits for R2 , whereas P2 has allocated R2 and waits for R1 —, one can see that priorities form a circuit with vertices p12 and p21 . This flaw in the specification (which means that the specification is intrinsically not deadlock-free) can be corrected by declaring states {s2 , s6 } in mutual exclusion. The resulting mutual exclusion constraint is M = {s2 , s3 , s6 , s7 }, which means that the product state (s2 , s6 ) is made unreachable. In practice, this means that the sequence consisting of the two resource allocations is atomic, and the obtained system is live. Notice that each process eventually frees all resources, and the waiting states s1 and s5 are persistent, so that both processes remain individually deadlock-free after composition in this improved specification.

6

Discussion

We have presented a method for the construction of live timed systems based on the preservation of a set of structural properties by appropriately chosen composition operators. Structural properties verification can be done locally and does not require exploration of the global system’s dynamic behavior. The set of initial states is also structurally determined.


125

An important question to be further investigated is applicability of the method. It concerns the expressivity of the class of structurally live systems as well as the possibility to apply in practice the liveness preservation theorems. We believe that the two properties implying timelock-freedom correspond to completely natural common sense requirements of sanity. Structural nonZenoness is a kind of “well-guardedness” property that is satisfied in practice. Local livelock-freedom is also a basic property to avoid problems in the interaction between time progress and discrete state changes. The main difficulty in the application of our method, is the satisfaction of the local livelock-freedom property. It may happen that the initial clock valuation at some state is too weak. In that case, the guards of the transitions entering this state must be strengthened in an appropriate manner (as in Example 2) and this is left to the user’s ingenuity. The proposed parallel composition operator can be enhanced by selective elimination of escape actions thanks to the use of additional priorities. If all non communicating actions are given infinitely higher priority than communicating actions then stronger interaction can be achieved and for this parallel composition operator Theorem 2 remains true. However, Theorem 3 does not hold and it is not easy to find conditions for individual liveness preservation. The presented method uses a framework for the compositional description of timed systems [6,7,8]. This framework is based on “flexible” composition operations in the sense that composition allows only interaction resulting in a global behavior that preserves liveness. Priorities are essential for restricting appropriately the behavior of the cooperating components depending on their abilities to synchronize from their respective states. This contrasts with usual composition operations which are “constraint oriented” and consider parallel composition essentially as the intersection of “observable” behaviors. Such operations enforce action synchronization and respect components urgency at the risk of livelock or timelock. In the presence of timelock or livelock, the behavior of the components must be changed to get correct specifications. We prefer flexible composition, in spite of its deficiencies, because it is more appropriate for the “correct by construction” approach. To our knowledge, this approach has not been very much explored so far. [16] defines sufficient static conditions for deadlock- and timelock-freedom for the synchronized product of timed automata. Also, there exists some work about reactive systems such as [9,13]. Concerning the use of priorities, there exist many papers introducing priorities to process algebras, mainly for the untimed case [5,10,14]. Our notion of timed systems with priorities is closer to the work of [14] on the timed process algebra ACSR. However, this work does not tackle problems of property preservation. This work is part of a more general project which aims at developing techniques and tools for modeling and analyzing real-time systems. We implemented priority choice, parallel composition as well as verification of structural properties, in a prototype tool, which we are currently using for the description of scheduling algorithms.

126


References 1. K. Altisen, G. G¨ oßler, A. Pnueli, J. Sifakis, S. Tripakis, and S. Yovine. A Framework for Scheduler Synthesis. In IEEE RTSS’99 proceedings, 1999. 109 2. R. Alur and D.L. Dill. A theory of timed automata. TCS, 126, pp. 183-235, 1994. 3. E. Asarin, O. Maler, and A. Pnueli. Symbolic Controller Synthesis for Discrete and Timed Systems. Hybrid Systems II, LNCS 999, Springer-Verlag, 1995. 109 4. P. C. Attie. Synthesis of Large Concurrent Programs via Pairwise Composition. In CONCUR’99. 5. J. C. M. Baeten, J. A. Bergstra, and J. W. Klop. Syntax and defining equations for an interrupt mechanism in process algebra. Fundamenta Informaticae IX (2), pp. 127-168, 1986. 125 6. S. Bornot and J. Sifakis. On the composition of hybrid systems. In International Workshop “Hybrid Systems: Computation and Control”, LNCS, pp. 49–63. Springer-Verlag, April 1998. 110, 112, 117, 118, 125 7. S. Bornot and J. Sifakis. An Algebraic Framework for Urgency. In Calculational System Design, NATO Science Series, Computer and Systems Science 173, Marktoberdorf, July 1998. 110, 112, 115, 117, 118, 125 8. S. Bornot, J. Sifakis, and S. Tripakis. Modeling urgency in timed systems. In COMPOS’97, Malente, Germany. LNCS 1536, Springer-Verlag, 1998. 110, 125 9. L. P. Carloni, K. L. McMillan, and A. L. Sangiovanni-Vincentelli. Latency Insensitive Protocols. In CAV’99, Trento, Italy. LNCS 1633, Springer-Verlag, 1999. 125 10. R. Cleaveland, G. L¨ uttgen, V. Natarajan, and S. Sims. Priorities for Modeling and Verifying Distributed Systems. In TACAS’96, LNCS 1055, pp. 278-297. 125 11. T. A. Henzinger, X. Nicollin, J. Sifakis, and S. Yovine. Symbolic model checking for real-time systems. Proc. 7th Symp. on Logics in Computer Science (LICS’92) and Information and Computation 111(2):193–244, 1994. 12. C. A. R. Hoare. Communicating Sequential Processes. Prentice Hall, 1985. 120 13. M. V. Iordache, J. O. Moody, and P. J. Antsaklis. A Method for Deadlock Prevention in Discrete Event Systems Using Petri Nets. Technical Report, University of Notre Dame, July 1999. 125 14. H. Kwak, I. Lee, A. Philippou, J. Choi, and O. Sokolsky. Symbolic schedulability analysis of real-time systems. In IEEE RTSS’98, Madrid, Spain, December 1998. 125 15. R. Milner. Communication and Concurrency. Prentice Hall, 1989. 120 16. S. Tripakis. Verifying Progress in Timed Systems. In ARTS’99, Bamberg, Germany, 1999 (to appear in LNCS series). 114, 125

On Memory-Block Traversal Problems in Model-Checking Timed Systems Fredrik Larsson1 , Paul Pettersson2, and Wang Yi1 1

2

Department of Computer Systems, Uppsala University, Sweden {fredrikl,yi}@docs.uu.se BRICS , Department of Computer Science, Aalborg University, Denmark [email protected]

Abstract. A major problem in model-checking timed systems is the huge memory requirement. In this paper, we study the memory-block traversal problems of using standard operating systems in exploring the state-space of timed automata. We report a case study which demonstrates that deallocating memory blocks (i.e. memory-block traversal) using standard memory management routines is extremely time-consuming. The phenomenon is demonstrated in a number of experiments by installing the Uppaal tool on Windows95, SunOS 5 and Linux. It seems that the problem should be solved by implementing a memory manager for the model-checker, which is a troublesome task as it is involved in the underlining hardware and operating system. We present an alternative technique that allows the model-checker to control the memoryblock traversal strategies of the operating systems without implementing an independent memory manager. The technique is implemented in the Uppaal model-checker. Our experiments demonstrate that it results in significant improvement on the performance of Uppaal. For example, it reduces the memory deallocation time in checking a start-up synchronisation protocol on Linux from 7 days to about 1 hour. We show that the technique can also be applied in speeding up re-traversals of explored state-space.

1

Introduction

During the past few years, a number of verification tools have been developed for real-time systems in the framework of timed automata (e.g. Kronos and Uppaal [HH95,DOTY95,LPY97,BLL+ 98]). One of the major problems in applying these tools to industrial-size systems is the huge memory-usage (e.g. [BGK+ 96]) for the exploration of the state-space of a network (or product) of timed automata. The main reason is that the model-checkers must store a large number of symbolic states each of which contains information not only on the control structure of the automata but also the clock values specified by clock constraints. To reduce memory usage, the model-checker must throw away parts of

Basic Research In Computer Science, Centre of the Danish National Research Foundation.


128

Fredrik Larsson et al.

the state-space explored (resulting in memory deallocation), that are not needed for further analysis or re-traverse parts of the state-space explored and stored in (virtual) memory blocks to check a new property. In both cases, the underling operating system must traverse the memory blocks storing the state-space explored. Unfortunately, using the standard memory management service for memoryblock traversals e.g. memory deallocation is surprisingly time-consuming in particular when swapping is involved during state-space exploration. A problem we discovered in a very recent case study when Uppaal was applied to check two correctness properties of the start-up algorithm for a time division multiple access protocol [LP97]. The first property was verified using 5 hours of CPU time and 335MB of memory1 but the memory deallocation process, after verifying the first property, did not terminate until 7 days! The phenomenon described above is caused by the so-called thrashing, which occurs occasionally in common-purpose operating systems, but much more often in the context of state-space exploration due to the large memory consumption. Unfortunately, this is a phenomenon not only occurring on Linux, but most of the existing operating systems. The fact has been demonstrated by our experiments on Uppaal installed on Linux, Windows 95 and SunOS 5. Furthermore, we notice that as Uppaal is based on the so-called symbolic reachability analysis which is the basis for several other model-checkers e.g. Kronos and HyTech, this should be a common problem for verification tools in the domain of real-time systems. More intuitively, the problem can be described as follows: When throwing away parts of the state-space, the states are deallocated one by one. Note that the size of a state could be a number of bytes. To deallocate the amount of memory for a particular state, the memory page containing that state must be in the main memory. When swapping is involved, this means that the particular page must be loaded from disc. If the next state we want to throw away is in another page, and memory is almost full, the newly loaded page must be swapped out, even if it needs to be swapped in later when another state shall be removed. If the deallocation order is independent of how the allocated states are mapped to memory, unnecessary swapping will occur. Therefore, it is crucial to store information on the allocation order of memory blocks, but this will introduce extra overhead for the model-checker. It is not obvious how much information that should be collected during the verification process and used later for deallocating. The more information collected, the more overhead in the verification but the better the deallocation performance obtained. We need to find the best trade-off. As our first experiment, we have simulated the allocation order of memory blocks in Uppaal and experimented with three different deallocation orders. The first 1

The experiment was performed on a 200 MHz Pentium Pro equipped with 256MB of primary memory running Red Hat Linux 5.

On Memory-Block Traversal Problems in Model-Checking Timed Systems

129

simply traverses the allocated structure without taking into account how blocks were allocated. This was the one used in Uppaal when the start-up protocol was verified. The second strategy deallocates memory blocks in the same order as they were allocated. The third one deallocates them in the reverse allocation order. According to our experiments, the last strategy is clearly the best choice, which has been implemented in Uppaal. It results in significant performance improvements on Uppaal. For example, it reduces the memory deallocation time on Linux from 7 days to about 1 hour for the start-up protocol. The technique is also implemented to speed up re-traversing of the explored state-space to check new properties when the model-checker is used in an interactive manner. Our experiments demonstrate similar performance improvement. The rest of the paper is organised as follows: In Section 2, we briefly introduce the notion of timed automata and symbolic reachability analysis for networks of timed automata. In Section 3, we describe and study the memory deallocation problem in more details. Several experiments are presented to illustrate that it is a common phenomenon for all the common-purpose operation systems. In Section 4, we present a solution to the problem and experimental results showing that our solution does result in a significant performance improvement for the Uppaal tool. Section 5 concludes the paper by summarising our contributions and future work.

2 2.1

Preliminaries Timed Automata

Timed automata was first introduced in [AD90] and has since then established itself as a standard model for real–time systems. For the reader not familiar with the notion of timed automata we give a short informal description. A timed automaton is a standard finite–state automaton extended with a finite collection C of real–valued clocks ranged over by x, y etc. A clock constraint is a conjunction of atomic constraints of the form: x ∼ n or x − y ∼ n for x, y ∈ C, ∼∈ {≤, CS ∧ . . . ∧ ν(x, m) > CS .   m The last segment contains identifiers of those processes whose local clock readings are greater than CS . The processes with identifiers in a segment other than the last one all have the same fractional part in their clock readings which are no greater than CS . Definition 3. normalized runs Given a run ρ = (ν0 , t0 )(ν1 , t1 ) . . . (νk , tk ) . . . of a real-time software system S = A, m, I, a normalized run ρ¯ of ρ is a mapping from N × R such that for every k ∈ N and 0 ≤ t ≤ tk , ρ¯(k, t) is a normalized state of νk + t. After each transition or clock readings advancement, a normalized state can be changed to an unnormalized one and there can be more than one identifier permutation whose application can maintain the normality of states. We propose the following permutation rules which can simplify our tool implementation. 1. When process i resets its local clock with a transition, we have to − change the identifier of process i to 1 (with global and local variables updated according to the transitions.); and

Efficient Data Structure for Fully Symbolic Verification

163

− for every 1 ≤ j < i, change the identifier of process j to j + 1; and − for every i < k ≤ m, keep the identifier of process k unchanged in the destination state to make it normalized. The permutation can be viewed as an identifier movement from i to 1 with displacement 1 − i. 2. When there is no integer clock readings ≤ CS in the source state and some clocks will advance from noninteger readings < CS to integer readings, we first have to identify the segment of identifiers of those processes with such clocks. This is the segment right preceding the last segment which contains identifiers of processes with local clock readings > CS . Suppose, we find out x[j], . . . , x[k] are such clocks. Then in the destination state, − for all j ≤ i ≤ k, the identifier of process i is changed to i − j + 1; and − for all 1 ≤ i < j, the identifier of process i is changed to i + k − j + 1; and − for all k < i ≤ m, the identifier of process i is unchanged to make it normalized. The permutation can be viewed as an identifier segment movement from [j, k] to [1, k − j + 1] with displacement 1 − j. 3. When some clocks advance from integer to noninteger readings. we first have to detect if some of those clocks advance their readings from CS to beyond CS . Suppose, we find out that x[j], . . . , x[k] are such clocks. Then in the destination state, − for all j ≤ i ≤ k, the identifier of process i is changed to i + m − k; and − for all 1 ≤ i < j, the identifier of process i is unchanged; and − for all k < i ≤ m, the identifier of process i is changed to i + j − k − 1 to make it normalized. The permutation can be viewed as an identifier segment movement from [j, k] to [j + m − k, m] with displacement m − k. 4. In all other cases, the identifiers of all processes stay unchanged to satisfy normality. However, there is one thing unclear in the above-mention permutation scheme. That is, in the third item, how do we know that those processes with clock readings = CS will appear with consecutive process identifiers ? That is the good thing about this permutation scheme and can be established by the following lemma. Lemma 1. In the permutation scheme presented in the above, inside all segments of identifiers of processes whose clock readings are ≤ CS and share the same fractional parts, the process identifiers are arranged according to monotonically increasing order of the local clock readings. Proof : True because every time when we reset a local clock, we change the identifier of the transiting process to 1. Thus the later a process resets its clock, the earlier its identifier appears in a segment.

Definition 4. Symmetric global state predicate Given a global state predicate η and a permutation θ of process identifier 1 through m, ηθ is a new global state predicate obtained from η by renaming process identifiers according to θ. A global state predicate η for m processes is symmetric iff for any permutation

164

Farn Wang

Fig. 2. Data structure implementation of a node in RED θ of 1 through m, η equals to ηθ according to commutation laws of Boolean algebra. We want to establish the soundness of our RED technology with the following lemma. Lemma 2. : Given a state ν of a real-time software system S = A, m, I and a symmetric global state predicate η, for any normalized image ν of ν, ν |= η iff ν |= η. Proof : Suppose the process identifier permutation that changes ν to ν is θ. Then ν |= η has the same truth value as ν |= (ηθ). But ηθ is equal to η according to commutation laws of Boolean algebra. Thus the lemma is proven.

3

Region-Encoding Diagram

RED is a data-structure for representing set of normalized states. In the implementation aspect, it resembles CDD[7] and each node in RED has the structure shown in figure 2. Such a node is used to evaluate the truth value of a formulus from variable v. The outgoing arcs are labeled with lower and upper bounds of integer parts (note, only integer parts) of values of variable v and direct to the RED’s for the subformulae true in the corresponding ranges of v’s values. For example, if the second arc from left in figure 2, is labeled with [7, 9], then subformulus represented by the RED rooted at v1 must be true when the integer part of v’s value is in [7, 9]. The ranges labeled on arcs from a RED node are required to be disjoint. The lower and upper bounds of outgoing arcs are chosen according to the following rules. For clock variables, we define constant OS = CS + 1 which symbolically denotes a clock reading greater than CS . Thus the lower and upper bounds of outgoing arcs from RED nodes of clock variables are chosen from elements in {0, . . . , CS }∪{OS , ∞} which is sufficient for the regions construction in [2]. For discrete variables, the lower and upper bounds of outgoing arcs are chosen from those constants assigned to and compared with the variable in both the automaton and the specification. For pointer variables, the lower and upper bounds of outgoing arcs are chosen from NULL and integers 1 through m.


165

Given an automaton A with variable name set X, the variable set in the RED for an m process system is {x | x ∈ X; x is global} ∪{x[i] | x ∈ X; x is local; 1 ≤ i ≤ m} ∪{κ[i] | 1 ≤ i ≤ m} Here κ is the name for an auxiliary local binary discrete variable name used to encode the fractional part orderings among clock readings. According to Alur et al’s region graph construction [2], the state-equivalence relation for modelchecking is determined by the following three factors: • the discrete information of each state, • the integer parts of clock readings ≤ CS . • the ordering among the fractional parts of clock readings ≤ CS . Our innovation is that we use one bit (κ) for each clock to encode the ordering among the fractional parts of clock readings in normalized states. For each clock, say x[i] of process i, κ[i] is true in a normalized state s if and only if s(x[i]) ≤ CS and either • i = 1 and frac(s(x[i])) = 0, i.e., s(x[i]) is an integer; or • i > 1 and frac(s(x[i−1])) = frac(s(x[i])), i.e., the fractional parts of s(x[i−1]) and s(x[i]) are the same. With such definition of data-structure and appropriate permutations of process identifiers after clock reading advancements and clock reset operations, we are able to represent the regions of timed automata [2]. As for the other input variables, local or global, we simply copy them as the variables in our RED. Thus given a real-time software system S = A, m, I with A = X, λ, Q, µ, E, τ, π, the number of variables used in our RED is O(m|X| + m). For example, we may have 8 processes in a normalized state with x[1] = 0, x[2] = 3, x[3] = 1.3, x[4] = 1.456, x[5] = 9.456, x[6] = 20.7, x[7] = 38, x[8] = 10π while CS = 13. The readings of clocks and values of κ[i]’s are shown in the following. 2 3 4 5 6 7 8 i 1 x[i] 0 3 1.3 1.456 9.456 20.7 38 10π κ[i] true true false false true false false false

4 4.1

Manipulations on RED Boolean Operations

The Boolean operations on RED’s follow the same style in Bryant’s BDD manipulations [5,7,8]. We present procedure REDop(op, Dx , Dy ) in table 4.1 to illustrate the idea in the implementation of such an operation. For convenience, we use [l, u]D to denote an outgoing arc whose lower bound is l, upper bound is u, and the subformulus RED is D. Also, D.v denotes the index, of D’s variable, used in the variable-ordering of the RED. We should point out that the algorithm shown in table 4.1 is for simplicity and clarity of algorithm presentation and is not for efficiency. Our implementation is more efficient in that it records which pairs of Dx , Dy have already

166

Farn Wang

Table 1. Algorithm for computing Dx op Dy REDop(op, Dx , Dy ){ (1) if op= AND, (1) if Dx is true, return Dy ; (2) else if Dy is true, return Dx ; (3) else if either Dx or Dy is false, return false; (2) else if op= OR, (1) if either Dx or Dy is true, return true; (2) else if Dx is false, return Dy ; (3) else if Dy is false, return Dx ; (3) else { (1) Construct a new RED node D with D.v = min(Dx .v, Dy .v); (2) if Dx .v < Dy .v, then for each outgoing arc [l, u]Dc of Dx , add an outgoing arc [l, u]REDop(op, Dc , Dy ) to D. (3) else if Dx .v > Dy .v, then for each outgoing arc [l, u]Dc of Dy , add an outgoing arc [l, u]REDop(op, Dx , Dc ) to D. (4) else for each outgoing arc [lx , ux ]Dx of Dx and outgoing arc [ly , uy ]Dy of Dy , if [max(lx , ly ), min(ux , uy )] is nonempty, add an outgoing arc [max(lx , ly ), min(ux , uy )]REDop(op, Dx , Dy ) to D. (5) Merge any two outgoing arcs [l, u]Dc , [u + 1, u ]Dc of D into one [l, u ]Dc until no more merge can be done. (6) if D has more than one outgoing arcs, return D, else return the sole subformulus of D; } }

been processed. If a pair of Dx , Dy has already been processed with procedure REDop() before, then we simply return the result recorded in the first time when such a pair was processed.

4.2

Preserving Normality after Transitions and Clock Reading Advancement

RED is a data-structure for normalized states of real-time software systems. Transitions and clock reading advancements may change normalized states into unnormalized states. This section tells us how to symbolically do necessary process identifier permutation to preserve the normality of states. Given a local variable v[i] of process i, we assume that VarIndex(i, v) is the variable index of v[i] in RED. For convenience, we use process identifier 0 (NULL) for those global variables. That is VarIndex(0, v) returns a valid variable index in RED only when v is a global variable. As can be seen from the process identifier permutation scheme in subsection 2.3, segment movements are performed. We can thus define the following function which computes the new identifier of process i after such a segment movement.


167

NewProcId(i, j, k, disp) /* process identifiers j through k are to be moved with displacement disp. */ { (1) if i = 0, return 0; /* Global is always global. */ (2) else if j ≤ i ≤ k, return(i + disp); (3) else if i < j + disp, return(i); (4) else if j + disp ≤ i < j, return(i + k − j + 1); (5) else if k < i ≤ k + disp, return(i − (k − j + 1)); (6) else /* k + disp < i */ return(i); } Due to page-limit, we shall only describe the algorithm for symbolic manipulation of a procedure ToInt(R), in table 2 in page 168, which generates a new RED describing the set of states obtained from those in R by advancing those clocks with biggest fractional parts to integers. In the algorithm presentation, for simple clarity, we use Boolean operation symbols like ∨, ∧ to represent our procedure REDop(). Also for an atom like l ≤ χ ≤ u, it is implemented by constructing the following RED.

Of course, when [0, l − 1] (or [u + 1, ∞]) is empty, the corresponding arc disappears. Symbolic manipulation procedures for next state set after transitions and clock reading advancement from integers to fractionals can all be defined similarly.

5

Experiments

We have experimented to compare RED technology with previously published performance data in two reports[4,6] that compared performances of various model-checkers respectively on two versions of Fischer’s timed mutual exclusion algorithm as shown in Figure 3. The property to be verified is the safe property: at any moment, no more than one process are allowed in mode 3. UPPAAL’s version has bigger timing constants while Balarin’s version allows repetitions. UPPAAL is based on DBM technology and has been well accepted as one of the most efficient model-checkers for real-time systems. It has been used to successfully verify many communication protocols. Recently, CDD technology was proposed to enhance the performance of UPPAAL[7]. However, further reports are yet to be seen. In [6], UPPAAL was compared with many other

168

Farn Wang

ToInt(R) /* R describes the state set before advancing those clock readings with biggest fractional parts to integers. */ { (1) D := false; (2) For 1 ≤ i ≤ m and i ≤ j ≤ m, do { (1) Construct the condition K that • there is no clock whose reading is an integer ≤ CS ; and • processes i to j are those with biggest fractional parts in their clock readings. (2) D := D ∨ RecToInt(K ∧ R, i, j); } (3) Return(D); } RecToInt(K, i, j) { (1) If K is either true or false, return K; (2) Get the process identifier k of K.v; /* k = 0 when v is global. */ (3) Generate the name χ of variable K.v of process NewProcId(k, i, j, 1 − i)); (4) K := false; (5) switch on type of K.v { (6) case LOCAL CLOCK: (1) if i ≤ k ≤ j, then for each outgoing arc [l, u]D of K, K := K ∨ (l + 1 ≤ χ ≤ u + 1 ∧ RecToInt(D , i, j)); else for each outgoing arc [l, u]D of K, K := K ∨ (l ≤ χ ≤ u ∧ RecToInt(D , i, j)); (2) return(K ); (7) case κ[k]: (1) if NewProcId(k, i, j, 1 − i) = 1, (1) then with outgoing arcs [l1 , u1 ]D1 , . . . , [ln , un ]Dn of K, return(κ[1] = true ∧ 1≤h≤n RecToInt(Dh , i, j)); (2) else for each outgoing arc [l, u]D of K, K := K ∨ (l ≤ κ[NewProcId(k, i, j, 1 − i)] ≤ u ∧ RecToInt(D , i, j)); (2) return(K ); (8) case LOCAL Discrete: (9) case GLOBAL Discrete: (1) for each outgoing arc [l, u]D of K, K := K ∨ (l ≤ χ ≤ u ∧ RecToInt(D , i, j)); (2) return(K ); (10) case LOCAL POINTER: (11) case GLOBAL POINTER: (1) for each outgoing arc [l, u]D of K and each l ≤ h ≤ u, { (1) g := NewProcId(h, i, j, 1 − i); (2) K := K ∨ (χ = g ∧ RecToInt(D , i, j)); } (2) return(K ); } }

Table 2. Symbolic manipulation procedure for time-steps from regions with no integer clock readings ≤ CS to those with ones


169

Fig. 3. Two versions of Fischer’s algorithm for experiments

model-checkers like HyTech’s[3], Epsilon, and Kronos[13] on the automaton in figure 3(a). The experiments was reported to be performed on a Sparc-10 with 128 MB memory (real plus swap). All other tools fail when the number of processes reaches beyond 5 while UPPAAL can verify the algorithm on 8 processes. We have implemented two version of RED on an Pentium II 366 MHz IBM notebook with 256 MB memory (real plus swap) running Linux. The tools are avaiable at: http://www.iis.sinica.edu.tw/˜farn/red The first version is plain while the second version employs the clock-shielding reduction technique reported in [12,14]. Reduction clock-shielding replaces clock readings with ∞ in a state when along any runs from the state, it is determined that such a reading will no longer be read unless the clock is reset. The performance is listed in the following table. version resources 2 no CS time 0.19 space 50 CS time 0.17 space 47

3 1.22 212 0.98 161

4 5 6 7 8 9 6.5 27 105 320 888 2323 697 1959 4885 10966 22444 42858 4.4 16.5 50.3 134 325 724 463 1134 2456 4810 8871 15726

10 5556 77503 1493 26194

11 N/A N/A 3002 41930

12 N/A N/A 5743 64323

13 N/A N/A 10152 95389

“CS” means the version with clock-shielding reduction while “no CS” means the one without. The CPU time is measured in seconds. The space is measured in kilobytes and only includes those for the management of RED’s and 2-3 trees. “N/A” means “not available” which indicates that the corresponding experiment has not been performed. The time consumption is considerable bigger than that of UPPAAL[6] considering the CPU clock rate difference. This is due to our implementation philosophy. We believe time is an unbounded resource while space is not. As can be seen from procedure ToInt(), no RED for the relation between current state and next state is computed. In practice, such a relation in RED can occupy a great many bytes. The next-state set RED is computed by analysis on different

170

Farn Wang

situations of i and j. The sacrifice in CPU time pays off in the memory space efficiency. With twice the memory size used in [6], we are now able to verify the simplified Fischer’s algorithm with 13 processes. UPPAAL is a mature tool with a great arsenal of reduction technologies implemented. Our software at this moment only relies on minimal canonicality of RED to gain performance. Please note that the exponent base in our data seems to decrease with respect to concurrency size. This may imply that fully symbolic manipulation is more suitable for large system verification. In the future, with more reduction technique implemented for RED, we hope even more performance improvements will be observed. For example, the clock-shielding reduction indeed slowers down the state-space explosion problem exponentially. Still several simple reduction, like getting rid of FALSE terminal nodes in RED, can be implemented in the future version of RED to get constant factor of improvement. In [4,15], weak and strong approximation technologies of symbolic verification are proposed and experiments are performed on algorithm in figure (b). We extend the performance data table in [4] to compare our tool with previous technologies. RED(no CS) #proc strong weak KRONOS Wong-Toi 6 155sec 18sec 1174sec 74sec 26sec/1374k 7 398sec 48sec M/O 164sec 67sec/2488k 8 986sec 116sec M/O 375sec 142sec/4242k M/O 891sec 303sec/6858k 9 2220sec 247sec 10 M/O 576sec N/A N/A 558sec/10659k 11 N/A N/A N/A N/A 1034sec/15673k N/A N/A N/A N/A 1724sec/22251k 12 13 N/A N/A N/A N/A 2889sec/30593k N/A N/A N/A N/A 4492sec/41019k 14 15 N/A N/A N/A N/A 7047sec/53737k 16 N/A N/A N/A N/A 10782sec/69126k N/A N/A N/A N/A 15330sec/87431k 17 The original table consists of the firt five columns and only reports the CPU time in seconds used by various tools. “M/O” means “out of memory.” KRONOS is also based on DBM technology while Wong-Toi’s tool is based on approximation. In our extension, each entry is composed of both CPU time (in seconds) and space (in kilobytes) used. The column extension is for time/space consumed without clock-shielding reduction. Balarin’s experiment is performed on Sparc 2 with 128 MB memory while ours is performed on IBM Thinkpads with PII 366 MHz and 256 MB memory. Be reminded that verification problems are of high space complexities in nature. The fact that RED-technology can handle much higher concurrency implies that it indeed control state-space explosion better. We believe that such performance is gained not only from utilization of system symmetry, but more importantly, from the data-sharing capability of RED.


6

171

Conclusion

We propose to use one auxiliary binary variable for each clock in our new datastructure for fully symbolic model-checking of real-time software systems. Since we now have fewer variables in the fully symbolic manipulation, theoretically we can expect better verification performance. With better implementation of reduction techniques borrowed from BDD technology, we are hoping for further performance improvement.

References 1. Asaraain, Bozga, Kerbrat, Maler, Pnueli, Rasse. Data-Structures for the Verification of Timed Automata. Proceedings, HART’97, LNCS 1201. 158 2. R. Alur, C. Courcoubetis, D.L. Dill. Model Checking for Real-Time Systems, IEEE LICS, 1990. 157, 158, 159, 164, 165 3. R. Alur, T.A. Henzinger, P.-H. Ho. Automatic Symbolic Verification of Embedded Systems. in Proceedings of 1993 IEEE Real-Time System Symposium. 169 4. F. Balarin. Approximate Reachability Analysis of Timed Automata. IEEE RTSS, 1996. 167, 170 5. J.R. Burch, E.M. Clarke, K.L. McMillan, D.L.Dill, L.J. Hwang. Symbolic Model Checking: 1020 States and Beyond, IEEE LICS, 1990. 157, 165 6. J. Bengtsson, K. Larsen, F. Larsson, P. Pettersson, Wang Yi. UPPAAL - a Tool Suite for Automatic Verification of Real-Time Systems. Hybrid Control System Symposium, 1996, LNCS, Springer-Verlag. 167, 169, 170 7. G. Behrmann, K.G. Larsen, J. Pearson, C. Weise, Wang Yi. Efficient Timed Reachability Analysis Using Clock Difference Diagrams. CAV’99, July, Trento, Italy, LNCS 1633, Springer-Verlag. 158, 164, 165, 167 8. R.E. Bryant. Graph-based Algorithms for Boolean Function Manipulation, IEEE Trans. Comput., C-35(8), 1986. 157, 165 9. E. Clarke and E.A. Emerson. Design and Synthesis of Synchronization Skeletons using Branching-Time Temporal Logic, Proceedings of Workshop on Logic of Programs, Lecture Notes in Computer Science 131, Springer-Verlag, 1981. 10. D.L. Dill. Timing Assumptions and Verification of Finite-state Concurrent Systems. CAV’89, LNCS 407, Springer-Verlag. 157, 158 11. T.A. Henzinger, X. Nicollin, J. Sifakis, S. Yovine. Symbolic Model Checking for Real-Time Systems, IEEE LICS 1992. 12. P.-A. Hsiung, F. Wang. User-Friendly Verification. Proceedings of 1999 FORTE/PSTV, October, 1999, Beijing. Formal Methods for Protocol Engineering and Distributed Systems, editors: J. Wu, S.T. Chanson, Q. Gao; Kluwer Academic Publishers. 169 13. X. Nicolin, J. Sifakis, S. Yovine. Compiling real-time specifications into extended automata. IEEE TSE Special Issue on Real-Time Systems, Sept. 1992. 169 14. F. Wang, P.-A. Hsiung. Automatic Verification on the Large. Proceedings of the 3rd IEEE HASE, November 1998. 169 15. H. Wong-Toi. Symbolic Approximations for Verifying Real-Time Systems. Ph.D. thesis, Stanford University, 1995. 170

Verification of Parameterized Systems Using Logic Program Transformations Abhik Roychoudhury1, K. Narayan Kumar2 , C.R. Ramakrishnan1 , I.V. Ramakrishnan1, and Scott A. Smolka1 1

Dept. of Computer Science, SUNY Stony Brook, Stony Brook, NY 11794, USA {abhik,cram,ram,sas}@cs.sunysb.edu 2 Chennai Mathematical Institute 92 G.N. Chetty Road, Chennai, India [email protected]

Abstract. We show how the problem of verifying parameterized systems can be reduced to the problem of determining the equivalence of goals in a logic program. We further show how goal equivalences can be established using induction-based proofs. Such proofs rely on a powerful new theory of logic program transformations (encompassing unfold, fold and goal replacement over multiple recursive clauses), can be highly automated, and are applicable to a variety of network topologies, including uni- and bi-directional chains, rings, and trees of processes. Unfold transformations in our system correspond to algorithmic model-checking steps, fold and goal replacement correspond to deductive steps, and all three types of transformations can be arbitrarily interleaved within a proof. Our framework thus provides a seamless integration of algorithmic and deductive verification at fine levels of granularity.

1

Introduction

Advances in Logic Programming technology are beginning to influence the development of new tools and techniques for the specification and verification of concurrent systems. For example, constraint logic programming has been used for the analysis and verification of hybrid systems [Urb96] and more recently for model checking infinite-state systems [DP99]. Closer to home, we have used a tabled logic-programming system to develop XMC, an efficient and flexible model checker for finite-state systems [RRR+ 97]. XMC is written in under 200 lines of tabled Prolog code, which constitute a declarative specification of CCS and the modal mu-calculus at the level of semantic equations. Despite the highlevel nature of XMC’s implementation, its performance is comparable to that of highly optimized model checkers such as Spin [Hol97] and Murϕ [Dil96] on examples selected from the benchmark suite in the standard Spin distribution.

This work was partially supported by NSF grants CCR-9711386, CCR-9876242, CDA-9805735 and EIA-9705998.


Verification of Parameterized Systems Using Logic Program Transformations

173

More recently, we have been investigating how XMC’s model-checking capabilities can be extended beyond finite-state systems. Essentially, this can be done by enhancing the underlying resolution strategy appropriately at the level of meta-programming, and without the undue performance penalties typically associated with the concept of meta-programming. In this sense, XMC can be viewed as a programmable verification engine. For example, we have shown in [DRS99] how an efficient model checker for real-time systems can be attained through the judicious use of a constraint package for the reals on top of tabled resolution. In this paper, we expand on this theme even further. In particular, we examine how the tabled-resolution approach to model checking finite-state systems can be extended to the verification of parameterized systems. A parameterized system represents an infinite family of systems, each instance of which is finite state. For example, an n-bit shift register is a parameterized system, the parameter in question being n. In general, the verification of parameterized systems lies beyond the reach of traditional model checkers and it is not at all trivial (or even possible) to adapt them to verify parameterized systems. The main idea underlying our approach is to reduce the problem of verifying parameterized systems to one of determining equivalence of goals in a logic program. We then establish goal equivalences by inducting on the size of proofs of ground instances of goals. To derive such induction proofs we were required to substantially generalize the well-established theory of logic program transformations encompassing unfold, fold and goal-replacement transformations. In particular, in a recent paper [RKRR99b] we developed a new transformation system that allows folding using multiple recursive clauses, which seems essential for proving properties of parameterized systems. In our framework, unfold transformations, which replace instances of clause left-hand sides with corresponding instances of clause right-hand sides, represent resolution. They thereby represent a form of algorithmic model checking; viz. the kind of algorithmic, on-the-fly model checking performed in XMC. Unfold transformations are used to evaluate away the base case and the finite portions of the induction step in an induction proof. Fold transformations, which replace instances of clause right-hand sides with corresponding instances of clause lefthand sides, and goal replacement transformations, which replace a goal in a clause right-hand side with a semantically equivalent goal, represent deductive reasoning. They are used to simplify a given program so that applications of the induction hypothesis in the induction proof can be recognized. Using our approach, we have been able to prove liveness and safety properties of a number of parameterized systems. Moreover, our approach does not seem limited to any particular kind of network topology, as the systems we considered have included uni- and bi-directional chains, rings, and trees of processes. The primary benefits can be summarized as follows. – Uniform framework. Our research has shown that finite-state systems, realtime systems, and, now, parameterized systems can be uniformly specified and verified in the tabled logic programming framework.

174

Abhik Roychoudhury et al.

– Tighter integration of algorithmic and deductive model checking. Unfold, fold, and goal-replacement steps can be arbitrarily interleaved within the verification proof of a parameterized system. Thus our approach allows algorithmic model checking computation (unfold) to be integrated with deductive reasoning (fold, goal replacement) at fine levels of granularity. Also, since deductive steps are applied lazily in our approach, finite-state model checking emerges as a special case of verifying parameterized systems. – High degree of automation. Although a fully automated solution to verification of parameterized systems is not possible, for many cases of practical interest, we have identified certain heuristics that can be applied to our proof system in order to completely automate the deduction involved. The idea of using logic program transformations for proving goal equivalences was first explored in [PP99] for logic program synthesis. Our work expands the existing body of work in logic program transformations with more powerful transformation rules and strategies that are central to verification of parameterized systems. Note that our transformation rules are also applicable for proving general program properties. Regarding related work in the verification area, a myriad of techniques have been proposed during the past decade for verifying parameterized systems, and the related problem of verifying infinite-state systems. [BCG89,EN95,ID99] reduce the problem of verifying a parameterized system to the verification of an “equivalent” finite-state system. [WL89,KM95,LHR97] seek to identify a “network invariant” that is invariant with respect to the given notion of parallel composition and stronger than the property to be established. The network-invariant approach is applicable to parameterized systems consisting of a number of copies of identical components (or components drawn from some finite set) that are composed in parallel. Another approach [CGJ95] aims to finitely represent the state space and transition relation of the entire family of finite-state systems comprising a given parameterized system, and has been used in [KMM+ 97] to extend symbolic model checking [McM93] to the verification of parameterized systems. This method requires the construction of a uniform representation for each class of networks, and the property in question must have a proof that is uniform across the family of networks. Perhaps the work most closely related to our own involves the use of theorem provers for verifying parameterized systems. Rajan et al. [RSS95] have incorporated a mu-calculus model checker as a decision procedure within the PVS theorem prover [OSR92]. Inductive proofs can be established by the prover via calls to the model checker to verify finite subparts. Graf and Saidi [GS96] combine a custom-built specification/deduction system with PVS to formalize and verify invariant properties of infinite-state systems. The key difference between our approach and these is that we enhance model checking with deductive capabilities, rather than implement model checking as a decision procedure in a deductive system. In particular, the underlying evaluation mechanism for model checking in XMC is essentially unfolding, and we have enhanced this mechanism with folding and goal-replacement transforma-


175

tions. In our approach, deductive steps are deployed only on demand and hence do not affect the efficacy of the algorithmic model-checking. More importantly our framework demonstrates that a tabled constraint logic-programming system can form the core of a verification engine that can be programmed to verify properties of various flavors of concurrent systems including finite-state, real-time, and parameterized systems.

2

Parameterized System Verification as Goal Equivalence

In this section, we discuss how verification of temporal properties of parameterized systems can be reduced to checking equivalence of goals in a logic program.

gen([1]). thm(X) :- gen(X), live(X). gen([0|X]) :- gen(X). live(X) :- X = [1| ]. trans([0,1|T], [1,0|T]). live(X) :- trans(X, Y), live(Y). trans([H|T], [H|T1]) :- trans(T, T1). System description

Property description

Fig. 1. Example: Liveness in a unidirectional token-passing chain

Modeling Parameterized Systems: Consider the parameterized system consisting of a chain of n token-passing processes. In the system’s initial state, the process in the right-most position of the chain has the token and no other process has a token. The system evolves by passing the token leftward. A logic program describing the system is given in Figure 1. The predicate gen generates the initial states of an n-process chain for all n. A global state is represented as an ordered list ( a list in Prolog-like notation is of the form [Head|Tail] ) of zeros and ones, each bit corresponding to a local state, and the head of the list corresponding to the local state of the left-most process in the chain. Each process in the chain is a two-state automaton: one with the token (an entry of 1 in the list) and the other without the token (an entry of 0). The set of bindings of variable S upon evaluation of the query gen(S) is { [1], [0,1], [0,0,1], . . . }. The predicate trans in the program encodes a single transition of the global automaton. The first clause in the definition of trans captures the transfer of the token from right to left; the second clause recursively searches the state representation until the first clause can be applied. Liveness Properties: The predicate live in Figure 1 encodes the temporal property we wish to verify: eventually the token reaches the left-most process. The first clause succeeds for global states where the token is already in the leftmost process (a good state). The second (recursive) clause checks if a good state is reachable after a (finite) sequence of transitions. Thus, every member of the family satisfies the liveness property if and only if ∀ X gen(X) ⇒ live(X). Moreover, this is the case if ∀ X thm(X) ⇔ gen(X), i.e., if thm and gen are equivalent

176


(have the same least model). Clearly, testing the equivalence of these goals is infeasible since the minimal model of the logic program is infinite. However, we present in Section 3 a proof methodology, based on program transformations, for proving equivalences between such goals. Safety Properties: We can model safety properties by introducing negation into the above formulation for liveness properties, using the temporal-logic identity G φ ≡ ¬F ¬φ. Although our program transformation systems have been recently extended to handle programs with negation [RKRR99a], for simplicity of exposition we present here an alternative formulation without negation. In particular, we define a predicate bad to represent states that violate the safety property, show that the start states are not bad, and, finally, show that bad states are reachable only from other bad states. For instance, mutual exclusion in the n-process chain can be verified using the following program: bad([1|Xs]) :- one more(Xs). bad([ |Xs]) :- bad(Xs).

bad start(X) :- gen(X), bad(X).

bad src(X,Y) :- trans(X, Y), bad(X). one more([1| ]). bad dest(X,Y) :- trans(X, Y), bad(Y). one more([ |Xs]) :- one more(Xs).

bad is true if and only if the given global state has more than one local state with a token. Showing bad start(X) ⇔ false establishes that the start states do not violate the safety property. Showing that bad src(X) ⇔ bad dest(X) establishes that states that violate the safety property can be reached only from other states that violate the property. These two facts together imply that no reachable state in the infinite family is bad and thus establish the safety property. A Note on the Model: XMC [RRR+ 97] provides a highly expressive process description language based on value-passing CCS [Mil89] for specifying parameterized systems (although XMC is guaranteed to terminate only for finite-state systems). The above simplified presentation (which we will continue to use in the rest of this paper) is used to prevent a proliferation of syntax.

3

Goal Equivalence Proofs Using Tableau

In this section we describe the basic framework to construct such equivalence proofs. We begin by defining the relevant notations. Notations: We assume familiarity with the standard notions of terms, models, substitutions, unification, and most general unifier (mgu) [Llo93]. A term having no variables is called a ground term. Atoms are terms with a predicate symbol at the root (true and false are special atoms), and goals are conjunctions of atoms. Atoms whose subterms are distinct variables (i.e., atoms of the form p(X1 , . . . , Xn ), where p is a predicate symbol of arity n) are called open atoms. We use the following notation (possibly with primes and subscripts): p, q for predicate symbols; X, Y for variables; t, s for terms; X, Y for sequences of variables; t, s for sequences of terms; A, B for atoms; σ, θ for substitutions; C, D for Horn clauses; α, β for goals; and P for a definite logic program, which is a


177

set of Horn clauses. A Horn clause C is written as A :− B1 , B2 , . . . , Bn . A, the consequent, is called the head of C and the antecedent B1 , B2 , . . . , Bn the body of C. Note that we can write Horn clauses as A :− α. Semantics of a definite logic program P is given in terms of least Herbrand models, M (P ). Given a goal α and a program P , SLD resolution is used to prove whether instances of α are in M (P ). This proof is constructed recursively by replacing an atom B in α with βθ where B :− β ∈ P and θ = mgu(B, B ). We use P0 , P1 , . . . , Pn to denote a program transformation sequence where Pi+1 is obtained from Pi by applying a transformation. We call P0 as the original program. 3.1

Tableau Construction

The goal equivalence problem is: given a logic program P and a pair of goals α, β, determine if α and β are semantically equivalent in P : i.e., whether for all ground substitutions θ, αθ ∈ M (P ) ⇔ βθ ∈ M (P ). This problem is undecidable in general and we attempt to provide a deductive system for identifying equivalence. We now develop a tableau-based proof system for establishing goal equivalence. Our proof system is analogous to SLD resolution. Let Γ = P0 , P1 , . . . , Pi be a sequence of logic programs such that Pj+1 is obtained from Pj (1 ≤ j < i) by the application of a rule in our tableau. Further let M (P0 ) = M (P1 ) = M (P2 ) = . . . = M (Pi ). An e-atom is of the form Γ α ≡ β where α and β are goals, and represents our proof obligation: that α and β are semantically equivalent in any program in Γ . An e-goal is a (possibly empty) sequence of e-atoms (e-atoms and e-goals correspond to atoms and goals in standard resolution).

(Ax) (Tx) (Gen)

Γ α≡β hline Γ α≡β Γ, Pi+1 α ≡ β

where α ∼ =β where M (Pi+1 ) = M (Pi )

Γ α≡β where M (Pi+1 ) = M (Pi ) if α ≡ β hline Γ, Pi+1 α ≡ β, P0 α ≡ β

Fig. 2. Rules for constructing equivalence tableau

The three rules used to construct equivalence tableau are shown in Figure 2. The axiom elimination rule (Ax) is applicable whenever the equivalence of goals α and β can be established by some automatic mechanism, denoted by α ∼ = β. Axiom elimination is akin to the treatment of facts in SLD resolution. The program transformation rule (Tx) attempts to simplify a program in order to expose the equivalence of goals. We use this rule when we apply a (semanticspreserving) transformation that does not add any equivalence proof obligations e.g. unfolding, folding. The sub-equivalence generation rule (Gen) replaces an e-atom with new e-atoms which are (hopefully) simpler to establish. This step

178


is akin to standard SLD resolution step. Note that the proof of α ≡ β may involve a transformation sequence different from, and not just an extension of, Γ . A successful tableau for an e-goal E0 is a finite sequence E0 , E1 , . . . , En where Ei+1 is obtained from Ei by applying Ax/Tx/Gen and En is empty. Theorem 1 Let E0 , E1 . . . , En be a successful tableau, P0 be a (definite) logic program and E0 = P0 α ≡ β. For all ground substitutions θ, αθ ∈ M (P0 ) ⇔ βθ ∈ M (P0 ), i.e. α and β are equivalent in the least Herbrand model of P0 . The tableau, however, is not complete. There can be no such complete tableau (which can be proved using a reduction in [AK86]). Theorem 2 The problem of determining equivalence of predicates described by logic programs is not recursively enumerable. 3.2

Program Transformations

The Tx and Gen rules of our proof system require us to transform a program Pi into a program Pi+1 . This is accomplished by applying logic program transformations that include unfolding, folding, goal replacement and definition introduction. For a simple illustration of program transformations, consider Figure 3. There, program P1 is derived from P0 by unfolding the occurrence of r in the definition of q. P2 is derived from P1 by folding t,s in the definition of p using the definition of q. While unfolding is semantics preserving, indiscriminate fold-

p :- t, s. q :- r , s. r :- t. ... Program P0

p :- t, s . q :- t, s. r :- t. ...

p :- q. q :- t, s. r :- t. ...

Program P1 Program P2

Fig. 3. Example of an unfold/fold transformation sequence

ing may introduce circularity, thereby removing finite proof paths. e.g. folding t,s in the definition of q in P2 using the definition of p in P0 results in a program p :- q. q :- p. r :- t. .... This removes p and q from the least model. We now present the program transformations informally. For a formal description, the reader is referred to [RKRR99b]. With each clause C in program Pi of the transformation sequence, we associate a pair of integer counters that bound the size of a shortest proof of any ground atom A derived using C in program Pi relative to the size of a shortest proof of A in P0 . Thus the counters keep track of potential reductions in proof lengths. Conditions on counters are then used to determine if a given application of folding is semantics preserving.


B : −β, A A1 : −α1 . A2 : −α2 . .. . An : −αn .

179

A1 : −α1 . Bσ1 : −(β, α1 , β )σ1 . .. Bσ2 : −(β, α2 , β )σ2 . Pj : , β. . .. An : −αn . . =⇒ Bσn : −(β, αn , β )σn . B : −β, α1 , β . A1 : −α1 . B : −β, α2 , β . .. P : =⇒ B : −β, A , β . i .. . . An : −αn . B : −β, αn , β .

(a) Unfolding

(b) Folding

Fig. 4. Schema for unfold/fold transformations Unfolding of an atom A in the body of a clause in Pi is shown in Figure 4a. The conditions for applying the transformation are : (i) A1 , . . . , An are the only clause heads in Pi which unify with A, and (ii) σj is the mgu of A and Aj for all 1 ≤ j ≤ n. Note that these conditions are taken directly from resolution, which means that unfolding is essentially a resolution step. Folding replaces an occurrence of the body of a clause with its head. The clause where the replacement takes place is called the folded clause and the clauses used to perform the replacement are called the folder clauses. The folding schema is illustrated in in Figure 4b, where the clauses of B are the folded clauses, and the clauses of A are the folder clauses. The folder clauses may come from some earlier program Pj (j ≤ i) in the transformation sequence. The conditions for applying the transformation are1 : (i) αl is an instance of αl with substitution σl for all 1 ≤ l ≤ n (ii) there is an atom A such that ∀1 ≤ l ≤ n Al σl = A and the folder clauses are the only clauses in Pj whose heads unify with A. Goal replacement replaces an atom B in a clause A :− α, Bβ in program Pi with a semantically equivalent atom B to obtain the clause A :− α, B , β. Note that such a replacement can change lengths of proofs of A arbitrarily. To obtain the counters associated with the new clause we need to estimate the changes in proof lengths. In practice, we do so by using techniques based on Integer Linear Programming. Details appear in [Roy99]. Theorem 3 ([RKRR99b]) Let P0 , P1 , . . . , PN be a sequence of definite logic programs where Pi+1 is obtained from Pi by an application of unfolding, folding, or goal replacement. Then M (Pi ) = M (P0 ), 1 ≤ i ≤ N . Definition-introduction transformation adds clauses defining a new predicate to a program Pi . This transformation is used to generate “names” for goals. Note 1

In addition, certain other conditions need to be imposed including conditions on the counters of the folder and folded clauses; we do not mention them here.

180


that after definition introduction, M (Pi+1 ) = M (Pi ) since a new predicate is added to Pi+1 . But for every predicate p in Pi , and all ground terms t, p(t) ∈ M (Pi ) ⇔ p(t) ∈ M (Pi+1 ). The tableau presented earlier can be readily extended to include such transformations. 3.3

Checking Goal Equivalence from Syntax

Recall that the axiom elimination rule (Ax) is applicable whenever we can mechanically establish the equivalence of two goals. We now develop a syntax-based technique to establish the equivalence of two open atoms, i.e., atoms of the form p(X) and q(X). p(X) :- r(X). p(X) :- e(X,Y), p(Y). r(X) :- b(X).

q(X) :- s(X). q(X) :- e(X,Y), q(Y). s(X) :- b(X).

Consider the example program given above. We can infer that r(X) ≡ s(X) since r and s have identical definitions. Then, we can infer q(X) ≡ p(X), since their definitions are “isomorphic”. Formally: P

Definition 1 (Syntactic Equivalence) A syntactic equivalence relation, ∼, is an equivalence relation on the set of predicates of a program P such that for P all predicates p, q in P , if p ∼ q then: 1. p and q have same arity, and 2. Let the clauses defining p and q be {C1 , . . . , Cm } and {D1 , . . . , Dn }, re spectively. Let {C1 , . . . , Cm } and {D1 , . . . , Dn } be such that Cl (Dl ) is obtained by replacing every predicate symbol r in Cl (Dl ) by s, where s is the P

name of the equivalence class of r (w.r.t. ∼). Then there exist two functions f : {1, . . . , m} → {1, . . . , n} and g : {1, . . . , n} → {1, . . . , m} such that: (a) ∀1 ≤ i ≤ m Ci is an instance of Df (i) , and (b) ∀1 ≤ j ≤ n Dj is an instance of Cg(j) . The largest syntactic equivalence relation can be computed by starting with all predicates in the same class, and repeatedly splitting the classes until a fixed point is reached. Syntactic equivalence is sound w.r.t. semantic equivalence, i.e. P

Lemma 4 Let P be a program and ∼ be the syntactic equivalence relation. For P all predicates p, q, if p ∼ q, then p(X) ≡ q(X).

4

Automated Construction of Equivalence Tableau

We describe an algorithmic framework for creating strategies to automate the construction of the tableau. The objective is to: (a) find equivalence proofs that arise in verification with limited user intervention, and (b) apply deduction rules lazily, i.e. a proof using the strategy is equivalent to algorithmic verification for finite-state systems.


181

algorithm Prove(A, B: open atoms, Γ :prog. seq.) begin let Γ = P0 , . . . , Pi (* Ax rule *) P

if (A = p(X) ∧ B = q(X) ∧ p ∼i q) then return true else nondeterministic choice (* Tx rule *) case FIN (Γ, unfold (Pi ) ): (* Unfolding *) return Prove(A, B, Γ, unfold(Pi ) ) case Folding is possible in Pi : return Prove(A, B, Γ, fold(Pi ) ) (* Gen rule *) case Conditional folding is possible in Pi : let (A , B ) = new atom equiv for fold (Pi ) return replace and prove(A, B, A , B , Γ ) case Conditional equivalence is possible in Pi : let (α, β) = new goal equiv for equiv (A, B, Pi ) return replace and prove(A, B, α, β , Γ ) end choices end

Fig. 5. Algorithmic framework for automated construction of tableau

In our framework, the tableau rules and associated transformations are applied in the following order. Given an e-atom Γ α ≡ β, the proof is complete whenever the axiom elimination rule (Ax) is applicable. Hence, we first choose to apply Ax. When the choice is between the Tx and Gen rules, we choose the former since Tx allows unfolding, i.e. resolution. This will ensure that our strategies will perform algorithmic verification, a’ la XMC, for finite-state systems. For infinite-state systems, however, uncontrolled unfolding will diverge. To create finite unfolding sequences we impose the finiteness condition FIN in Definition 2. If FIN prohibits any further unfolding we either apply the folding transformation associated with Tx or use the Gen rule. Care must be taken, however, when Gen is chosen. Recall from the definition of Gen that α ≡ β in Pi+1 implies α ≡ β in Pi only if we can prove a new equivalence α ≡ β in P0 . Since Gen itself does not specify the goals in the new equivalence, its application is highly nondeterministic. We limit the nondeterminism by using Gen only to enable Ax or Tx rules. Definition 2 (Finiteness condition) An unfolding transformation sequence Γ = P0 , . . . , Pi , . . . satisfies FIN (Γ ) if and only if for the clause C and atom A selected for unfolding at Pi : (i) A is distinct modulo variable renaming from any atom B which was selected in unfolding some clause D ∈ Pj (j < i) where C is obtained by repeated unfolding of D (ii) the term size of A is bounded a-priori by a constant.

182


Hence, when no further unfoldings are possible, we apply any possible folding. If no foldings are enabled, we check if there are new atom equivalences that will enable a folding step. We call this a conditional folding step. Note that atom equivalences may be of the form p(t) ≡ q(s), where t and s are sequences of arbitrary terms, whereas the test for syntactic equivalence is only done on open atoms. We therefore introduce new definitions to convert them into open atoms. Finally, we look for new goal equivalences, which, if valid, can lead to syntactic equivalence. This is called as a conditional equivalence step. In such a step, an equivalence proof on arbitrary goals is first converted into equivalence between open atoms by introducing new definitions. The above intuitions are formalized in Algorithm Prove (see Figure 5). Given a program transformation sequence Γ , and a pair of open atoms A, B, algorithm Prove attempts to prove that Γ A ≡ B. Algorithm Prove uses the following functions. Function replace and prove constructs proofs for sub-equivalences created by applying the Gen rule. replace and prove(A, B, α, β, Γ ) first introduces definitions for α and β, then proves the equivalence P0 α ≡ β by invoking Prove, then replaces α by β and finally invokes Prove to complete the proof of Γ A ≡ B. Functions unfold (P ) and fold (P ) apply unfolding and folding transformations respectively to program P and return a new program. Whenever conditional folding is possible, the function new atom equiv for fold (P ) finds the pair of atoms whose replacement is necessary to do the fold operation. Similarly, when conditional equivalence is possible, new goal equiv for equiv (A, B, P ) finds a pair of goals α, β s.t. syntactic equivalence of A and B can be established after replacing α with β in P . Note that Prove terminates as long as the number of definitions introduced (i.e., new predicate symbols added) is finite. If multiple cases of the nondeterministic choice are enabled, then Prove tries them in the order specified in Figure 5. If none of the cases apply, then evaluation fails, and backtracks to the most recent unexplored case. There may also be nondeterminism within a case; for instance, many fold transformations may be applicable at the same time. By providing selection functions to pick from the applicable transformations, one can implement concrete strategies from Prove. Details appear in [Roy99]. 4.1

Example: Liveness Property in Chains

Recall the logic program of Figure 1 which formulates a liveness property about token-passing chains, namely, that the token eventually reaches the left-most process in any arbitrary length chain. To establish the liveness property, we prove thm(X) ≡ gen(X) by invoking Prove(thm(X), gen(X), P0 ). The proof tree is illustrated in Figure 6 (dashed arrows in the figure denote multiple applications of the transformation annotating the arrow). Prove first unfolds the clauses of thm to obtain: thm([1]). thm([0|X]) :- gen(X), X = [1| ]. thm([0|X]) :- gen(X), trans(X,Y), live([0|Y]).

Verification of Parameterized Systems Using Logic Program Transformations P0

thm(X)

183

gen(X) Unfolds

P5 Defn. Intro. (live’(Y):-live([0|Y]).

P6 Fold

P7 Goal Replacement

P0

live’(Y)

live(Y)

P0,...,P7,P12 thm(X)

Unfolds

P10

gen(X)

Fold

P13 Fold

Fold

P11

P14

live’ ~ live

thm ~ gen

Fig. 6. Proof tree for liveness property in chains

Since no unfolding or folding is applicable, conditional folding is done giving rise to the (sub)-equivalence live([0|Y]) ≡ live(Y). Since live([0|Y]) is not an open atom, a new definition live’(Y) :- live([0|Y]) is added to P5 to yield P6 . Then Prove folds the third clause of thm using this definition and recursively invokes Prove(live’(X), live(X), P0 ) to establish live’(X) ≡ live(X). This subproof appears in the left branch of Figure 6. Finally, Prove replaces live’(X) with live(X) in the clauses of thm and completes the proof of thm(X) ≡ gen(X) by applying two folding steps. It is interesting to observe in Figure 6 that the unfolding steps that transform P0 to P5 and P7 to P10 are interleaved with folding steps. This illustrates how we interleave algorithmic model-checking steps with deduction steps. 4.2

Example: Mutual Exclusion in Token Rings

Algorithm Prove generates a proof for mutual exclusion in a n-process token ring. The token ring is described by the following logic program: gen([0,1]). gen([0|X]) :- gen(X). trans1([0,1|T],[1,0|T]). trans1([H|T],[H|T1]) :- trans1(T,T1).

trans(X,Y) :- trans1(X,Y). trans([1|X],[0|Y]) :- trans2(X,Y). trans2([0], [1]). trans2([H|X],[H|Y]) :- trans2(X,Y).

As in the case of chains (see Section 2), we represent the global state of a ring as a list of local states. Processes with tokens are in local state 1 while processes without tokens are in state 0. trans is now divided into two parts: trans1 which transfers the token to the left neighbor in the list, and trans2 which transfers the token form the front of the list to the back, thereby completing the ring. Mutual

184

Abhik Roychoudhury et al. P0

bad_src(X)

bad_dest(X)

Unfolds

P10 Defn. Intro.(s1(X,Y):- ...)

P0

bad_start(X)

P11

false

Defn. Intro. (s2(X,Y):- ...)

Unfolds

P12

P3

Folds

Fold

P4 bad_start ~ false

P14 P0 s1(X,Y)

Defn. Introductions

s2(X,Y) Unfolds

P21

Rest of the proof Folds

P23 s1 ~ s2

Fig. 7. Proof trees for mutual exclusion in token rings

exclusion, a safety property, is modeled using the predicates bad, bad start, etc. as discussed in Section 2. These predicates, along with those listed above, form the initial program P0 . Recall that a safety proof can be completed by showing bad start ≡ false and bad src ≡ bad dest. Figure 7 illustrates the proofs generated by Prove to demonstrate these equivalences. Invocation of Prove(bad start(X), false, P0 ) performs unfoldings to obtain program P3 where bad start is defined using a single clause, namely: bad start([0|X]) :- gen(X), bad(X). Prove now folds using the original definition of bad start to obtain P4 where bad start is defined by the clause: bad start([0|X]) :- bad start(X). Since bad start is defined by a single self-recursive clause, it is detected as failed, and hence bad start ≡ false. An invocation of Prove(bad src(X), bad dest(X), P0 ) performs unfoldings, to get program P10 where the definitions of bad src and bad dest are: bad bad bad bad bad bad bad bad bad bad bad bad

src([0,1,1|X], [1,0,1|X]). src([0,1,H|T], [1,0,H|T]) :- one more(T). src([1|X],[1|Y]) :- trans1(X,Y), one more(X). src([H|X],[H|Y]) :- trans1(X,Y), bad(X). src([1,1|X],[0,1|Y]) :- trans2(X,Y). src([1,H|X],[0,H|Y]) :- trans2(X,Y), one more(X). dest([0,1,1|X], [1,0,1|X]). dest([0,1,H|T], [1,0,H|T]) :- one more(T). dest([1|X],[1|Y]) :- trans1(X,Y), one more(Y). dest([H|X],[H|Y]) :- trans1(X,Y), bad(Y). dest([1,1|X],[0,1|Y]) :- trans2(X,Y), one more(Y). dest([1,H|X],[0,H|Y]) :- trans2(X,Y), bad(Y).


185

Now, to show bad src ≡ bad dest, Prove applies conditional equivalence steps, generating the following (sub)-equivalences: trans1(X,Y), one more(X) ≡ trans1(X,Y), one more(Y) trans1(X,Y), bad(X) ≡ trans1(X,Y), bad(Y) trans2(X,Y), one more(Y) ≡ trans2(X,Y) trans2(X,Y), one more(X) ≡ trans2(X,Y), bad(Y) We now show the proof of the first of the above. Proofs of the other three (sub)-equivalences proceed similarly, and are omitted. Since the goals are not open atoms, the following definitions are created to obtain program P12 . s1(X, Y) :- trans1(X,Y), one more(X). s2(X, Y) :- trans1(X,Y), one more(Y).

Since no new unfolding is applicable at P12 , the clauses of bad src and bad dest are folded using the above two clauses to obtain P14 . Prove(s1(X), s2(X), P0 ) is then invoked by Prove as a subproof. This subproof is completed after a sequence of unfoldings (to reach program P21 ) and two foldings, yielding P23 : s1([0,1|X], [1,0|X]). s1([1|X],[1|Y]) :- trans1(X,Y). s1([H|X],[H|Y]) :- s1(X,Y).

s2([0,1|X], [1,0|X]). s2([1|X],[1|Y]) :- trans1(X,Y). s2([H|X],[H|Y]) :- s2(X,Y).

P

23 s1 ∼ s2 and hence s1(X) ≡ s2(X).

5

Concluding Remarks

A preliminary prototype implementation of our transformation system, built on top of our XSB tabled logic-programming system [XSB99], has been completed. So far we have been able to automatically verify a number of examples including the ones described in this paper. Our plan now is to investigate the scalability of our system on more complex problems such as parameterized versions of the Rether protocol [DSC99] and the Java meta-locking protocol [BSW00].

References AH96.

AK86. BCG89.

BSW00.

R. Alur and T. A. Henzinger, editors. Computer Aided Verification (CAV ’96), volume 1102 of Lecture Notes in Computer Science, New Brunswick, New Jersey, July 1996. Springer-Verlag. 186 K. Apt and D. Kozen. Limits for automatic verification of finite-state systems. Information Processing Letters, 15:307–309, 1986. 178 M. Browne, E. Clarke, and O. Grumberg. Reasoning about networks with many identical finite-state processes. Information and Computation, 81(1):13–31, 1989. 174 S. Basu, S.A. Smolka, and O.R. Ward. Model checking the Java metalocking algorithm. In IEEE International Conference on the Engineering of Computer Based Systems. IEEE Press, April 2000. 185

186 CGJ95.


E. Clarke, O. Grumberg, and S. Jha. Verifying parametrized networks using abstraction and regular languages. In CONCUR, LNCS 962, 1995. 174 Dil96. D. L. Dill. The Murϕ verification system. In Alur and Henzinger [AH96], pages 390–393. 172 DP99. G. Delzanno and A. Podelski. Model checking in CLP. In TACAS’99, volume LNCS 1579, pages 74–88. Springer-Verlag, March 1999. 172 DRS99. X. Du, C.R. Ramakrishnan, and S.A. Smolka. Tabled resolution + constraints: A recipe for model checking real-time systems. Technical report, Dept. of Computer Science, SUNY Stony Brook, http://www.cs.sunysb.edu/~vicdu/papers, 1999. 173 DSC99. X. Du, S. A. Smolka, and R. Cleaveland. Local model checking and protocol analysis. Software Tools for Technology Transfer, 1999. 185 EN95. E. Emerson and K.S. Namjoshi. Reasoning about rings. In POPL, pages 85–94, 1995. 174 GS96. S. Graf and H. Saidi. Verifying invariants using theorem proving. In Alur and Henzinger [AH96]. 174 Hol97. G. J. Holzmann. The model checker SPIN. IEEE Transactions on Software Engineering, 23(5):279–295, May 1997. 172 ID99. C. N. Ip and D. L. Dill. Verifying systems with replicated components in Murϕ. Formal Methods in System Design, 14(3), May 1999. 174 KM95. R.P. Kurshan and K. Mcmillan. A structural induction theorem for processes. Information and Computation, 117:1–11, 1995. 174 KMM+ 97. Y. Kesten, O. Maler, M. Marcus, A. Pnueli, and E. Shahar. Symbolic model-checking with rich assertional languages. In CAV, LNCS 1254, 1997. 174 LHR97. D. Lesens, N. Halbwachs, and P. Raymond. Automatic verification of parametrized linear networks of processes. In POPL, pages 346–357, 1997. 174 Llo93. J.W. Lloyd. Foundations of Logic Programming, Second Edition. SpringerVerlag, 1993. 176 McM93. K. L. McMillan. Symbolic Model Checking. Kluwer Academic, 1993. 174 Mil89. R. Milner. Communication and Concurrency. International Series in Computer Science. Prentice Hall, 1989. 176 OSR92. S. Owre, N. Shankar, and J. Rushby. PVS: A Prototype Verification System. Proceedings of CADE, 1992. 174 PP99. A. Pettorossi and M. Proietti. Synthesis and transformation of logic programs using unfold/fold proofs. Journal of Logic Programming, 41, 1999. 174 RKRR99a. A. Roychoudhury, K. Narayan Kumar, C.R. Ramakrishnan, and I.V. Ramakrishnan. Beyond Tamaki-Sato style unfold/fold transformations for normal logic programs. In ASIAN, LNCS 1742, pages 322–333, 1999. 176 RKRR99b. A. Roychoudhury, K. Narayan Kumar, C.R. Ramakrishnan, and I.V. Ramakrishnan. A parameterized unfold/fold transformation framework for definite logic programs. In PPDP, LNCS 1702, pages 396–413, 1999. 173, 178, 179 Roy99. A. Roychoudhury. Program transformations for automated verification of parameterized concurrent systems. Technical report, Department of Computer Science, State University of New York at Stony Brook, http://www.cs.sunysb.edu/~abhik/papers, 1999. Dissertation proposal. 179, 182

Verification of Parameterized Systems Using Logic Program Transformations RRR+ 97.

RSS95. Urb96. WL89.

XSB99.

187

Y.S. Ramakrishna, C.R. Ramakrishnan, I.V. Ramakrishnan, S.A. Smolka, T. Swift, and D.S. Warren. Efficient model checking using tabled resolution. In CAV, LNCS 1254, 1997. 172, 176 S. Rajan, N. Shankar, and M. K. Srivas. An integration of model checking with automated proof checking. In CAV, LNCS 939, 1995. 174 L. Urbina. Analysis of hybrid systems in CLP(R). In Constraint Programming (CP’96), volume LNCS 1102. Springer-Verlag, 1996. 172 P. Wolper and V. Lovinfosse. Verifying properties of large sets of processes with network invariants. In Automatic Verification Methods for Finite State Systems, LNCS 407, 1989. 174 The XSB logic programming system v2.01, 1999. Available by anonymous ftp from www.cs.sunysb.edu/~sbprolog. 185

Abstracting WS1S Systems to Verify Parameterized Networks Kai Baukus1 , Saddek Bensalem2 , Yassine Lakhnech2 , and Karsten Stahl1 1

Institute of Computer Science and Applied Mathematics, University of Kiel Preusserstr. 1–9, D-24105 Kiel, Germany. {kba,kst}@informatik.uni-kiel.de 2 Verimag, Centre Equation 2 Av. de Vignate, 38610 Gières, France. {bensalem,lakhnech}@imag.fr

Abstract. We present a method that allows to verify parameterized networks of finite state processes. Our method is based on three main ideas. The first one consists in modeling an infinite family of networks by a single WS1S transition system, that is, a transition system whose variables are set (2nd-order) variables and whose transitions are described in WS1S. Then, we present methods that allow to abstract a WS1S system into a finite state system that can be model-checked. Finally, in order to verify liveness properties, we present an algorithm that allows to enrich the abstract system with strong fairness conditions while preserving safety of the abstraction. We implemented our method in a tool, called pax, and applied it to several examples.

1

Introduction

Recently there has been much interest in the automatic and semi-automatic verification of parameterized networks, i.e., verification of a family of systems {Pi | i ∈ ω}, where each Pi is a network consisting of i finite-state processes. Apt and Kozen show in [AK86] that the verification of parameterized networks is undecidable. Nevertheless, automated and semi-automated methods for the verification of restricted classes of parameterized networks have been developed. The methods presented in [GS92,EN95,EN96] show that for classes of ring networks of arbitrary size and client-server systems, there exists k such that the verification of the parameterized network can be reduced to the verification of networks of size up to k. Alternative methods presented in [KM89,WL89,BCG89,SG89,HLR92,LHR97] are based on induction on the number of processes. These methods require finding a network invariant that abstracts any arbitrary number of processes with respect to a pre-order that preserves the property to be verified. While this method has been originally presented for linear networks, it has been generalized in [CGJ95] to networks generated by context-free grammars. In [CGJ95], abstract transition systems were

This work has been partially supported by the Esprit-LTR project Vires. Contact Author.


Abstracting WS1S Systems to Verify Parameterized Networks

189

used to specify the invariant. An abstract transition system consists of abstract states specified by regular expressions and transitions between abstract states. The idea of representing sets of states of parameterized networks by regular languages is applied in [KMM+ 97], where additionally finite-state transducers are used to compute predecessors. These ideas are applied to linear networks as well as to processes arranged in a tree architecture and semi-automatic symbolic backward analysis methods for solving the reachability problem are given. The work presented in [ABJN99] extends the ideas in [KMM+ 97] by considering the effect of applying infinitely often a transition that satisfies certain restrictions. These restrictions allow to characterize the effect of the repeated application of the transition by finite-state transducers. Moreover, the method presented in [ABJN99] allows to consider networks of processes guarded by both local and global conditions that restrict the context in which a transition can be taken. Global conditions are typically used in many mutual exclusion algorithms such as Szymanski’s algorithm, the bakery and ticket algorithms by Lamport and Dijkstra’s algorithm. In this paper we present a method for the verification of parameterized networks that can deal with a larger class of networks than the methods presented in [KMM+ 97,ABJN99] and that is applicable to verify communal liveness (also referred to as weak liveness) properties [MP94]. To verify parameterized protocols we first transform a given infinite family of networks of finite processes into a bisimilar single transition system whose variables are set variables and whose transitions are described in WS1S, the weak monadic second order logic of one successor. We call such systems WS1S transition systems. Then, we abstract the obtained WS1S transition system into a finite abstract system that can be analyzed using model-checking techniques. To obtain such a finite abstraction, one needs to come up with an appropriate abstraction relation and to construct a correct abstract system, i.e., a system which exhibits for every behavior of the WS1S system a corresponding abstract behavior. We present a method to construct an abstraction relation from the given WS1S transition system and three techniques that allow to automatically construct either a correct abstract system, the reachability state graph of a correct abstract system without constructing the system itself or, finally, an abstraction of such a graph. Our experience shows that our method for constructing an abstraction relation is useful for many examples and that it is useful to have the three techniques for constructing an abstract system. It is well known that an obstacle to the verification of liveness properties using abstraction, e.g. [CGL94,LGS+ 95,DGG94], is that often the abstract system contains cycles that do not correspond to paths in the concrete system. This is not surprising since the main goal of an abstraction relation is to identify and merge states together, which consequently introduces new cycles. A way to overcome this difficulty is to enrich the abstract system with fairness conditions or more generally ranking functions over well-founded sets that eliminate undesirable cycles, that is, cycles that do not correspond to concrete computations. The main problem is, however, to find such fairness conditions. To tackle this

190

Kai Baukus et al.

problem, we present an algorithm that given a reachability state graph of an abstraction of a WS1S system enriches the graph with strong fairness conditions while preserving the property that to each concrete computation corresponds an abstract fair one. Hence, we can use the enriched graph to prove liveness properties of the WS1S systems, and consequently, of the parameterized network. We implemented our method in a tool, we call pax, that uses the decision procedures of Mona [KM98,HJJ+ 96] to check the satisfiability of WS1S formulas. We then applied our method to several examples including Szymanski’s mutual exclusion algorithm, a server-ring as well as a token passing protocol. The first results obtained using our method and pax are very encouraging.

2

Preliminaries

In this, section, we briefly recall the definition of weak second order theory of one successor (WS1S for short) [B¨ uc60,Tho90] and introduce the logic we use to describe the class of parameterized systems we are interested in. Terms of WS1S are built up from the constant 0 and 1st-order variables by applying the successor function succ(t) (“t + 1”). Atomic formulae are of the form b, t = t , t < t , t ∈ X, where b is a boolean variable, t and t are terms, and X is a set variable (2nd-order variable). WS1S-formulae are built up from atomic formulae by applying the boolean connectives as well as quantification over both 1st-order and 2nd-order variables. First-order monadic formulae are WS1S-formulae in which no 2nd-order variables occur. WS1S-formulae are interpreted in models that assign finite subsets of ω to 2nd-order variables and elements of ω to 1st-order variables. The interpretation is defined in the usual way. Given a WS1S formula f , we denote by [[f ]] the set of models of f . The set of free variables in f is denoted by free(f ). We say that f is (1st-order) closed, if it does not contain (1st-order) free variables. In addition to the usual abbreviations, given a 2nd-order variable P , we write ∀P i : f instead of ∀i : i ∈ P → f and ∃P i : f instead of ∃i : i ∈ P ∧ f . Finally, we recall that by B¨ uchi [B¨ uc60] and Elgot [Elg61] the satisfiability problem for WS1S is decidable. Indeed, the set of all models of a WS1S-formula is representable by a finite automaton (see, e.g., [Tho90]). Let n be a variable. To define parameterized systems, we introduce the set AF(n) of formulae f defined by: f ::= b[x] | ¬f | f ∧ f | ∀n x : f | ∃n x : f , where x is a position variable, b is a boolean array variable. Let m ∈ ω. We denote by Σm the set of evaluations s such that s(n) = m, s(x) ∈ {0, · · · , m − 1} and s(b) : {0, · · · , m − 1} → {true, false}. Then, formulae in AF(n) are interpreted over evaluations s ∈ m∈ω Σm in the usual way. In the sequel, we also assume the usual notion of free variables, closed formulae, etc., as known.


3

191

Parameterized Systems

We now introduce a class of parameterized systems for which we develop an abstraction-based verification technique. Definition 1 (Boolean Transition Systems). A boolean transition system S(i, n), parameterized by n and i, where n and i are variables ranging over natural numbers, is described by the triple (V, Θ, T ), where – V = {b1 , . . . , bk } and each bj , 1 ≤ j ≤ k, is a boolean array of length n. – Θ is a formula in AF(n) with free(Θ) ⊆ V ∪ {i} and which describes the set of initial states. – T is a finite set of transitions where each τ ∈ T is given by a formula ρτ ∈ AF(n) such that free(ρτ ) ⊆ V ∪ V ∪ {i} and m−1

We denote by Pm the parallel composition l=0 S(l, m), where S(l, m) is obtained from S(i, n) by substituting m for n and l for i and where denotes the interleaving-based parallel composition (asynchronous product). Notice, that if we identify the boolean array variables bj by the m boolean variables bj [1], · · · , bj [m], the formulae describing the initial states as well as the m−1 transitions of l=0 S(l, m) are first-order WS1S formulae whose free variables are in V, respectively, V ∪ V . Thus, Pm is a transition system in the usual sense, i.e., it does not contain the parameters n and i. Hence, we assume the definition of a computation of Pm as known and we denote by [[Pm ]] the set of its computations. Then, a monadic parameterized system P (MPS for short) built from S(i, n) is the set {Pm | m ≥ 1}. To illustrate the above definitions we consider Szymanski’s mutual exclusion algorithm [Szy88] as a boolean transition system. Example 1 (Szymanski’s mutual exclusion algorithm). Consider the following version of Szymanski’s mutual exclusion algorithm (cf. [ABJN99]), where each process S(i, n) is described as follows: 1 : await ∀n j : at 1 [j] ∨ at 2 [j] ∨ at 4 [j] 2 : skip 3 : if ∃n j : at 2 [j] ∨ at 5 [j] ∨ at 6 [j] ∨ at 7 [j] then goto 4 else goto 5 4 : await ∃n j : at 5 [j] ∨ at 6 [j] ∨ at 7 [j] 5 : await ∀n j : at 1 [j] ∨ at 2 [j] ∨ at 5 [j] ∨ at 6 [j] ∨ at 7 [j] 6 : await ∀n j : j < i → (at 1 [j] ∨ at 2 [j] ∨ at 4 [j]) 7 : critical section ; goto 1 For the sake of presentation, the example is given in the style of [MP95]. The await statements express the guards for the transitions leading from one control location to the next one, i.e., the processes have to wait until the guard becomes true. In our formal model the control locations are modeled by a boolean array

192

Kai Baukus et al.

variable at k for each location k , 1 ≤ k ≤ 7. According to Definition 3 the transition from 1 to 2 is given by the AF(n) formula: 7 (∀n j : at 1 [j] ∨ at 2 [j] ∨ at 4 [j]) ∧ ∀n j : j = i → l=1 at l [j] ↔ at l [j] 7 ∧ at 1 [i] ∧ ¬at 1 [i] ∧ at 2 [i] ∧ l=3 at l [i] ↔ at l [i] . The initial condition states that each process starts in 1 . Our aim is to prove that this algorithm satisfies the mutual exclusion prop erty, which can be expressed by ✷¬ ∃n i, j : i = j ∧ at 7 [i] ∧ at 7 [j].

4

WS1S Transition Systems

In this section, we introduce WS1S transition systems which are transition systems with variables ranging over finite sub-sets of ω and show how they can be used to represent infinite families of boolean transition systems. Definition 2 (WS1S Transition Systems). A WS1S transition system S = (V, Θ, T ) is given by the following components: – V = {X1 , . . . , Xk }: A finite set of second order variables where each variable is interpreted as a finite set of natural numbers. – Θ: A WS1S formula with free(Θ) ⊆ V describing the initial condition of the system. – T : A finite set of transitions where each τ ∈ T is represented as a WS1S ✷ formula ρτ (V, V ), i.e., free(ρτ ) ⊆ V ∪ V . The computations of S are defined as usual. Moreover, let [[S]] denote the set of computations of S. Relating parameterized and WS1S transition systems. We define a translation that maps an MPS to a bisimilar WS1S system. We fix a 2nd-order variable P that is used to model the set of indices of the processes up to n. The translation from MPS to WS1S systems uses a function tr from AF(n) into WS1S. This function replaces in an AF(n)-formula all occurrences of atomic sub-formulae of the form b[i] by i ∈ B, all n by max(P ) + 11 , and λn by λP where λ is one of the quantifiers ∀ or ∃. Definition 3 (Translation of Boolean to WS1S Systems). Consider an MPS system P built from S(i, n) where S(i, n) = (V, Θ, T ). Define a WS1S T ) by constructing the variable set, the initial condition, and the system (V , Θ, transitions as follows: – For each boolean array bk in V , V contains the variable Bk . Additionally, V contains the set variable P . be ∃n : P = {0, . . . , n − 1} ∧ k Bl ⊆ P ∧ (∀P i : tr(Θ)). – Let Θ l=1 k – Let T be the set {∃P i : tr (ρτ ) ∧ P = P ∧ l=1 Bl ⊆ P | τ ∈ T }. 1

It is not difficult to check that max(P ) can be expressed in WS1S.


193

We denote the above transformation of an MPS system P by Tr (P).

✷

Example 2 (Szymanski cont’d). The translation of Example 1 into a WS1S system introduces a set variable P and set variables At 1 , . . . , At 7 . According to the above definition of the translation we have as initial condition Θ ∃n : P = {0, . . . , n − 1} ∧

k

Bl ⊆ P ∧ ∀P i : (i ∈ At 1 ∧

l=1

7

i∈ / At l ) .

l=2

The translation of the AF(n) formula characterizing the transition from 1 to 2 presented in Example 1 yields 7 (∀P j : j ∈ At 1 ∪ At 2 ∪ At 4 ) ∧ ∀P j : j = i → l=1 j ∈ At l ↔ j ∈ At l 7 ∧ i ∈ At 1 ∧ i ∈ / At 1 ∧ i ∈ At 2 ∧ l=3 i ∈ At l ↔ i ∈ At l which, using the invariant

k

l=1

Bl ⊆ P , can be simplified to

7 (∀P j : j ∈ At 1 ∪ At 2 ∪ At 4 ) ∧ l=3 At l = At l ∧ At 1 = At 1 \ {i} ∧ At 2 = At 2 ∪ {i} . In order to state the relationship between an MPS P and its translation, we introduce a function h relating the states of both systems. Let P be an MPS built from S(i, n) = (V, Θ, T ) with V = {b1 , . . . , bk }. Let m be a natural number. denote the set of interpretations s˜ of V such that s˜(X) ⊆ s˜(P ), for Let Σ s → s˜ by s˜(P ) = {0, . . . , m − 1} each X ∈ V . Then, define hm : Σm → Σ, and s˜(Bj ) = {l < m | s(bj [l]) = true}, for every 1 ≤ j ≤ k. Then, we define h = m∈ω hm . Notice that h is a bijection. The following lemma shows that h is consistent with the translation tr from AF(n) into WS1S. Lemma 1. Let f be a formula in AF(n) with free(f ) ⊆ V ∪ V ∪ {i} and let all m ∈ ω, for all s, s ∈ Σm , we have: (s, s ) |= f iff (h(s), h(s )) |= tr(f ) . ✷ Using this lemma we can prove the following theorem that justifies our verification method given in Section 5. The theorem states that Pm is bisimilar to Tr (P) when we initialize P to {0, . . . , m − 1}. Theorem 1 (Relating Boolean and WS1S Systems). Let P be an MPS built from S(i, n) and m ∈ ω. Then, h is a bisimulation between Pm and Tr ∗ (P), ≡P = where Tr ∗ (P) is obtained from Tr (P) by taking as initial condition Θ k {0, . . . , m − 1} ∧ l=1 Bl ⊆ P ∧ ∀P i : tr (Θ).

194

Kai Baukus et al.

Proof: Consider s0 to be an initial state of Pm , i.e., s0 |= Θ. With Lemma 1 it follows that h(s0 ) |= P = {0, . . . , m − 1} ∧

k

Bl ⊆ P ∧ (∀P i : tr (Θ)) .

l=1

Vice versa, for any initial state s˜0 of some computation in [[Tr ∗ (P)]] the state h−1 (˜ s0 ) is an initial state of P. with With the same argumentation we can show for s, s ∈ Σm and s˜, s˜ ∈ Σ s˜ = h(s) that for any τ ∈ T , – if s is a τ -successor of s then h(s ) is a tr (ρτ )-successor of s˜, and – if s˜ is an tr (ρτ )-successor of s˜ then h−1 (˜ s ) is a τ -successor of s. Hence, both systems are bisimilar. ✷ Using Theorem 1, we can prove the following: Corollary 1. Let P be an MPS built from S(i, n). Then, lifting h to computa✷ tions, we have a bijection between m∈ω [[Pm ]] and [[Tr (P)]].

5

Abstracting WS1S Systems

In Section 4, we have shown how parameterized boolean transition systems can be translated into WS1S systems. This translation allows us to consider a single, though infinite-state, transition system instead of an infinite family of systems. In the following, we present a method to construct finite abstractions of WS1S systems. To do so, we first present a heuristic that allows to construct for a given WS1S system an abstraction function such that the corresponding abstract system has a finite state space. Then, we present a method that, given such a function, constructs a finite transition system that is an abstraction of the given WS1S system. Model-checking techniques can then be used to construct a state graph of this abstract system. The nodes of the constructed graph represent sets of abstract states and the edges correspond to abstract transitions. This graph contains all reachable abstract states. The nodes of the finest graph that can be constructed represent singleton sets, i.e., single abstract states. The coarsest graph has one node corresponding to the set of reachable states. In fact, the granularity of the computed graph depends on the techniques used during exploration. While the previous method first constructs an abstract system from which a graph is computed, we also present two methods inspired by [GS97] for computing an abstract state graph, resp. an abstraction of it, without computing the abstract transition system at all. These methods are useful in case the abstract system is not computable for size reasons. Finally, we describe our pax tool which implements these techniques using Mona [KM98,HJJ+ 96].


195

We first recall some definitions and the idea of proving properties of systems by abstraction. Given a transition system S = (V, Θ, T ) and a total abstraction relation α ⊆ Σ × ΣA , we say that SA = (VA , ΘA , TA ) is an abstraction of S w.r.t. α, denoted by S α SA , if the following conditions are satisfied: – s0 |= Θ implies α(s0 ) |= ΘA – τ ◦ α−1 ⊆ α−1 ◦ τA . Let ✷ϕ, ✷ϕA be invariance formulae, i.e., ϕ, ϕA are state formulae. Then, from S α SA , α−1 ([[ϕA ]]) ⊆ [[ϕ]], and SA |= ✷ϕA we can conclude S |= ✷ϕ. This statement, which is called preservation result, shows the interest of verification by abstraction: since if SA is finite, it can automatically be checked whether SA |= ✷ϕA . In fact a similar preservation result holds for any temporal logic without existential quantification over paths, e.g., ∀CTL , LTL, or µ✷ [CGL94,DGG94,LGS+ 95]. 5.1

Constructing the Abstraction Function

Our heuristic to construct an abstraction function for WS1S systems assumes the transitions to have the following form: ∃P i : G ∧ L(i) ∧ C(i) ∧ V = exp(V, V ) , where G, L(i), C(i) are WS1S formulae whose free variables are in V and such that: – G is a 1st-order closed WS1S formula. Intuitively, G describes a global condition. E.g., in the Szymanski example (see Example 2), the presented transition contains the global condition ∀P j : j ∈ At 1 ∪ At 2 ∪ At 4 . – L(i) is a quantifier-free formula with i as the unique free 1st-order variable. Intuitively, if i models a process index then L(i) is a condition on the local state of this process. – C(i) is a condition that as in the case of L(i) has i as the unique free 1storder variable but which contains 1st-order quantifiers. Intuitively, it imposes conditions on the context of process i. Though, the above requirements restrict the set of considered WS1S systems, it still includes all translations of MPS systems. Let S = (V, Θ, T ) be a WS1S system whose transitions satisfy the restriction above. We are now prepared to present our heuristic for constructing abstraction functions. The set VA of abstract variables contains a boolean variable bX for each variable X ∈ V. Moreover, for each global guard G, resp. local guard L occurring in a transition, it contains a boolean variable bG , resp. bL . Since the context guards C(i) describe a dependence between process i and the remaining processes, it turns out to be useful to combine them with the local guards. Indeed, this allows to check, for instance, whether some dependence is propagated

196

Kai Baukus et al.

over some transitions. Therefore, we introduce boolean variables bLk ,Cl for some boolean combinations of local guards and context guards. Additionally, VA contains a boolean variable for each state formula appearing in the property to be verified. It remains now to present how we relate the concrete and abstract states, i.e., to describe an abstraction relation α. The abstraction relation α can be expressed on the syntactic level by a predicate α over V, VA which is defined as the conjunction of the following equivalences: bX ≡ X = ∅ bG ≡ G bL ≡ ∃P i : L(i) bLk ,Cl ≡ ∃P i : Lk (i) ∧ Cl (i) bξ ≡ ξ ) to denote the predicate obtained from α by subHenceforth, we use α (V , VA stituting the unprimed variables with their primed versions.

Example 3 (Szymanski cont’d). Applying the above heuristic on Szymanski’s algorithm (see Example 2) we get seven boolean variables: ψi ≡ At i = ∅, for each 1 ≤ i ≤ 7 . The global guards not referring to i can be derived by the above variables and do not lead to a finer partitioning of the state space. All the local guards i ∈ At l would introduce a boolean variable with meaning ∃i : i ∈ At l which is equivalent to stating that At l is not empty. In the transition leading from 6 to 7 we have a context ∀j < i : j ∈ At 1 ∪ At 2 ∪ At 4 which we have to combine with the local guards i ∈ At l . For this example it turns out to be enough to take only one combination, namely ϕ ≡ ∃i : i ∈ At 7 ∧ ∀j < i : j ∈ At 1 ∪ At 2 ∪ At 4 . Moreover, for the property of interest we introduce ξ ≡ ¬∃l, j : l = j ∧ l ∈ At 7 ∧ j ∈ At 7 . 5.2

Constructing the Abstract System

In Section 5.1, we presented a method that allows to construct an abstraction function from a given WS1S system. In this section, we show how to use this abstraction function to automatically construct a finite transition system that can be model-checked. Let S = (V, Θ, T ) be a given WS1S system that satisfies the restriction given in Section 5.1 and let α be the abstraction function constructed by the method


197

given in the same section. Notice that since the abstract variables are booleans, the abstract system we construct is finite, and hence, can be subject to modelchecking techniques. Moreover, we make use of the fact that both α (V, VA ) and the transitions in T are expressed in WS1S to give an effective construction of the abstract system. Henceforth, given a set γ of abstract states, we denote by γ (VA ) a WS1S formula that characterizes this set. The abstract system we construct contains for each concrete transition τ an abstract transition τA , which is characterized by the formula (V, VA ) ∧ ρτ (V, V ) ∧ α (V , VA ) ∃V, V : α . with free variables VA and VA The initial states of the abstract system we construct can be described by the formula ∃V : α (V, VA ) .

To compute them, one has to find all states fulfilling this formula, which is possible since this is a WS1S formula. 5.3

Constructing Abstract State Graphs

We first define state graphs of transition systems. Note that there is a whole set of state graphs for a given transition system. Definition 4 (State Graphs). Let S = (V, Θ, T ) be a transition system and Σ be the set of all reachable states of S. A state graph G of S is a tuple (N , E, N0 , µ), where N is a set of nodes, N0 ⊆ N is the set of initial nodes, E ⊆ N × T × N is a set of labeled edges, and µ : N → 2Σ is a labeling function, such that the following conditions are satisfied: 1. [[Θ]] ⊆ q∈N0 µ(q). 2. ∀q ∈ N , τ ∈ T : post τ (µ(q)) ⊆ (q,τ,q )∈E µ(q ), where post τ (µ(q)) is the set of successors of µ(q) w.r.t. τ . ✷ There are several strategies to calculate a state graph for an abstract system. First of all, if one has previously computed the abstract system as explained in Section 5.2, one can use model-checking techniques, for example a forward state exploration, to construct a state graph. The actual graph obtained depends on the computation techniques used. Another way is to compute such a graph without calculating the abstract system at all. The nodes of the graph are sets of abstract states. One starts with an initial node representing the set of abstract initial states, which are computed as shown in Section 5.2. Assume that a concrete transition τ and node q are given. The formula A) ∧ α (V, VA ) ∧ ρτ (V, V ) ∧ α (V , VA ) ∃VA , V, V : µ(q)(V

198

Kai Baukus et al.

describes the set M of abstract post states w.r.t. τA . Then, a node q with µ(q ) = M and an edge (q, τA , q ) are added to the graph. This process is repeated until no new nodes or edges can be added. The so obtained graph is a state graph of SA , we call this calculation precise computation. Since we restrict ourselves to abstraction functions of the form ai ↔ ϕi (V) , α (V, VA ) ≡ 1≤i≤k

where VA = {a1 , . . . , ak }, we can also eliminate the abstract variables VA by replacing each abstract variable ai by ϕi (V). The decision procedure for WS1S is based on constructing a finite automaton over finite words that recognizes the set of models of the considered formula. In practice, however, it can happen that the automaton cannot be constructed because of its size. In this case, we propose to go on as follows to obtain an abstract state graph of SA . We start with the same initial node as before. Given a node q and concrete transition τ , we construct new nodes by computing for each abstract variable ai the set Mi ⊆ {true, false} of fulfilling values for ai of A) ∧ α (V, VA ) ∧ ρτ (V, V ) ∧ (ai ↔ ϕi (V )) . ∃VA , V, V : µ(q)(V Again, the abstract variables VA can be eliminated. In case Mi is empty for some i, then there does not exist any post state, and hence, the computation for the other variables can be omitted. Otherwise, instead of taking a node representing the set of abstract post states, one takes a new node q with µ(q ) = {s | ∀i : s(ai ) ∈ Mi } and a new edge (q, τA , q ). The set µ(q ) contains at least all possible abstract post states w.r.t. τA . It is not difficult to see that this method computes an abstraction of SA , and hence, is also an abstraction of S. 5.4

The Pax Tool

We use Mona [KM98,HJJ+ 96] to decide the predicates mentioned above. In fact, Mona is able to construct all models of a WS1S predicate. Our system pax constructs state graphs. It uses Mona to compute the abstract initial states, the abstract transitions, or the set of abstract post states represented by a state graph node. To do so, it creates from its input files input for Mona and interprets the Mona results. Once an abstract system (resp. abstract state graph) is constructed, a translation to SMV, alternatively to SPIN, can be used to model-check the obtained abstract system (resp. abstract state graph). pax allows the combination of the method of Section 5.2, which consists in computing abstractions of concrete transitions independently of any source abstract state, with the methods of Section 5.3. This is helpful in case Mona does not succeed in computing an abstract transition because of memory limitations. In Table 1 we give run time results for the calculation of the abstract systems of some examples, one of it is the Szymanski mutual exclusion algorithm given


199

in Example 3. The construction of the state graph from the abstract system does not require mentionable time. We used a Sun Ultra Sparc 5/10 with 768 MB of memory and 333 MHz processor. Table 1. pax construction of abstract transition systems Example Abstract Transitions System Szymanski 7 min 28 sec Server-ring 40 sec Token passing 5 sec

The run time results for the construction of a state graph (resp. an abstraction) without previous computation of the abstract system of these examples is summarized in Table 2. Table 2. pax results for state graph construction Example Precise Computation Abstraction Szymanski 49 min 52 sec 56 sec Server-ring 1 min 5 sec 13 sec Token passing 1 min 40 sec 19 sec

Example 4 (Szymanski cont’d). For the Szymanski’s algorithm and the abstraction function given in Example 3, we obtain using the last method of Section 5.3 the state graph presented in Figure 1. The labeling function µ is also given in for each node q. The initial states are Figure 1 in form of the predicates µ(q) marked by an edge without source node. It is not difficult to check that no state falsifying the mutual exclusion property is reachable in the obtained graph.

6

Proving Liveness Properties

Let S be a WS1S transition system and G = (N , E, N0 , µ) be a state graph of SA constructed from S and an abstraction function α. Let ϕ be an LTL formula. Let ξ1 , · · · , ξn be the atomic subformulae of ϕ such that, for every node p ∈ G, → ξi either all states in µ(p) satisfy ξi or none does, i.e., we have either µ(p) or µ(p) → ¬ξi is valid. For each ξi , we introduce a proposition Pi . Then, let Gˇ = (N , E, N0 , ν) be a Kripke structure with the same nodes, edges, and initial → ξi is valid. Let also ϕˇ be the nodes as G and such that Pi ∈ ν(p) iff µ(p) formula obtained from ϕ by substituting Pi for ξi . Then, S |= ϕ, if Gˇ |= ϕ. ˇ Example 5 (Szymanski cont’d). Let G = (N , E, N0 , µ) be the state graph for Szymanski’s algorithm given in Example 4. Let us now consider the liveness property ϕ ≡ ✷✸ψ7 expressing that the critical section is entered infinitely

200

Kai Baukus et al. ψ1 ∧¬ψ2..7 ∧¬φ∧ξ 1→2

1→2

ψ2 ∧¬ψ3..7

ψ1 ∧¬ψ2..4,7

1→2

∧¬φ∧ξ

∧¬φ∧ξ

2→3

2→3

7→1

∧¬φ∧ξ 3→4 ψ2,4 ∧¬ψ5..7

3→4

3→4

2→3

ψ1,6,7 ∧¬ψ2..4

∧¬φ∧ξ

∧φ∧ξ 5→6

1→2

∧¬φ∧ξ 2→3

2→3

3→5

5→6

5→6

7→1

¬ψ2,4,6,7 ∧ψ5

ψ2,4 ∧¬ψ3,5..7

∧¬φ∧ξ

∧φ∧ξ

3→5

∧¬φ∧ξ

ψ3,4 ∧¬ψ5..7

6→7 ψ1,7 ∧¬ψ2..4

ψ3 ∧¬ψ4..7

3→4

∧φ∧ξ

∧¬φ∧ξ

∧¬φ∧ξ

∧¬φ∧ξ 4→5

ψ1,6 ∧¬ψ2..4,7

6→7 ¬ψ2..4,7 ∧ψ6

1→2 ¬ψ2,6,7 ∧ψ4,5 3→4

¬ψ2,6,7 ∧ψ5

6→7

7→1 ¬ψ2..4 ∧ψ7

5→6

3→4

5→6

5→6

5→6

7→1 ¬ψ2..4 ∧ψ6,7 ∧φ∧ξ

5→6 5→6

∧¬φ∧ξ

4→5

Fig. 1. Reachability graph for Szymanski’s mutual exclusion algorithm

often. Clearly, we can define a Kripke structure Gˇ = (N , E, N0 , ν) with the same nodes and edges as G and with a proposition P such that P ∈ ν(p) iff → ψ7 . Thus, all nodes labeled by P are shadowed in Figure 1. Moreover, |= µ(p) we get ϕˇ ≡ ✷✸P . ˇ This is due to It is easy to see that ϕˇ does not hold in the Kripke structure G. the cycles which generate infinite traces in Gˇ without ever reaching a shadowed node. However, these traces have no corresponding computations in the concrete WS1S system. E.g., the loops labeled 1 → 2 are the abstraction of the transition taking an element out of At 1 and adding it to At 2 . Clearly, since WS1S is interpreted over finite sets, it is impossible to infinitely execute transition 1 → 2 without taking a transition that adds elements to At 1 . In this section we present a method that allows us to add fairness conditions to the Kripke structure Gˇ constructing a fair Kripke structure GˇF such that we still have S |= ϕ, if GˇF |= ϕˇ and such that the added fairness conditions rule out infinite traces in Gˇ that have no counter-parts in S. The method uses a marking algorithm that labels each edge of the considered state graph with one of the symbols {+X , −X , =X } for each set variable X of the original WS1S system. Intuitively, the labels −X resp. =X express whether the transitions at the concrete level reduce resp. maintain the cardinality of a set X, the label +X represents all other cases. For the sake of presentation, we use p(VA ) instead of µ(p).


201

Marking Algorithm Input: WS1S system S = (V, Θ, T ), abstraction relation α , state graph G = (N , E, N0 , µ) of SA Output: Edge labeling of G Description: For each X ∈ V, for each edge e = (p, τA , q) ∈ E, let τ be the concrete transition in T corresponding to τA . Moreover, let ∆(X, e, ≺), with ≺∈ {⊂, =}, denote the WS1S formula: (V, VA ) ∧ q(VA )∧α (V , VA ) ∧ τ (V, V ) ⇒ X ≺ X . p(VA ) ∧ α

Then, mark e with −X , if ∆(X, e, ⊂) is valid, mark e with =X , if ∆(X, e, =) is valid, and mark e with +X otherwise. + Now, for a set variable X we denote with EX the set of edges labeled with +X . ˇ F ) where F is the set Then, the fair Kripke structure is defined as GˇF = (G, of strong fairness conditions containing for each edge e and each of its labels −X + the set (e, EX ). Each fairness condition states that e can only be taken infinitely + often if one of the edges in EX is taken infinitely often.

Example 6 (Szymanski cont’d). Figure 2 shows part of the abstract state graph after running the labeling algorithm. All =X symbols are left out and the labels +At k , −At k are abbreviated with +k , −k . The figure shows a strongly con-

−3 , +4

in ψ2 ∧ ψ4 ∧ ¬ψ5..7 ∧¬φ ∧ ξ

−3 , +4

−2 , +3

ψ3 ∧ ψ4 ∧ ¬ψ5..7 ∧¬φ ∧ ξ −2 , +3

out

−1 , +2

ψ2 ∧ ¬ψ3 ∧ ψ4 ∧ ¬ψ5..7 ∧¬φ ∧ ξ −2 , +3 −1 , +2

Fig. 2. Part of the labeled state graph

nected part of the graph with the only ingoing edge in and only outgoing edge out. To prove communal accessibility it is necessary to show that the system cannot cycle forever in this component. ˇ Hence, SzymanIt can be proved, e.g., using model-checking, that GˇF |= ϕ. ski’s algorithm satisfies ✷✸ ∃P i : i ∈ At 7 .

202

7

Kai Baukus et al.

Conclusion

We have presented a method for the verification of parameterized networks of finite processes. Our method is based on the transformation of an infinite family of systems into a single WS1S transition system and applying abstraction techniques on this system. We also showed how our method can deal with liveness properties. We have applied this method, which has been implemented in our tool pax, to a number of parameterized protocols. The obtained results are encouraging. Closest to our work is [ABJN99]. Therefore, we give a short account of the main differences between this and our work. While the method in [ABJN99] aims at computing the exact set of reachable states, our method computes an over-approximation. On the other hand, their method may fail because of the divergence of the exploration algorithm, even when acceleration is applied. Moreover, our method can deal with a larger class of networks and with a class of liveness properties, often called communal accessibility. We intend to extend our method to deal with a larger class of liveness properties. It is also clear that we can use WS2S instead of WS1S when we consider networks arranged in trees.

References ABJN99.

AK86.

BCG89.

B¨ uc60. CGJ95.

CGL94.

DGG94.

Elg61.

P.A. Abdulla, A. Bouajjani, B. Jonsson, and M. Nilsson. Handling Global Conditions in Parameterized System Verification. In N. Halbwachs and D. Peled, editors, CAV ’99, volume 1633 of LNCS, pages 134–145. Springer, 1999. 189, 191, 202 K. Apt and D. Kozen. Limits for Automatic Verification of Finit-State Concurrent Systems. Information Processing Letters, 22(6):307–309, 1986. 188 M.C. Browne, E.M. Clarke, and O. Grumberg. Reasoning about networks with many identical finite state processes. Information and Computation, 1989. 188 J.R. B¨ uchi. Weak Second-Order Arithmetic and Finite Automata. Z. Math. Logik Grundl. Math., 6:66–92, 1960. 190 E. Clarke, O. Grumberg, and S. Jha. Verifying Parameterized Networks using Abstraction and Regular Languages. In I. Lee and S. Smolka, editors, CONCUR ’95: Concurrency Theory, LNCS. Springer, 1995. 188 E. M. Clarke, O. Grumberg, and D. E. Long. Model checking and abstraction. ACM Transactions on Programming Languages and Systems, 16(5), 1994. 189, 195 D. Dams, R. Gerth, and O. Grumberg. Abstract interpretation of reactive systems: Abstractions preserving ACTL∗ , ECTL∗ and CTL∗ . In E.-R. Olderog, editor, Proceedings of PROCOMET ’94. North-Holland, 1994. 189, 195 C.C. Elgot. Decision problems of finite automata design and related arithmetics. Trans. Amer. Math. Soc., 98:21–52, 1961. 190


203

E. A. Emerson and K. S. Namjoshi. Reasoning about rings. In 22nd ACM Symposium on Principles of Programming Languages, pages 85–94, 1995. 188 EN96. E. A. Emerson and K. S. Namjoshi. Automatic verification of parameterized synchronous systems. In 8th Conference on Computer Aided Verification, LNCS 1102, pages 87–98, 1996. 188 Gru97. O. Grumberg, editor. Proceedings of CAV ’97, volume 1256 of LNCS. Springer, 1997. 203 GS92. S.M. German and A.P. Sistla. Reasoning about systems with many processes. Journal of the ACM, 39(3):675–735, 1992. 188 GS97. S. Graf and H. Saidi. Construction of Abstract State Graphs with PVS. In Grumberg [Gru97]. 194 HJJ+ 96. J.G. Henriksen, J. Jensen, M. Jørgensen, N. Klarlund, B. Paige, T. Rauhe, and A. Sandholm. Mona: Monadic Second-Order Logic in Practice. In TACAS ’95, volume 1019 of LNCS. Springer, 1996. 190, 194, 198 HLR92. N. Halbwachs, F. Lagnier, and C. Ratel. An experience in proving regular networks of processes by modular model checking. Acta Informatica, 22(6/7), 1992. 188 KM89. R.P. Kurshan and K. McMillan. A structural induction theorem for processes. In ACM Symp. on Principles of Distributed Computing, Canada, pages 239–247, Edmonton, Alberta, 1989. 188 KM98. N. Klarlund and A. Møller. MONA Version 1.3 User Manual. BRICS, 1998. 190, 194, 198 KMM+ 97. Y. Kesten, O. Maler, M. Marcus, A. Pnueli, and E. Shahar. Symbolic Model Checking with Rich Assertional Languages. In Grumberg [Gru97], pages 424–435. 189 LGS+ 95. C. Loiseaux, S. Graf, J. Sifakis, A. Bouajjani, and S. Bensalem. Property preserving abstractions for the verification of concurrent systems. Formal Methods in System Design, 6(1), 1995. 189, 195 LHR97. D. Lesens, N. Halbwachs, and P. Raymond. Automatic verification of parameterized linear networks of processes. In POPL ’97, Paris, 1997. 188 MP94. Z. Manna and A. Pnueli. Verification of parameterized programs. In E. Borger, editor, Specification and Validation Methods, pages 167–230, Oxford University Press, 1994. 189 MP95. Z. Manna and A. Pnueli. Temporal Verification of Reactive Systems, Safety. Springer Verlag, 1995. 191 SG89. Z. Stadler and O. Grumberg. Network grammars, communication behaviours and automatic verification. In Proc. Workshop on Automatic Verification Methods for Finite State Systems, Lecture Notes in Computer Science, pages 151–165, Grenoble, France, 1989. Springer Verlag. 188 Szy88. B.K. Szymanski. A simple solution to Lamport’s concurrent programming problem with linear wait. In Proceedings of International Conference on Supercomputing Systems 1988, pages 621–626, St. Malo, France, July 1988. 191 Tho90. W. Thomas. Automata on infinite objects. In Handbook of Theoretical Computer Science, Volume B: Formal Methods and Semantics, pages 134– 191. Elsevier Science Publishers B. V., 1990. 190 WL89. P. Wolper and V. Lovinfosse. Verifying properties of large sets of processes with network invariants (extended abstract). In Sifakis, editor, Workshop on Computer Aided Verification, LNCS 407, pages 68–80, 1989. 188 EN95.

FMona: A Tool for Expressing Validation Techniques over Infinite State Systems J.-P. Bodeveix and M. Filali IRIT Université Paul Sabatier 118 route de Narbonne, F-31062 Toulouse {bodeveix,filali}@irit.fr

Abstract. In this paper, we present a generic tool, called FMona, for expressing validation methods. we illustrate its use through the expression of the abstraction technique and its application to infinite or parameterized space problems. After a review of the basic results concerning transition systems, we show how abstraction can be expressed within FMona and used to build a reduced system with decidable properties. The FMona tool is used to express the validation steps leading to synthesis of a finite abstract system;then SMV and/or Mona validate its properties. Keywords: abstraction, transition systems, model checker, monadic second order logic.

1

Introduction

In recent years, important work has been done in the design and implementation of general specification languages and validation systems. Usually, we distinguish three families of tools: model checkers (SMV [BCMD90], SPIN [Hol91]) to build a finite model and check its temporal properties; automatic proof tools (Mona [HJJ+ 95]) which offer a complete decision procedure if the underlying logic is decidable and proof assistants (Coq [BBC+ 97], HOL [GM94] and PVS [ORS92]) which offer an expressive higher order logic (and thus not decidable) and an assistance to the validation of formulas expressed in this logic. Our experience in using these tools has led us to the following observations: – model checkers are generally easy to use but their validation algorithm is “hardwired” and the available data structures are generally poor, – automatic proof tools lack a specification language level to express methods – and proof assistants lack powerful decision procedures and their integration is a delicate operation. Moreover their use is uneasy and require for instance the knowledge of the underlying type theory, the proof tactics, the tactic language and the underlying decision procedures. In this paper, we relate an attempt to overcome these problems. We have chosen an intermediate approach combining an automatic proof tool and higher level S. Graf and M. Schwartzbach (Eds.): TACAS/ETAPS 2000, LNCS 1785, pp. 204–219, 2000. c Springer-Verlag Berlin Heidelberg 2000

FMona: A Tool for Expressing Validation Techniques

205

aspects so that the expression of validation methods becomes easy. Of course, unlike proof assistants, our tool FMona cannot be used to validate the methods themselves. Encoded methods can only be instantiated on given applications. As our automatic proof tool target, we have chosen Mona as the main proof tool. Actually, within its underlying logic (WS1S) we can express transition systems and most of their basic properties without restricting to finite state spaces. Indeed, we can consider parameterized transition systems. We have used FMona to express several validation techniques, e.g. iterative methods with convergence acceleration over parameterized state systems and abstraction methods. In the following, we focus on the use of FMona to express and apply the abstraction method. The remainder of this paper is organized as follows: section 2 presents the logic underlying the studied validation techniques and its associated tools. Section 3 describes the transition system formalism and states the theorems underlying the abstraction technique. In section 4, we describe the use of the abstraction method to the validation of always true and simulation properties. Sections 5 and 6 illustrate the technique on two concrete examples. Section 7 considers some ongoing work.

2

Monadic Second Order Logic and Related Tools

We recall below the definition of the two variants (WS1S and S1S) of the monadic second order logic of one successor [Tho90]. Then, we present the Mona tool deciding WS1S formulas and its high level interface FMona. Definition 1 (The S1S and WS1S logics) Let {x1 , . . . , xn } be a family of first order variables and {X1 , . . . , Xn } a family of second order monadic variables. A primitive grammar of this logic can be defined as follows: – A term t is recursively defined as: t ::= 0 | xi | s(t) – A logic formula f is recursively defined as: f ::= Xi (t) | ¬f | f ∧ f | ∃xi . f | ∃Xi . f Notice that the successor function s is the only function. Validity of a formula A closed formula is valid in S1S or WS1S if it is valid in the interpretation on the set N of naturals, where s is the successor function, first order quantifiers relate to the naturals and second order quantifiers to the subsets (finite in the case of WS1S) of N . These two logics are decidable [Tho90]. The monadic second order logic naturally supports the method presented since it makes it possible on the one hand to express the concept of sequence of execution on a finite state space and the temporal properties associated, and on the other hand the refinement relation between a parameterized concrete space and a finite abstract space.

206

J.-P. Bodeveix and M. Filali

The Mona Tool The Mona tool [HJJ+ 95] implements a decision procedure for WS1S, based on the automata theory. The Mona syntax accepts the constructions of the WS1S logic presented in the preceding section. Mona data types are thus limited to booleans, naturals and finite sets of naturals. Thus, propositional, first order and second order variables are respectively declared, existentially and universally quantified by vari , exi and alli where i is the order of the variable. The FMona Tool The FMona tool [BF99b] is a high level interface for Mona. For instance, it is possible to declare enumerated and record with update types and quantify over them. Furthermore, FMona allows the definition of higher order macros parameterized by types and predicates. FMona source code is typechecked, macro expanded and translated to pure Mona. The following example defines the transition relation req1 between the states st and st’. The complete example is given in section 5. type PC = {out,req,mutex}; type Sys = record{pc1,pc2: PC; y1,y2: nat;}; pred req1(var Sys st,st’) = st.pc1=out & st’=st with {pc1:=req; y1:=st.y2+1;};

Note that the expression st’=st with { pc1 := req; y1 := st.y2 + 1;} expresses that st’ is obtained by updating the fields pc1 and y1 of st. We will use the FMona tool to express parameterized transition systems, abstraction relations, the synthesis of finite abstractions and the validation of their safety properties (mainly the so called always true properties).

3

The Formalism and the Basic Results

This section presents the formalism used: transition systems [Arn92]. We recall then the basic results concerning transition systems. The Coq proof assistant has been used to formalize the definitions and to validate the stated theorems. Notations Given a set S, its complement is denoted S. In the following, sets and predicates are identified. Given a relation ϕ ⊂ A × B and a subset P ⊂ A, we note ϕ(P ) = {y ∈ B | ∃x : P (x) ∧ ϕ(x, y)}. 3.1

Transition Systems, Refinements, Simulations and Implementations

Definition 2 A labeled transition system is defined by a quadruple (E, I, L, →), where E is a set of states, I ⊂ E is the set of initial states, L is a set of labels l and → ⊂ E × L × E is the transition relation. We will note e → e instead of (e, l, e ) ∈ →. Definition 3 (Invariance) A predicate P is invariant in the transition system S if: it is true over the initial states and is is preserved by each transition. A state s ∈ E is reachable in S if there exists a sequence s0 , . . . , sn = s such that s0 ∈ I and ∀i ∈ 0..n − 1 : si → si+1 . The set of reachable states of a


207

transition system S will be denoted Acc(S). A predicate P is said to be always true in S if it holds in all reachable states of S. This is denoted S ✷P . Theorem 1 (Sufficient condition for validity) An invariant property is always true. Within FMona, we define the macro reachable and always true as follows: pred reachable(type State, pred(var State s) init, pred(var State s,s’) tr, var State s) = ex array nat of State A: ex nat i: A[i]=s & init(A[0]) & all nat j where j < i: tr(A[j],A[j+1]); pred always true(type State, pred(var State s) p, pred(var State s) init, pred(var State s,s’) tr) = all State s: reachable(init,tr,s) ⇒ p(s);

Definition 4 (Refinement) Given two transition systems with the same set of labels L, C = (Ec , Ic , L, →c ) and A = (Ea , Ia , L, →a ), and ϕ ⊂ Ec × Ea . C refines A through ϕ, denoted C ϕ A, if: – ϕ maps each initial state of C to an initial state of A. l – Given two states c and c of Ec such that c → c and a state a ∈ Ea in relation with c through ϕ, there exists a state a ∈ Ea in relation with c such l that a → a . Definition 5 (Run) Given a transition system S = (E, I, L, →). A run is a relation ⇒ ∈ E × L∗ × E inductively defined as:

– e⇒e l l.a a – if e ⇒ e and e → e then e =⇒ e We define the set of finite traces T (S) of the system S as follows: l

T (S) = {l ∈ L∗ | ∃i ∈ I, e ∈ E : i ⇒ e}. Definition 6 (Simulation and implementation) Given two transition systems C and A. C simulates A through ϕ if for every state c of C reachable by a trace t, c has a ϕ image reachable in A by t. C implements A if the set of traces of C is a subset of the set of traces of A. Theorem 2 (Sufficient conditions) Refinement is a sufficient condition for simulation. Simulation is a sufficient condition for implementation. The validation of always true properties relies on the following theorems which state two equivalent sufficient conditions; the first one is expressed at the abstract level and the second one at the concrete level.

208


Theorem 3 (Always true properties preservation) Given two transition systems C and A such that C simulates A through ϕ. If the abstraction of P by ϕ (ϕ(P )) is always true over A, then P is always true over C. More formally, we have the two equivalent formulas: Csimulatesϕ A A ✷ϕ(P ) C ✷P 3.2

Csimulatesϕ A ϕ−1 (Acc(A)) ⇒ P C ✷P

(1)

Abstraction

The abstraction technique aims at verifying the properties of a transition system through the reduction of its state space: the original system is said concrete and the reduced one is said abstract. In fact, it can be considered as the reverse of the refinement technique where we derive a concrete system from an abstract one. The abstraction technique synthesizes an abstract system from the concrete one. Relevant properties are studied over the abstract system and inherited by the concrete one. This method has been used by [CGL94] to reduce the state explosion resulting from an exhaustive search over a finite state space. It is also used by [BLO98] for analyzing infinite state space systems. Given an abstraction function, they propose heuristics for the construction of the abstract system whereas in our approach the abstract system is built in an automatic way by the FMona tool. In the following, we recall the basic definitions and results. Definition 7 (Abstraction) Let C = (Ec , Ic , L, →c ) be a transition system, Ea a set of so called abstract states and ϕ a relation over Ec ×Ea . The abstraction of C through ϕ is the transition system (Ea , Ia , L, →a ) where Ia is the image l by ϕ of Ic and for each label l, →a is the set of images through ϕ of the pairs l connected by →c . It follows that the abstraction of a transition can be expressed by the generic and higher order FMona macro: pred tr a(type State c, type State a, pred(var State c c, c’) tr c, pred(var State c c, var State a a) ϕ, var State a a,a’) = ex State c c,c’: ϕ(c,a) & ϕ(c’,a’) & tr c(c,c’);

Theorem 4 (Refinements and abstractions) Let ϕ a total relation between two state spaces Ec and Ea . A transition system over Ec refines its abstraction through ϕ.

4

Automatic Validation through Abstraction

Let us recall that the abstraction introduced in the paragraph 3.2 consists in defining a finite reduced system starting from a concrete system, a finite state


209

space and a total relation known as the abstraction. It is the reverse of a refinement as the starting system is the concrete one. Moreover, for a refinement, the two transition systems are provided. One generally considers two approaches for the expression of properties to be validated: – the first one is based on states: a property is expressed as a temporal logic predicate over the state space (more exactly over the state variables defining the interface of the system). – the second one is based on transitions: we are interested in a simulation property between a concrete system and an abstract system (also called the reference system). In the following, we illustrate the abstraction method by considering the two approaches: to validate the mutual exclusion implemented by the bakery algorithm, we adopt a state based approach; to validate some classes of cache coherency protocols, we adopt the transition based approach. 4.1

Specification and Synthesis of the Abstract Transition System

The formulas defining the transitions of the abstract transition system, as introduced in definition 7, are quantified over the domain of the concrete space and thus are not propositional. It follows that the existence of a transition between two abstract states is not necessarily decidable. In order to be in a decidable context, we consider the framework of the WS1S logic for expressing: – the infinite or parameterized concrete state space (with first and second order variables), – the transitions of the concrete system, – the abstraction relation between the concrete and abstract systems. Thus, according to definition 7, an abstract transition is a WS1S predicate over two abstract variables. Consequently, the properties of an abstract system can – either be studied within the WS1S logic, which assumes the encoding of temporal logic operators in this formalism [Tho90]. Then, safety properties (which are inherited) can be expressed and automatically decided [ABP97]. – or be studied using a model checker as SMV [BCMD90]. Such a use requires the synthesis of a propositional expression of abstract transitions. Since this alternative resorts to a dedicated tool, it seems to be more efficient on the considered examples. The synthesis of the propositional expression can be performed through two methods: • by an exhaustive exploration of the abstract state space: the existence of a transition between two abstract states is determined by the validity of a closed WS1S formula (definition 7).

210


• by a symbolic reduction to propositional logic of an abstract transition expressed in WS1S. This reduction is possible within the Mona tool where the set of solutions of a predicate with free variables is encoded by an transition system whose transitions are labeled by propositional formulas. In this context the free variables are booleans and the automaton generated by Mona contains a unique transition. Let us illustrate the synthesis of the finite transition system over a trivial example. The state space of the concrete transition system is a finite set of naturals of unknown size, the concrete transition is defined by the predicate Initc (S) = (S = {0}) and the transition Trc (S, S ) = ∃1 x, y : y ∈ S ∧ S = S\{y}∪{x}. As an abstraction, we consider a state reduced to a unique boolean b, and the abstraction relation ϕ(S, b) = (b ⇔ ∀1 x, y : x ∈ S ∧y ∈ S ⇒ x = y). The abstract transition system is defined by the predicate Inita (b) = ∃2 S : Initc (S) ∧ ϕ(S, b) and the transition Tra (b, b ) = ∃2 S, S : ϕ(S, b) ∧ Trc (S, S ) ∧ ϕ(S , b ). The Mona tool can automatically simplify the previous monadic second order logic formulas to propositional formulas. Actually, we have synthesized the finite transition system defined by: Inita (b) = b and Tra (b, b ) = b ⇒ b . 4.2

Verification of Always True Properties

Given a total abstraction relation ϕ, the validation of a formula on the concrete transition system relies on the deduction rules of theorem 3. In this theorem, the abstract system is the abstraction through ϕ of the concrete system. By theorem 4, ϕ being total, the concrete system simulates its abstraction. Then, the rules (1) can be simplified as follows: Absϕ (C) ✷ϕ(P ) C ✷P

ϕ−1 (Acc(Absϕ (C))) ⇒ P C ✷P

Given these two rules, the validity of P is derived form the properties of the abstract transition system. Let us recall that the synthesis can be expressed in WS1S. Consequently, the two preceding rules give two decidable sufficient conditions. To summarize, given a user defined abstraction relation, we have two automatic verification methods: Method 1 1. Construction of the abstract transition system. 2. Construction of the reachable states Acc of the abstract transition system. 3. Definition of a superset of the reachable states of the concrete transition system as the inverse image by ϕ of Acc. 4. At the concrete level, we show that ϕ−1 (Acc) ⇒ P . Note that the term ϕ−1 (Acc) can be interpreted as a lemma automatically proven through an exhaustive exploration of the abstract state space. This lemma helps in the validation of P .


211

Method 2 1. Construction of the abstract transition system. 2. Computation of the abstraction of P : ϕ(P ). 3. Verification of this abstraction over the reachable states of the abstract transition system. Since the abstract state space is finite, this verification can be performed by a model checker like SMV. This second method uses a dedicated tool for the verification of always true properties. 4.3

Validation of Simulation Relations

The goal is to determine the existence of a simulation relation between a concrete system and a reference system. For that, we provide a projection of the concrete space to the state space of reference and a total abstraction relation. Then, we show that the restriction of the concrete system to some superset of its reachable states refines the reference system. Thus, given a user defined projection π and a total abstraction relation ϕabs , the construction of the simulation relation automatically proceeds according to the following steps: 1. Construction of the abstract transition system (WS1S): the concrete system refines the abstract system. 2. Construction of the accessible states Acc of the abstract transition system (WS1S). 3. Restriction of the concrete transition system to the reverse image of the accessible states of its abstraction. 4. Validation of the refinement between the reduced concrete transition system and the reference system (WS1S formula). 4.4

Abstraction Heuristics

To reduce parameterized or infinite data structures, we apply the heuristics presented in the following paragraph. The abstraction function associates with a parameterized or infinite type a finite approximation. We consider three classes of types: integer types, arrays with opaque1 index and finite values, arrays with natural index and finite value, and arrays with opaque index and values. We have considered the following abstractions which can be expressed in WS1S: 1. We associate with natural state space variables a family of boolean variables coding the comparisons between these variables or the variables and the constants of the problem. Notice that this heuristics is in fact the one used in an automatic way by [Les97]. 1

An opaque type supports only the assignment and comparison operations.

212


2. We associate with an array with opaque index and finite values within the set {x1 , . . . , xn } a family of bounded counters {c1 , . . . , cn } with value in the set {0, . . . , k, +}. A counter Ci indicates the number of indexes with value xi . This enumeration being bounded by k, a higher number of occurrences is denoted +. 3. We associate with an array t with natural index and finite values the number of alternations t(i) = t(i − 1), counted in the finite set {0, . . . , k, +}. 4. We associate with an array with opaque index and values the number of different values in the array, counted in the finite set {0, . . . , k, +}. Notice that the heuristics we present relate to the construction of an abstraction function, the abstract transition system being automatically built and validated by the FMona tool for the considered class of problems. On the other hand, [BLO98] supposes the existence of an abstraction function and proposes heuristics for the construction of the abstract system.

5

Application to the Bakery Mutual Exclusion Protocol

The transition system of the Bakery mutual exclusion algorithm over two processes is described in FMona by the following code. Its state space contains two finite-typed variables pc1 and pc2 and two naturals y1 and y2. The state space is thus infinite. type PC = {out,req,mutex}; type Sys = record{pc1,pc2: PC; y1,y2: nat;}; pred Init(var Sys st)= st.pc1=out & st.pc2=out & st.y1=0 & st.y2=0; pred req1(var Sys st,st’)= st.pc1=out & st’=st with {pc1:=req; y1:=st.y2+1;}; pred req2(var Sys st,st’)= st.pc2=out & st’=st with {pc2:=req; y2:=st.y1+1;}; pred enter1(var Sys st,st’)= st.pc1=req & (st.y2=0 | st.y1≤st.y2) & st’=st with{pc1:=mutex;}; pred enter2(var Sys st,st’)= st.pc2=req & (st.y1=0 | st.y2<st.y1) & st’=st with{pc2:=mutex;}; pred leave1(var Sys st,st’)= st.pc1=mutex & st’=st with {pc1:=out; y1:=0;}; pred leave2(var Sys st,st’)= st.pc2=mutex & st’=st with {pc2:=out; y2:=0;};

We notice that it is not possible to bound the natural variables y1 and y2. Actually, when considering the execution sequence r1 (e1 r2 l1 e2 r1 l2 )∗ , the sequence r1 (e1 r2 l1 e2 r1 l2 )k of (y1,y2) values is (0, 0)−− −−−−−−−−−−→(2k + 1, 0) where r, e, l respectively abbreviate req,enter,leave. We seek to establish that the mutual exclusion property is always true: pred excl(var Sys st) = ∼(st.pc1 = mutex & st.pc2 = mutex);


213

The predicate excl is not an invariant. Actually, it is not preserved by enter1. However, as shown in the following, it is always true, i.e., true in any reachable state. In order to get a finite state space, the fields pc1 and pc2 being finite, it is enough to abstract the fields y1 and y2. We consider the abstraction which consists in coding the comparisons between these two fields. Then, we get the abstract system Sys a and the abstraction relation ϕ defined as follows: type Cmp = {z1z2,z1,z2,inf12,inf21,eq}; type Sys a = record{pc1,pc2: PC; y1y2: Cmp;}; pred ϕ(var Sys st, var Sys a a) = a.pc1 = st.pc1 & a.pc2 = st.pc2 & if st.y1 = 0 & st.y2 = 0 then a.y1y2 = z1z2 elsif st.y1 = 0 then a.y1y2 = z1 elsif st.y2 = 0 then a.y1y2 = z2 elsif st.y1 < st.y2 then a.y1y2 = inf12 elsif st.y2 < st.y1 then a.y1y2 = inf21 else a.y1y2 = eq endif;

The relation ϕ being total, according to theorem 4, the Bakery transition system refines its abstraction through ϕ. The abstraction through ϕ of the Bakery system, computed by FMona, is a finite state system of which transitions can be expressed using WS1S and reduced to propositional logic using Mona. Consequently, the computation of the reachable states is possible. Mona validates that any state reachable by this transition system cannot be the image of a state where two processes would not be in mutual exclusion. The following logical formula (extracted from the transition system produced by Mona) encodes the set of reachable states of the abstract system: ∨ ∨ ∨ ∨ ∨ ∨ ∨ ∨

st1 st1 st1 st1 st1 st1 st1 st1 st1

= = = = = = = = =

idle ∧ st2 = idle ∧ cmp = z1z2 idle ∧ st2 = req ∧ cmp = z2 idle ∧ st2 = mutex ∧ cmp = z2 req ∧ st2 = idle ∧ cmp = z1 req ∧ st2 = req ∧ cmp = inf12 req ∧ st2 = req ∧ cmp = inf21 req ∧ st2 = mutex ∧ cmp = inf21 ∧ cmp = z1 mutex ∧ st2 = idle ∧ cmp = inf12 mutex ∧ st2 = req

(∗ (∗ (∗ (∗ (∗ (∗ (∗ (∗ (∗

0 0 0 0 0 0 0 0 0

= = = = < < < =
0 iff [x, y] ∈ F (the arc multiplicities), and m0 is a state, i.e. a mapping m0 : P −→ N. 1

throughout the paper, we use the term low level for the symmetry approach to place/transition nets, i.e. Petri nets with unstructured, uniform tokens. In contrast, high level symmetries rely on the ability to use data specific terms for symbolic description of symmetries.

Integrating Low Level Symmetries into Reachability Analysis

317

Throughout the paper, we assume that places and transitions are totally ordered. For a place or transition x, •x = {y | [y, x] ∈ F } denotes the pre–set of x, and x• = {y | [x, y] ∈ F } denotes its post–set. Definition 2 (Transition relation). We say that t can fire at a state m yielding state m (written: m@ > t >> m ) iff for all p ∈ P , m(p) ≥ W ([p, t]) and m (p) = m(p) − W ([p, t]) + W ([t, p]). If, for a given state m and transition t there exists a state m such that m@ > t >> m , then we say that t is enabled at m. We extend the transition relation to sequences of transitions. Define m@ > e >> m for an arbitrary m and the empty sequence e, and m@ > wt >> m (w being a transition sequence and t a transition) iff there is an m∗ such that m@ > w >> m∗ and m∗ @ > t >> m . If there is a transition sequence w such that m@ > w >> m , we write m@ > ∗ >> m . Definition 3 (Reachability graph). A directed labeled graph is the reachability graph of a Petri net N = [P, T, F, W, m0 ] iff its set of vertices is the set of all reachable states, i.e. {m | m0 @ > ∗ >> m}, and [m, m ] is an edge labeled with t iff m@ > t >> m .

3

Graph Automorphisms

Consider a directed graph [V, E] (with a finite set V of vertices and a set E ⊆ V × V of edges) together with a mapping φ : V ∪ E −→ C that assigns a color of a set C to every graph element. Definition 4 (Graph automorphism). A graph automorphism is a bijection σ : V → V of the vertices of a directed colored graph that respects adjacency and coloring, i.e. – e = [x, y] ∈ E iff σ(e) = [σ(x), σ(y)] ∈ E; – φ(σ(z)) = φ(z) for z ∈ V ∪ E. The set of all automorphisms of a graph forms a group under composition and inversion. The identity is always an automorphism and serves as neutral element of the group. For the remainder of this section, consider an arbitrary graph and its automorphism group. There can be exponentially many automorphisms. |−1) elements for the However, there is always a generating set of at most |V |·(|V 2 whole automorphism group. In the sequel we consider a rather well formed generating set that enjoys a regular structure though it is not necessarily of minimal size. The algorithm proposed in [Sch97] returns a generating set as described below. Assume a total ordering of V , i.e. V = {v1 , . . . , vn }. A well formed generating set G for all graph automorphisms consists of |V | families G1 , . . . , G|V | . If, for i ∈ {1, . . . , |V |} and j ∈ {i, . . . , |V |}, there exist automorphisms σ such that σ(v1 ) = v1 , . . . , σ(vi−1 ) = vi−1 and σ(vi ) = vj then family Gi contains exactly one of them. In other words, the elements of family Gi are equal to the identity on all vertices smaller than vi and cover all possible images of vi .

318

Karsten Schmidt 3

4

2

1

7

8

5

6

Fig. 1. 3 dimensional grid

Example 1. Consider the graph depicted in Fig. 1. Every drawn line between two vertices x and y corresponds to a pair [x, y] and [y, x] of edges. Table 1 lists a generating set for the 48 graph automorphisms that fits to the rules above. The generating set is not minimal. For instance, σ2 = σ1 ◦ σ1 .

Table 1. Generating set of the grid automorphisms Argument 1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8 id

2 3 4 1 6 7 8 5 σ1

Family 3 4 5 4 1 1 1 2 4 2 3 8 7 8 6 8 5 2 5 6 3 6 7 7 σ2 σ3 σ4

1 6 5 8 7 2 1 4 3 σ5

Images Family 2 7 8 1 1 1 8 7 2 4 5 5 6 3 8 6 6 5 4 5 2 3 4 5 2 4 4 3 6 3 8 1 2 7 7 7 2 1 8 6 3 σ6 σ7 id σ8 σ9

Family 3 1 1 2 2 3 6 4 5 5 4 6 3 7 7 8 8 id σ10

Proposition 1 (Generating set). Every set of automorphisms that fits to the rules described above is a generating set for all automorphisms. In particular, every automorphism can be represented as the composition σ1 ◦ · · · ◦ σ|V | where σi belongs to family Gi of the generating set. Proposition 2 (Non–repetition). If for all i, σi and τi are members of family Gi of a generating set as described above, then σ1 ◦ · · · ◦ σn = τ1 ◦ · · · ◦ τn implies σ1 = τ1 , . . . , σn = τn . These two propositions state that every automorphism can be generated in exactly one way as the composition of one member per family of the generating set. As a corollary, the product of the sizes of the families yields the size of the automorphism group. For instance, our grid has 8 · 3 · 2 = 48 automorphisms.


319

Rotation groups (automorphism groups of ring–like graphs) have a generating set consisting of one family, permutation groups (symmetry groups of clique– like graphs) have generating sets where the size of subsequent families of the generating set decreases by one.

4

Petri Net Symmetries

A Petri net N = [P, T, F, W, m0 ] can be regarded as colored graph with V = P ∪ T , E = F , φ(p) = place for p ∈ P , φ(t) = transition for t ∈ T , and φ(f ) = W (f ) for f ∈ F . Definition 5 (Symmetry). A Petri net symmetry is an automorphism of the underlying colored graph. We denote the symmetry group of a Petri net by Σ. A symmetry group Σ induces equivalence relations on the Petri net vertices as well as on the states. Definition 6 (Equivalence of vertices/states). Two vertices x and y in P ∪ T are equivalent with respect to Σ (x ∼Σ y) iff there is a σ ∈ Σ such that σ(x) = y. For a state m, let σ(m) be the state satisfying, for all x ∈ P ∪ T , σ(m)(σ(x)) = m(x). A state m1 is equivalent to a state m2 with respect to Σ (m1 ∼Σ m2 ) iff there is a σ ∈ Σ such that σ(m1 ) = m2 . ∼Σ is an equivalence relation. We denote the ∼Σ equivalence class containing some state m by [m]Σ .

5

The Integration Problem

During generation of the reduced reachability graph, we want to merge equivalent states. As soon as a new state m is generated, we compare it against the set of already existing states M . If, among those states, there is one equivalent to m, we do not store m. Instead, we redirect all arcs to m to the equivalent state. Thus, the problem we are confronted with (and which we call the integration problem) is: Given a symmetry group Σ, a set M of states, and a state m, decide whether there exist an m ∈ M and a σ ∈ Σ such that σ(m) = m ; in the case that such an m exists, return m . Here, Σ is given by a well formed generating set. M is the set of already calculated states and is usually organized as a search structure (tree, hash table or whatsoever). We study three approaches to the integration problem. The first two procedures implement one of the existential quantifiers appearing in the integration problem as a loop. The third method implements the canonical representative method to low level Petri nets.

320

6

Karsten Schmidt

Iterating the Symmetries

The integration problem quantifies a symmetry existentially. If we implement this quantification as a loop on all symmetries, we obtain the following brute force solution: FOR ALL σ ∈ Σ DO IF σ −1 (m) ∈ M THEN RETURN yes; END; END; RETURN no; The test σ −1 (m) ∈ R is a standard operation on sets of states and can be efficiently implemented. So the costs of the procedure depend on the number of iterations of the outer loop which is, in the worst case (the case where m is not in M ), equal to the size of the symmetry group. Due to the up to exponential size of symmetry groups, this approach does not work well. However, using decision trees for storing the states in M enables a nice reduction concerning the number of loops. A decision tree treats states as strings and merges common prefixes. Fig. 2 depicts a decision tree storing the set {(1, 0, 0), (1, 0, 1), (1, 2, 2), (1, 3, 1)}. If we find σ −1 (m) in the decision tree, we exit the loop. Otherwise, there is some prefix 1 of σ −1 (m) that is not contained in the tree and the length i of this prefix is available through the search process. This means that 3 0 2 any other state with the same prefix is not contained in M as well. However, the σ −1 – image of m on the first i places is determined 1 2 by the generators of the first i families of 0 1 the generating set. That is, every symmetry that is composed of the same elements of the first i families as σ, but different elements of Fig. 2. Decision tree the last |P | − i families of the generating set, yields the same i–prefix as σ −1 (m) and is consequently not contained in M . Using this observation, we can skip all such combinations of generators and continue with one where at least one of the first i ones is different. This method reduces significantly the number of iterations of the outer loop in the above code fragment. Having implemented this iteration, we found out that the loop reduction was powerful enough to make reduced graph generation faster than complete iteration even if complete iteration runs on an explicitly stored list of all symmetries (i.e. re–initialization of the loop is just a jump to the next list element instead of composing a symmetry from generators). The current version of INA uses the generating set and the described loop reduction. Older versions of INA maintain


321

an explicit list of all symmetries. The algorithm works quite well if the symmetry group is sparse. Unfortunately, larger symmetry groups require still too many iterations of the symmetry loop and graph generation tends to fail. Therefore, we need other integration technologies.

7

Iterating the States

In this section, we develop another solution of the integration problem where the outer loop iterates on states. The principal solution is: FOR ALL m ∈ M DO IF ∃σ : σ(m) = m THEN RETURN yes; END; END; RETURN no; For the test ∃σ : σ(m) = m we do not need to iterate the symmetries. The algorithm in [Sch97], otherwise used to compute the generating set, can as well be customized such that it computes a symmetry mapping m to m (or recognize that such a symmetry does not exist). Of course, iterating all states in the outer loop is unacceptable, since there are usually too many of them. Fortunately, the number of iterations can be reduced significantly when symmetry respecting hash functions are used (the use of hash functions has already been studied in [HJJJ84]). A hash function assigns an index h(m) from a finite index set I to every state m. This way, the set of states M can be partitioned into card(I) classes where two states are in the same class iff they have the same hash value. Simple hash techniques store each hash class separately such that other search techniques need to be applied only to the (hopefully small) hash classes rather than to the complete set of states. Symmetry respecting hash functions assign equal hash values to equivalent states. Using such a function h, it is sufficient to iterate the subset of M corresponding to h(m) rather than the whole M . As a simple way to get a symmetry respecting hash function, one can use a weighted sum of component values. For this purpose, one assigns a number cp to each place p and sets h(m) = mod k where k is the p∈P cp · m(p) size of the hash table. In order to make this function symmetry respecting, one guarantees cp = cp for all equivalent places. The equivalence relation for places can be efficiently deduced from the generating set without iterating all symmetries. In fact, it is sufficient to start with a family of singleton sets {{p} | p ∈ P } and then to build repeatedly the union of the set containing p with the set containing σ(p) (for all p ∈ P and all σ of the generating set). This task can be efficiently done by Tarjan’s union/find algorithm [Tar75] and produces directly the equivalence classes. The implementation used for computing the examples at the end of the paper uses weighted component sums as hash function where

322

Karsten Schmidt

the cp are otherwise randomly chosen. Random choice appears to spread hash values well enough. The proposed method depends on the number of states in M that share the same hash value. Besides the general uncertainties of hash functions, there are general problems with symmetry respecting hash functions for sparse symmetry groups. Consider Fig. 3 and assume that (maybe by some additional hidden net structure) the rotations along the ring are the only symmetries.

p1

p8

p2

t1

q1

t8

t2 q2

q8

p7

p3

q3

q7

t3

t7

q6

q4 q5 t4

t6

p4 t5 p6 p5

Fig. 3. Difficult situation for symmetry respecting hash functions In this net, for every pair of outer places there is a symmetry mapping one to another. The same holds for inner places. However, there is no symmetry mapping an outer place to an inner place. Therefore, a hash function following our proposal assigns some weight co to all outer places and some weight ci to all inner places. Consequently, the best symmetry respecting hash function would produce at most 9 different used hash values for the 36 states of the symmetrically reduced reachability graph of this net (the hash value depends only on how many inner places are marked, but equivalence depends on the distances between two marked inner places). In a ring of the same kind but length 20, the 52488 states of the reduced graph would share only 21 different n values of any symmetry respecting hash function (in general, at least 2n states share at most n + 1 hash values). A situation as described above is typical for all rotation–like symmetry groups. Fortunately, this effect is due to the low number of symmetries (where the integration method of the previous section behaves well). If we use all permutations between the pi (and corresponding mappings on the ti and qi ) as symmetry group of the system depicted in Fig. 3, the problem does not appear since those states that share the same hash value become equivalent. Thus, the reduced reachability graph contains only one of them. Assigning, for example,


323

weight 1 to the pi and weight 2 to the qi , we get 9 different hash values for the 9 states of the reduced reachability graph (in general, n values for n states). Thus, iterating the states of a hash class is a method for integrating symmetries that displays its best behavior with large symmetry groups. This complements the behavior of the method discussed in the previous section.

8

Canonical Representatives

This version of symmetry integration is inspired by [HJJJ84,ID96,CEFJ96]. The vector representation of states induces a (lexicographical) order between states: Let m < m iff there is a place p such that for for all places q (q < p), one has m(q) = m (q) while m(p) < m (p). Given this order, every equivalence class of states with respect to the symmetry has a least element, called the canonical representative. In the version of the integration problem we want to discuss now, only canonical representatives are added to M . Then, deciding the integration problem consists of transforming the new state m into its canonical representative m and checking whether m is contained in M . So, the transformation of arbitrary states into canonical representatives is the bottleneck of this method. Efficient solutions of the problem are restricted to few classes of symmetry groups (such as rotation or permutation groups). The brute force implementation in absence of a symbolic description of the symmetries would be to iterate all symmetries and to compare their images of the given m. This is, however, not appropriate here since this method would not work at all for larger groups. Therefore, we try once more to benefit from the structure of the generating set introduced in Sect. 3, in particular from the fact that elements of larger families do not change values on the first places. Thus, we could try the following procedure to transform states (σij is the j–th member of family Gi of the generating set, #i is the size of family Gi ): PROCEDURE transform(m:state): state: VAR globalmin,localmin: state; i,j:Nat; BEGIN globalmin := m; FOR i := 1 TO n DO (* for all families *) localmin := globalmin; FOR j := 1 TO n DO IF σij (globalmin) < localmin THEN localmin := σij (globalmin); END END globalmin := localmin; END RETURN globalmin; END.

324

Karsten Schmidt

This procedure has the advantage that it works in polynomial time in the size of the net. It has, however, one big disadvantage: it does not always produce canonical representatives! For an example, consider the grid example of Sect. 3. Assume for the purpose of simplicity that all vertices of the grid are places and transform the state m = (1, 2, 2, 3, 3, 2, 1, 3). In the first family, only the identity and σ6 produce 1 on the first place. σ6 (m) = (1, 3, 3, 2, 2, 3, 1, 2). Thus, the minimal state produced by the first family is the state itself. In the second family, both σ8 and σ9 would produce 3 on the third place, thus m itself remains the minimal state. In the third family, σ10 does not change the state. Therefore the transform procedure would return m itself. However, applying σ9 to σ6 (m) leads to (1, 2, 2, 2, 3, 3, 1, 3) which is smaller than m. Thus, the procedure does not always return canonical representatives. The way to the global minimum does not always lead via the minima at the intermediate steps of the algorithm. The problem is limited to symmetry groups other than rotation and permutation groups. For rotation groups, we have a generating set consisting of a single family containing all symmetries. Thus, no symmetry is forgotten. For full permutation groups, the transform procedure performs a real sorting on the state. Thus, the global minimum is returned. There are two ways out of the problem of non–minimality. The first one would be to replace the above transform procedure by one returning the actual canonical representative. However, the complexity of this problem is closely related to deciding graph isomorphism [CEFJ96,ES96] and therefore it is unlikely that there is a polynomial solution at all. Therefore we tried the other way which is to study which problems arise from non–unique representatives. The first observation is that a reduced graph using non–unique representatives can contain more than one element of some equivalence classes. Thus, the reduced graph is larger than a perfectly reduced one (i.e. one that contains exactly one representative per reachable class). On the other hand, most global properties do not depend on perfect reduction. In particular, the proof rules described in [Jen95] for boundedness, liveness, reversibility and other properties as well as model checking using formula respecting symmetries [ES96] are still valid. On the other hand, checking reachability of a given state m∗ against a reduced reachability graph might be dangerous. It can happen that the transformed image of m∗ is different from all representatives of its equivalence class in the reduced state space. Thus, not finding the image of m∗ in M does not yet mean that the equivalence class of m∗ is not represented in M . The problem can be circumvented in the following way: use the canonical representative method for generating the graph, but use one of the other methods to check reachability. This compromise should work well as long as only some states are to be tested for reachability.

9

Experiments

We have implemented all three methods in a new reachability oriented Petri net tool called LoLA (Low Level Analyzer). So reduced and full graph generation share the same code for all tasks not depending on the integration method.


325

ItSymm corresponds to the iteration of symmetries (Sect. 6), ItState to the iteration of states (Sect.7), and CanRep to the canonical representative method of Sect. 8. Times have been taken on a LINUX PC with 64MB RAM and a 400MHz Pentium processor. The times are written as <minutes>:<seconds>. We used a hash table of size 65536. The first three tables show the behavior of symmetric reduction for different kinds of symmetry groups. We demonstrate the reduction in space, compared with full graph generation and give an impression concerning the running time. Furthermore we provide experimental evidence for the run time predictions we derived in the theoretical sections. There, we expected ItSymm to be fast on sparse groups but slow on large groups, we expected ItStates to be slow on sparse, but acceptable on large groups, and we expected CanRep to be fast anyway but to produce larger graphs. For these goals, small examples should be sufficient. The first table concerns a deadlocking version of the n dining philosophers example. This is an example of a ring–like agents network.

Table 2. Results for the dining philosophers

Places Transitions States in full graph Edges in full graph Hash entries in full graph Time for full graph Symmetries States in red. graph Edges in red. graph nonempty hash classes in red. graph time for ItSymm time for ItState time for CanRep

number of phil. 5 10 13 25 50 65 20 40 52 242 59048 313 − 1 805 393650 ? 242 38048 ? 0:00.085 0:05.9 ? 5 10 13 50 5933 122642 165 39550 1062893 20 65 104 0:00.077 0:02 1:38 0:00.22 11:31 ? 0:00.077 0:01.1 0:33.5

The symmetry group is a rotation–like group. Thus, we would store all symmetries explicitly as our generating set. They are organized in a single family. Therefore, the canonical representative method must yield full reduction. The times of iteration of states and canonical representatives are acceptable. The long time for the iteration of states is due to the hashing problem discussed in Sect. 7 and makes the method unacceptable for this kind of net. Though the times for the reduced graphs include the calculation of the symmetries, they are smaller than the corresponding full graph generation. Note that the number of

326

Karsten Schmidt

instances of the integration problem to be solved corresponds to the number of edges of the reduced graph. The second example is a data access scheme where r readers can access some data concurrently while w writers access it in mutual exclusion (and excluded from the readers). The readers are not distinguishable from each other and the writers are not distinguishable from each other. Thus, the symmetry group is close to full permutation.

Table 3. Results for the data access scheme readers / writers 5/5 13/13 20/20 40/40 Places 31 79 121 241 Transitions 25 65 100 200 States in full graph 217 114857 21 · (220 + 20) 41 · (240 + 40) Edges in full graph 770 905554 ? ? Hash entries in full graph 217 54952 ? ? Time for full graph 0:00.1 2:54 ? ? Generators of Symm. 20 156 380 1560 Families of gen. set 8 24 38 78 Symmetries 14400 13! · 13! 20! · 20! 40! · 40! States in red. graph 14 30 44 84 Edges in red. graph 82 470 1072 4142 nonempty hash classes in red. 14 30 44 84 graph time for ItSymm 0:00.64 > 60:00 ? ? time for ItState 0:00.2 0:05.8 0:33 9:44 time for CanRep 0:00.084 0:00.4 0:01.7 0:34 States generated by CanRep 17 41 62 122 Edges generated by CanRep 85 481 1090 4180

For this system, iteration of symmetries fails due to the huge number of symmetries even in cases where the full graph can be generated without problems. Iteration of states works for this system though it cannot reach the speed of iterating the symmetries for a rotation symmetry group. However, compared to the time needed for the complete graph we can be satisfied with the result. Observe that the number of used hash entries shows that every instance of the integration problem involves at most one attempt to calculate a symmetry. The fastest method is once more the canonical representative approach. However, the example shows that it produces slightly larger graphs. This is due to the interlacing of two permutation groups. This problem could be avoided by rearranging the order of places which would require knowing the symmetries in advance; but that is not the intended application area of the low level Petri net method. However, the advantage with respect to time could justify a few more states. Again, one


327

of the perfectly reducing methods and the canonical representative method were able to outperform the full graph generation. The third example is designed to study the behavior of our procedures on grid–like networks. For this purpose we arranged several identical agents in a grid network. The agents have two states. The second state can only be entered in mutual exclusion to the direct neighbors, controlled by a set of semaphores. We vary the number of dimensions of the grid and the number of agents per row (our running example would have dimension 3 and two agents per row).

Table 4. Results for the grid network dimensions / agents per row 2/5 3/3 4/2 5/2 Places 75 81 48 96 Transitions 50 54 32 64 States of full graph 55447 70633 734 ? Edges of full graph 688478 897594 5664 ? Time for full graph 0: 10 0:15 0:00.18 ? Generators 4 10 21 41 Nontrivial families 2 3 4 5 Symmetries 8 48 384 3840 States of red. graph 7615 2352 21 332 Edges of red. graph 94850 29912 172 4937 nonempty hash entries of red. 192 106 9 17 graph Time for ItSymm 0:03.8 0:03.7 0:00.18 0:26.6 Time for ItState 12:29 4:38 0:00.72 1:20 Time for CanRep 0:04.7 0:04.9 0:00.15 0:27 States gen. by CanRep 15138 10832 29 3032 Edges gen. by CanRep 188706 137345 234 44650

For this example, the a lot of symmetries can be skipped during the iteration of symmetries in ItSymm, so ItSymm is even able to outperform the canonical representative method (which has, in addition, the disadvantage of generating more states). The grid symmetries can be considered as a sparse symmetry group, which explains the bad behavior of ItState. The reason for the slow ItState can be found in the small number of used hash classes compared with the large number of states. The grid example demonstrates the benefits of using low level net symmetries on non–standard symmetry groups. In the 3–dimensional case we have 48 symmetries. The size of the reduced graph is approximately 30 times smaller than the full one. Since every equivalence class of reachable states should appear in the reduced graph, and the size of an equivalence class is bounded by the number of symmetries, a reduced graph can never be smaller than the size of the full

328

Karsten Schmidt

graph divided by the number of symmetries. As outlined in [CFG94,CDFH90], the symbolic symmetry approach based on rotation and permutation groups considers only a rotation (sub-)group of grid structures that consists only of four symmetries. Thus, instead of a reduction factor 30, a reduction factor smaller than 4 is achieved. The symmetry approach has been criticized for its lack of practical feasibility. Extrapolation of the previous tables to larger examples supports this criticism. In particular, sparse symmetry groups do not yield sufficient reduction to keep pace with the growth of the reachability graph. However, things look different if we take into consideration that symmetries can be applied jointly with several other reduction techniques, for instance the stubborn set method [Val88]. Benefits of combined application have been reported earlier [Val91,DBDS93,EJP97]. We report results for our particular symmetry approach. Applying symmetries alone leads to memory overflow on all reported instances, not to mention full graphs.

Table 5. Stubborn sets versus stubborn sets with symmetries (for the dining philosophers)

Places Transitions States in full graph Symmetries States in symm./stubb. red. graph Edges in symm./stubb. red. graph time for ItSymm+ stubborn States in stubb. red. graph Edges in stubb. red. graph Time for stubb. red. graph

number of phil. 100 200 300 900 500 1000 1500 4500 400 800 1200 3200 3100 − 1 3200 − 1 3300 − 1 3900 − 1 100 200 300 900 299 599 899 2699 496 996 1496 4496 0:02 0:10 0:26 7: 00 29702 119402 overflow 39700 159400 0:05 1:08 -

In the grid example, stubborn sets do not reduce the number of states. Concerning the data access scheme (40 readers/40 writers), stubborn sets produce 121 states while combined application of stubborn sets and symmetries leads to 4 states, independently of the number of readers and writers.

10

Conclusion

We have presented three solutions of the integration problem (deciding whether for the current state there is a symmetrical one in the set of already computed states). All methods have their advantages and disadvantages. The advantage of the iteration of symmetries and iteration of states is that they yield a completely reduced graph. Unfortunately they work well only on sparse (iteration


329

of symmetries) or large (iteration of states) symmetry groups. The canonical representative method is the fastest method that works for all kind of symmetries, but it often produces more than one representative for some equivalence classes of states. The canonical representative method cannot be used for testing the reachability of states. This problem can be repaired by using one of the other method for testing the reachability on a graph produced by the canonical representative method. With the set of methods presented in this paper, low level symmetries are no longer a restricting factor for reduced reachability graph generation. In most cases, the remaining size of the reduced graph limited the analysis. This in turn is due to the limitation of the symmetry approach as it and not due to its low level version (low level symmetries do not produce larger graphs than high level (symbolic) symmetries). In connection with other reduction techniques (such as stubborn sets), much larger systems can be analyzed than using either method in isolation. The easy use of maximal symmetry groups other than rotation and permutation groups is another argument in favor of the low level symmetry approach.

References CDFH90. G. Chiola, C. Dutheillet, G. Franceschinis, and S. Haddad. On well–formed colored nets and their symbolic reachability graph. Proc. of the 11th Int. Conf. on Application and Theory of Petri Nets, pages 387–410, 1990. 315, 328 CEFJ96. E.M. Clarke, R. Enders, T. Filkorn, and S. Jha. Exploiting symmetry in temporal logic model checking. Formal Methods in System Design 9, pages 77–104, 1996. 315, 316, 323, 324 CFG94. G. Chiola, G. Franceschinis, and R. Gaeta. Modelling symmetric computer architectures by swn’s. Proc. 15th Int. Conf. on Application and Theory of Petri Nets, LNCS 815, pages 139–158, 1994. 315, 328 Chi98. G. Chiola. Manual and automatic exploitation of symmetries in spn models. Proc. 19th International Conference on Application and Theory of Petri nets, LNCS 1420, pages 28–43, 1998. 315 DBDS93. S. Duri, U. Buy, R. Devarapalli, and S. Shatz. Using state space methods for deadlock analysis in ada tasking. ACM Proc. Int. Symp. on Software Testing and Analysis, pages 51–60, 1993. 328 EJP97. E.A. Emerson, S. Jha, and D. Peled. Combining partial order and symmetry reductions. Proc. TACAS ’97, LNCS 1217, pages 19–34, 1997. 328 ES96. E.A. Emerson and A.P. Sistla. Symmetry and model checking. Formal Methods in System Design 9, pages 105–131, 1996. 315, 324 HJJJ84. Huber, A. Jensen, Jepsen, and K. Jensen. Towards reachability trees for high–level petri nets. In Advances in Petri Nets 1984, Lecture Notes on Computer Science 188, pages 215–233, 1984. 315, 321, 323 ID96. C.N. Ip and D.L. Dill. Better verification through symmetry. Formal Methods in System Design 9, pages 41–75, 1996. 315, 316, 323 Jen92. K. Jensen. Coloured Petri Nets, volume 1 of EATCS Monographs on Theoretical Computer Science. Springer, 1992. 315

330 Jen95. Jun98.

RS97.

Sch97. Sta91. Tar75. Val88.

Val91.

Karsten Schmidt K. Jensen. Coloured Petri Nets Vol. 2: Analysis Methods. Springer, 1995. 324 T. Junttila. Towards well-formed algebraic system nets. Workshop CSP’98 Berlin, Technical Report 110, Humboldt–University Berlin, pages 116–127, 1998. 315 S. Roch and P. Starke. INA – Integrierter Netz–Analysator Version 1.7. Handbuch. Humboldt–University Berlin, Institute of Computer Science, 1997. 316 K. Schmidt. How to calculate symmetries of petri nets. To appear in Acta Informatica. 316, 317, 321 P. Starke. Reachability analysis of petri nets using symmetries. J. Syst. Anal. Model. Simul., 8:294–303, 1991. 315, 316 R.E. Tarjan. Efficiency ofa good but not linear set union algorithm. Journal of the ACM 22(2), pages 215–225, 1975. 321 A. Valmari. Error detection by reduced reachability graph generation. Proc. of the 9th European Workshop on Application and Theory of Petri Nets, Venice, 1988. 328 A. Valmari. Stubborn sets for coloured petri nets. In The Proceedings of the 12th International Conference on Application and Theory of Petri Nets, pages 102–121, 1991. 328

Model Checking Support for the ASM High-Level Language Giuseppe Del Castillo1 and Kirsten Winter2 1

Heinz Nixdorf Institut, Universit¨ at-GH Paderborn F¨ urstenallee 11, D-33102 Paderborn, Germany [email protected] 2 GMD FIRST Kekuléstr.7, D-12489 Berlin, Germany [email protected]

Abstract Gurevich’s Abstract State Machines (ASM) constitute a highlevel specification language for a wide range of applications. The existing tool support for ASM–currently including type-checking, simulation and debugging–should be extended to support computer-aided verification, in particular by model checking. In this paper we introduce an interface from our existing tool environment to the model checker SMV, based on a transformation which maps a large subset of ASM into the SMV language. Through a case study we show how the proposed approach can ease the validation process.

1

Introduction

Gurevich’s Abstract State Machines (ASM) [7] constitute a simple but powerful method for specifying and modeling software and hardware systems. Existing case studies include specifications of distributed protocols, architectures, embedded systems, programming languages, etc. (see [1] and [8]). The advantage of ASMs is in the simple language and its intuitive understanding. The method is based on general mathematics which allows to naturally model systems on a suitable level of abstraction. Traditionally, the verification task is done by means of hand-written mathematical proofs. Tool support for the verification process is obviously needed for a broader acceptance. Our contribution to this task is the development of an interface between the ASM Workbench [2] and the SMV model checker [11]. The ASM Workbench is a tool environment, based on a typed version of ASM, which includes a type checker and a simulator for ASMs. SMV has been chosen as a typical representative of a class of model checkers based on transition systems and could be easily replaced by any other similar model checker, e.g., SVE [5] or VIS [6]. On the other hand our transformation tool supplies SMV with a higher level modeling language, namely ASMs. This facilitates the specification task by allowing the use of more complex data types and of n-ary dynamic functions for

Partially supported by the DFG Schwerpunktprogramm “Softwarespezifikation”.


332

Giuseppe Del Castillo and Kirsten Winter

parameterization (a peculiar feature of the ASM language, which generalizes the classical notion of state variables). Since model checking is only applicable to finite-state systems, we have to put restrictions on the ASM model to be checked in order to make it finite: all function ranges have to be restricted to a fixed finite set of values. To cope with a broader subset of the ASM language, we extend the basic work of [14], which introduced a simple transformation schema, to support the transformation of n-ary dynamic functions for n > 0. To ease the transition from infinite or large models to finite and feasible ones, we introduce a language feature for adjusting the function ranges in the declaration part of the system specification. Thus, such changes can be done locally and are not spread over the whole model. From a methodical point of view, model checking can support the early design phase: checking properties of the system behavior may yield counterexamples which help to “debug” the system specification. The simulator provided by the ASM Workbench can be fed with the counterexamples in order to illustrate the erroneous behavior. After locating and correcting the error that causes the counterexample, the transformation and model checking should be repeated. This debugging process gives a deeper insight into the model at hand. Errors become visible that can be easily over seen when carrying out mathematical proofs which are not mechanically checked, borderline cases become visible that are mostly not found when simulating isolated test cases. We are not claiming that model checking can replace, in general, mathematical proofs (developed with or without the help of theorem provers), as the range of applicability of model checking techniques is restricted to the verification of finite instances of the problem at hand and is in most cases insufficient to prove correctness of a system or protocol in general. However, we argue that using tool support in the way we suggest helps to find errors with small additional effort. This paper is structured as follows: after introducing the main features of ASM (Sect. 2), we show how the transformation from ASM into the SMV language is performed (Sect. 3). Sect. 4 presents results from applying our approach to a case study, an ASM specification of the FLASH cache coherence protocol. Sect. 5 outlines related work. We conclude in Sect. 6 with an outlook to further possible improvements of our tool.

2

Basic Notions of Abstract State Machines

In this section we introduce some basic notions of ASM (see [7] for the complete definition). We first describe the underlying computational model and then the syntax and semantics of the subset of the ASM language needed in this paper. 2.1

Computational Model

Computations Abstract State Machines define a state-based computational model, where computations (runs) are finite or infinite sequences of states {Si }, obtained from a given initial state S0 by repeatedly executing transitions δi :

Model Checking Support for the ASM High-Level Language δ

δ

333

δ

1 2 n S0 −→ S1 −→ S2 . . . −→ Sn . . .

States The states are algebras over a given signature Σ (or Σ-algebras for short). A signature Σ consists of a set of basic types and a set of function names, each function name f coming with a fixed arity n and type T1 . . . Tn → T , where the Ti and T are basic types (written f : T1 . . . Tn → T , or simply f : T if n = 0). for each function name f : T1 . . . Tn → T in Σ (the interpretation of the function name f in S). Function names in Σ can be declared as: – static: static function names have the same (fixed) interpretation in each computation state; – dynamic: the interpretation of dynamic function names can be altered by transitions fired in a computation step (see below); – external : the interpretation of external function names is determined by the environment (thus, external functions may change during the computation as a result of environmental influences, but are not controlled by the system). Any signature Σ must contain at least a basic type BOOL, static nullary function names (constants) true : BOOL, false : BOOL, the usual boolean operations (∧, ∨, etc.), and the equality symbol =. We also assume that there is a (polymorphic) type SET (T ) of finite sets with the usual set operations. When no ambiguity arises we omit explicit mention of the state S (e.g., we write T instead of T S for the carrier sets, and f instead of fS for static functions, as they never change during a run). Locations If f : T1 . . . Tn → T is a dynamic or external function name, we call a pair l = (f, x) with x ∈ T1 × . . . × Tn a location (then, the type of l is T and the value of l in a state S is given by fS (x)). Note that, within a run, two states Si and Sj are equal iff the values of all locations in Si and Sj are equal (i.e., they coincide iff they coincide on all locations). Transitions Transitions transform a state S into its successor state S by changing the interpretation of some dynamic function names on a finite number of points (i.e., by updating the values of a finite number of locations). More precisely, the transition transforming S into S results from firing a finite update set ∆ at S, where updates are of the form ((f, x), y), with (f, x) being the location to be updated and y the value. In the state S resulting from firing ∆ at S the carrier sets are unchanged and, for each function name f : y if ((f, x), y) ∈ ∆ fS (x) = fS (x) otherwise. Note that the above definition is only applicable if ∆ does not contain conflicting updates, i.e., any updates ((f, x), y) and ((f, x), y ) with y = y . The update set ∆–which depends on the state S–is determined by evaluating in S a distinguished closed transition rule P , called the program. The program consists usually of a set (block) of rules, describing system behavior under different–usually mutually exclusive–conditions.1 1

See, for instance, the example in Sect. 4, containing a rule for each message type.

334


2.2

The ASM Language

Terms Terms are defined as in first-order logic: (i) if f : T1 . . . Tn → T is a function name in Σ, and ti are terms of type Ti (for i = 1, . . . , n), then f (t1 , . . . , tn ) is a term of type T (written t : T ) (if n = 0 the parentheses are omitted, i.e. we write f instead of f ()); (ii) a variable v (of a given type T ) is a term. The meaning of a term t : T in a state S and environment ρ is a value Sρ (t) ∈ T defined by:2 fS (Sρ (t1 ), . . . , Sρ (tn )) if t ≡ f (t1 , . . . , tn ) Sρ (t) = ρ(v) if t ≡ v. As opposed to first-order logic, there is no notion of formula: boolean terms are used instead. Finite quantifications of the form “(Q v in A : G)”, where Q is ∀ or ∃, v : T , A : SET (T ), and G : BOOL, are also valid boolean terms.3 Transition rules While terms denote values, transition rules (rules for short) denote update sets, and are used to define the dynamic behavior of an ASM: the meaning of a rule R in a state S and environment ρ is an update set ∆S,ρ (R). ASM runs starting in a given initial state S0 are determined by the program P : each state Si+1 (i ≥ 0) is obtained by firing the update set ∆Si (P ) at Si : S0

∆S0 (P )

−→

S1

∆S1 (P )

−→

S2 . . .

∆Sn−1 (P )

−→

Sn . . .

Basic transition rules are the skip, update, block , and conditional rules. Additional rules are the do-forall (a generalized block rule) and choose rules (for non-deterministic choice).4 R ::= skip | f (t1 , . . . , tn ) := t | R1 . . . Rn | if G then RT else RF | do forall v in A with G R | choose v in A with G R The form “if G then R” is a shortcut for “if G then R else skip”. Omitting “with G” in do-forall and choose rules corresponds to specifying “with true”. The semantics of transition rules is as follows: ∆S,ρ ( skip ) = { } ∆S,ρ ( f (t1 , . . . , tn ) := t ) = { ((f, (Sρ (t1 ), . . . , Sρ (tn ))), Sρ (t)) } ∆S,ρ ( R1 . . . Rn ) = ni=1 ∆S,ρ ( Ri ) ∆S,ρ ( RT ) if Sρ (G) = true ∆S,ρ ( if G then RT else RF ) = ∆S,ρ ( RF ) otherwise 2

3 4

Environments–denoted by the letter ρ–are finite maps containing bindings which associate (free) variables to their corresponding values. We adopt the following notation: ρ[v → x] is the environment obtained by modifying ρ to bind v to x, while ρ\v is the environment with the binding of variable v removed from ρ. For closed terms and rules, we omit explicit mention of ρ (e.g., if t is a closed term, S(t) = S∅ (t)). Also in the rest of this paper we use A for set-typed terms and G for boolean terms. The ASM Workbench support more rules, such as let and case rules with pattern matching: however, for reasons of space, we have to skip them here.

Model Checking Support for the ASM High-Level Language

∆S,ρ ( do forall v in A with G R ) =

x∈X

335

∆S,ρ[v→x] ( R )

where X = {x | x ∈ Sρ (A) ∧ Sρ[v→x] (G) = true}. Note that executing a block (or a do-forall) rule corresponds to simultaneous execution of its subrules5 and may lead to conflicts. Choose rules are not directly supported by our transformation tool, but can always be replaced by external functions for arbitrary choice of a value (by a transformation similar to skolemization). For example, let Ai be terms of type SET (Ti ), i = 1, 2, 3, and fx : T1 , fz : T2 → T3 external functions with fx ∈ A1 and fz (y) ∈ A3 for each y ∈ A2 . Then the following two rules are equivalent: choose x in A1 do forall y in A2 choose z in A3 a(x, y, z) := x + y + z

∼ =

do forall y in A2 a(fx , y, fz (y)) := fx + y + fz (y)

Multi-Agent ASM Concurrent systems can be modelled in ASM by the notion of multi-agent ASM (called distributed ASM in [7]). The basic idea is that the system consists of more agents, identified with the elements of a finite set AGENT (which are actually sort of “agent identifiers”). Each agent a ∈ AGENT executes its own program prog(a) and can identify itself by means of a special nullary function self : AGENT , which is interpreted by each agent a as a. As a semantics for multi-agent ASM we consider here a simple interleaving model, which allows us to model concurrent systems in the basic ASM formalism as described above. In particular, we consider self as an external function, whose interpretation selfSi determines the agent which fires at state Si . We assume that there is one program P , shared by all agents, possibly performing different actions for different agents, e.g.: if self = a1 then prog(a1 ) ... if self = an then prog(an ) where {a1 , . . . , an } are the agents and prog(ai ) is the rule to be executed by agent ai , i.e., the “program” of ai . (The FLASH model presented in Sect. 4 is an example of this style of modelling, except that all agents execute exactly the same program, but on different data.) The ASM-SL Notation The ASM language, including all constructs above, is supported by the “ASM Workbench” tool environment [2], which provides syntax- and type-checking of ASM specifications as well as their simulation and debugging. The source language for the ASM Workbench, called ASM-SL, includes some additional features which are necessary for practical modelling tasks: constructs for defining types, functions, and named transition rules (“macros”), as well as a set of predefined data types (booleans, integers, tuples, lists, finite sets, etc.): as the ASM-SL notation is quite close to usual mathematical notation, no further explanation of ASM-SL will be needed. 5

For example, a block rule a := b, b := a exchanges a and b.

336

3


Translating Abstract State Machines into SMV

In this section, after a brief comparison of the ASM and SMV specification languages, we describe the transformation from ASM to SMV in two stages. First we recall the translation scheme introduced in [14], defined for a subset of ASM called ASM0 in this paper (Sect. 3.1). Then we define a transformation technique to reduce any ASM specification to ASM0 , such that the first translation scheme can then be applied (Sect. 3.2). ASM versus SMV While the computational model underlying both SMV and ASM is essentially the well-known model of transition systems, there are some significant differences: (1.) Abstract State Machines define, in general, systems with a possibly infinite number of states (as both the number of locations and the location ranges may be infinite); (2.) the way of specifying transitions in ASM and SMV is different: in SMV transitions are specified by next-expressions, which completely define the value which a state variable assumes in the next state, while updates of dynamic functions in ASM may be scattered troughout the program; (3.) the ASM notions of dynamic function and external function generalize the notion of state variable typical of basic transition systems (state variables correspond to nullary dynamic/external functions of ASM). The first issue is solved by introducing finiteness constraints, the second and third are addressed by the transformations of Sect. 3.1 and 3.2, respectively. Finiteness constraints In order to ensure that the ASM programs to be translated into SMV define finite-state systems, the user has to specify, for each dynamic or external function f : T1 . . . Tn → T , a finiteness constraint of the form f (x1 , . . . , xn ) ∈ t[x1 , . . . , xn ], where t : SET (T ) is a term denoting a finite set, possibly depending on the arguments of f (see Fig. 1 for an example). For external functions, finiteness constraints correspond to environment assumptions, expressed in the resulting SMV model by the range of the generated state variables; for dynamic functions, it must be checked that the constraints are not violated by the rules, resulting in the SMV code in appropriate proof obligations, which we call range conditions.6 3.1

The Basic Translation Scheme

The translation scheme introduced in [14] can be applied to transform into SMV a subset ASM0 of ASM, where: (i) only nullary dynamic and external functions are allowed; (ii) the only available data types are integers, booleans and enumerated types; (iii) the only defined static functions are those corresponding to predefined operations in SMV (boolean operations, +, -, etc.). As the semantic models for ASM0 are essentially basic transition systems, the translation of ASM into SMV is very close: 6

Note, however, that the range conditions can often be discarded by a simple static analysis of the rules, which prevents their expensive proof by model-checking.


337

– non-static functions (i.e., dynamic and external functions) are identified with locations and thus mapped one-to-one to SMV state variables; – values of the ASM data types are mapped one-to-one to SMV constants; – applications of static functions are translated to applications of the corresponding built-in operators of SMV. What remains to be done is to restructure the ASM program into a form where updates of the same location, together with their guards, are collected together. This is done in two steps. First, we transform an ASM program P into an equivalent ASM program P consisting only of a block of guarded updates (i.e., rules of the form if G then f (t) := t) by means of a “flattening” transformation: [[skip ]] = (empty block) [[f (t) := t ]] = if true then f (t) := t [[R1 . . . Rn ]] = [[R1 ]] . . . [[ Rn ]]  if G1T then RT1 if G ∧ G1T then RT1    [[RT ]] = . . .  ...   n n if Gn if G ∧ Gn T then RT T then RT ⇒ [[if G then RT else RF ]] = 1 1 1 1 if ¬G ∧ GF then RF  if GF then RF    ... [[RF ]] = . . .   m m if ¬G ∧ Gm if Gm F then RF F then RF

Second, we collect all guarded updates of the same location, thus obtaining, for each location loc occurring on the left-hand side of an update in P , a pair (loc, {(G1 , t1 ), . . . , (Gn , tn )}) which maps loc to a set of pairs (guard, right-hand side). Such a pair is translated into the following SMV assignment:7 ASSIGN next(C [[loc ]] ) := case C [[ G1 ]] : C [[t1 ]] ;

...

C [[Gn ]] : C [[tn ]] ;

1 : C [[loc ]] esac;

where C [[ . ]] denotes here the ASM → SMV compiling function for terms, which is straightforward for ASM0 . For each location l of a dynamic function f , in addition to the next assignment above, the transformation also generates the location’s initialization (an init assignment in SMV) as well as two proof obligations, a range condition (see discussion of finiteness constraints above) and a no-conflict condition, which ensures that no conflicts arise on this location. In fact, due to the semantics of case in SMV, the translation scheme is correct only if for all i, j with i = j, S |= ¬(Gi ∧ Gj ) ∨ (ti = tj ) in any reachable state S: if, in some state S, this condition is not satisfied, the ASM transition produces a conflict (i.e., an error), while the corresponding SMV transition simply picks one of the updates (the first one in the case whose guard is satisfied).8 3.2

The Extended Translation Scheme

In this section we show how to reduce an arbitrary (finite-state) ASM to ASM0 . This transformation allows to deal with the complete ASM language as in [7], 7 8

Note that we have to specify the default case explicitly (if none of the guards is true) which is given implicitly in ASM rules (see ASM semantics above). Like range conditions, no-conflict conditions can be often discarded statically.

338


with the exception of import rules (rules which allow the dynamic creation of elements at run-time) and choose rules. (However, one can deal with choose as explained in Sect. 2.2.) Arbitrary data types and operations (in particular, lists, finite sets, finite maps and user-definable freely generated types, as provided by ASM-SL) can be used without any restriction. Finite quantifications are also supported. The main problem here, as opposed to ASM0 , is that in general we do not know which location is updated by an update rule f (t1 , . . . , tn ) := t (if n > 0): the updated location may differ from state to state if some ti contains non-static function names. However, if all terms ti contain only static function names, they can be evaluated statically to values xi , and the term f (t1 , . . . , tn ) to the location l = (f, x). Thus, the basic idea of the transformation is to iteratively unfold and simplify rules until all terms can be reduced to values or locations. To formally define the transformation, we extend the syntactic category of terms to “partially evaluated terms” (simply called “terms” in the sequel) by adding values and locations: t ::= f (t1 , . . . , tn ) | v | (Q v in A : G) | x | l (We adopt the convention that x stands for a value and l for a location). Terms can be simplified by means of the transformation [[ . ]] ρ defined in Table 1, which is then extended to rules in a canonical way. Note that, whenever ρ contains bindings for all free variables occurring in t: (i) if t is a static term, then [[ t ]] ρ is a value x (coinciding with Sρ (t) in every state S); (ii) if t ≡ f (t1 , . . . , tn ) is a term where f is a dynamic or external function name and all the subterms ti are static (we call such a term a locational term), then [[ t ]] ρ is a location l.9 The rule-unfolding transformation E, which operates on closed rules such as the program P , is formally defined in Table 2. It works as follows: – if the rule R consists of a block of update rules of the form location := value, it terminates and yields R as result (there is nothing left to unfold); – otherwise, it looks for the first location l occurring in R (but not as left-hand side of some update rule) and unfolds R according to the possible values10 of l. In turn, the unfolding has to be applied to the subrules [[ R[ l/xi ] ]] obtained by substituting the values xi for l in R and simplifying. Applying E to the (simplified) ASM program [[ P ]] ∅ yields a program P = E( [[ P ]] ∅ ) which is essentially an ASM0 program (formally, the locations have still to be replaced by nullary dynamic or external function names and the values by nullary static function names, i.e. by constants).11 9 10 11

A simple consequence of this fact is that every closed static term simplifies to a value and every closed locational term to a location. The finite range of location l = (f, x) is derived from the finiteness constraint for f . The unfolding transformation often results in very large decision trees (casestructures in SMV): however, this does not have a negative influence on the efficiency of verification with SMV, as the verification costs depend on the size of the BDDs representing the transition relation and not on the size of the SMV source code (and BDDs, for a given variable ordering, are a canonical representation).


339

Table 1. Term and Rule Simplification Term Simplification [[ x ]]ρ = x

[[ v ]]ρ =

[[ l ]]ρ = l x = ρ(v) v

if v ∈ dom(ρ) otherwise

[[ ti ]] ρ = xi for each i ∈{1, . . . , n} ⇒ x = f (x1 , . . . , xn ) if f static function name [[f (t1 , . . . , tn )]]ρ = l = (f, (x1 , . . . , xn )) if f dynamic/external function name

[[ ti ]] ρ = l or [[ti ]]ρ = f (t ) for some i ∈ {1, . . . , n} ⇒ [[f (t1 , . . . , tn )]]ρ = f ([[t1 ]] ρ , . . . , [[tn ]] ρ ) [[ (Q v in A : G)]]ρ =

 [[ G]]ρ[v→x1 ] op . . . op [[G]]ρ[v→xn ]   if [[ A ]]ρ = x = {x1 , . . . , xn }

  (Q v in [[A]]ρ : [[G]](ρ\v) )

(i.e., if [[A ]]ρ is a value)

otherwise. (where op ≡ ∧ if Q ≡ forall, op ≡ ∨ if Q ≡ exists). Rule Simplification [[ skip]] ρ = skip [[ tL := tR ]]ρ = [[tL ]]ρ := [[tR ]]ρ [[ R1 . . . Rn ]] ρ = [[R1 ]]ρ . . . [[Rn ]] ρ

[[ if G then RT else RF ]] ρ =

[[ RT ]] ρ if [[G]]ρ = true if [[G]]ρ = false [[ RF ]] ρ if [[ G]]ρ then [[RT ]]ρ else [[RF ]]ρ otherwise.

[[ do  forall v in A with G R ]]ρ = [[ if G then R ]]ρ[v→x1 ] . . . [[ if G then R ]]ρ[v→xn ]   if [[A ]] ρ = x = {x1 , . . . , xn } (i.e., if [[A ]]ρ is a value) = do forall v in [ [ A ] ] ρ with [[ G ]] (ρ\v) [[ R ]] (ρ\v)   otherwise.

Table 2. Rule Unfolding Rule Unfolding If R has the form l1 := x1 . . . ln := xn , then E (R) = R. Otherwise: E (R) = if l = x1 then E ([[ R[l/x1 ]]] ∅ ) else if l = x2 then E ([[ R[l/x1 ]]] ∅ ) ... else if l = xn then E ([[ R[l/xn ]]] ∅ ) where l is the first location occurring in R (but not as lhs of an update rule) and {x1 , . . . , xn } is the range of location l.

340


Fig. 1 illustrates graphically the transformation technique (for simplicity, we consider a rule without variables, such that we can omit mentioning environments). The root of the tree–enclosed in the dashed box–is the (simplified) ASM program [[ P ]] to be transformed. The successors of each node in the tree are obtained as result of an unfolding step (under the given finiteness constraints): for instance, the successors of the root node are the rules [[ [[ P ]] [a/1] ]], [[ [[ P ]] [a/2] ]], and [[ [[ P ]] [a/3] ]], respectively. Locations are emphasized by enclosing them in boxes: note that, at the leaves, locations occur only as left-hand side of updates, thus they cause no further unfolding. The dashed box on the right contains the ASM0 program produced by the transformation: note that the locations actually affected by the ASM program–which are revealed by the unfolding–are mapped to nullary functions (“state variables”), whose ranges are derived from the finiteness constraints (see box at the top right corner).

Finiteness constraints a ∈ {1, 2, 3} f(x) ∈ {x, x + 1 } g(x) ∈ { 1,...,5 }

Locations → a → a (f,(1)) → f1 (f,(2)) → f2

ASM if a ≤ 2 then g(f( a )) := a

State variables : { 1, 2, 3 } : { 1, 2 } : { 2, 3 }

(g,(1)) → g1 : { 1,...,5 } (g,(2)) → g2 : { 1,...,5 } (g,(3)) → g3 : { 1,...,5 }

ASM 0 a=1

g( f, (1) ) := 1 (f,(1)) = 1

g, (1) := 1

(f,(1)) = 2

g, (2) := 1

a=2

a=3

g( f, (2) ) := 2 (f,(2)) = 2

g, (2) := 2

skip

(f,(2)) = 3

g, (3) := 2

→

if a = 1 then if f1 = 1 then g1 := 1 if f1 = 2 then g2 := 1 else if a = 2 then if f2 = 2 then g2 := 2 if f2 = 3 then g3 := 2 else if a = 3 then skip

Fig. 1. Rule Transformation Example

4

Case Study: The FLASH Cache Coherence Protocol

As an example for our model checking approach we chose a formalization of the FLASH protocol [9] with ASM. Our model is based on the work of Durand [4]. In Sect. 4.1, after a short introduction to FLASH, we describe an ASM model derived from [4] and motivate our refinements. Then we sketch the debugging process supported by the transformation and checking with SMV (in Sect. 4.2). 4.1

FLASH Cache Coherence Protocol

The Stanford FLASH multiprocessor integrates support for cache coherent shared memory for a large number of interconnected processing nodes. Each line-sized block of the distributed memory is associated with a home node containing the part of the physical memory where that line resides. Every read or write miss concerning a remote memory line triggers a line request to its home node that in turn initiates the corresponding part of the protocol. The request


341

may ask for shared or exclusive access depending on whether reading or writing access is wanted. The ASM description of the protocol is based on agents. A set of transition rules describes the behavior of a single agent. The behavior is determined by the currently processed message type – a notion that yields the clear model structure that is sketched in Fig. 2. Message Structure. A message is modeled as a quintuple consisting of the type of the message, the addressed agent, sender agent, agent initiating the request and requested line12 . Message types related to shared access are: requesting a line from its home granting a line to the requester (source of the request) forwarding the request to an exclusive owner of the line requesting a write-back of an owned line that is to be shared negatively acknowledging the request or forwarded request respectively, if it cannot be performed now. In analogy, message types related to exclusive access are: getx, putx, fwdgetx, and also inv: requesting a current sharer of the line to invalidate its local copy invAck: acknowledging the invalidation of the line fwdAck: owner’s granting according to a forwarded shared request. get: put: fwdget: swb: nack, nackc:

Additionally, for releasing a shared or exclusive copy from its cache an agent sends a write back (wb) and a replace message (rpl) to home, respectively. A read or write miss of a line, or the end of accessing, is simulated with the help of an oracle function which non-deterministically triggers an agent to send get/getx or rpl/wb messages. State Functions. Besides the message type, the agent’s behavior depends on several local state variables: curPhase(line) (phase of the current request), State(line) (state of the local line copy in use), and pending(line) (flag for currently processed request). Owner(line) and the set of Sharers of a line are also taken into account. Adjustable Parameters. The transition rules are parameterized by self, the agent that is currently active (this is implicit in Fig. 2), and the requested line. The domains of these parameters, Agents and Lines, and their extent are easily adjustable in the declaration part of the specification. Necessary Refinements. Sending a message is given as a macro definition. In the abstract model of [4] SendMsg adds a message to a (possibly infinite) set of messages in transit. The strategy for receiving a message from this set is not specified. For the proof it is just assumed that the messages are received in the right order. In order to keep the model finite and to formalize the assumption on the model behavior we have to refine the model. We replace the set of messages in transit by a finite queue for each agent, and we extend the overall behavior by means of a sub-step for synchronization. In the synchronization step the messages are passed through to the addressed agent in the proper order. 12

In our adaptation of the model the parts related to data are discarded.

342


if M essT ype = get then if pending(l) then SendMsg(nack, source, self , source, l) else if Owner(l) = undef then SendMsg(fwdget, Owner(l), self , source, l) pending(l) : = true else SendMsg(put, source, self , source, l) Sharer(l, source) : = true if M essT ype = fwdget then . . .

if M essT ype = put then . . .

if M essT ype = nack then curP hase(l) : = ready

if M essT ype = swb then . . .

if M essT ype = nackc then pending(l) : = false

if M essT ype = getx then if pending(l) then SendMsg(nack, source, self , source, l) else if Owner(l) = undef then SendMsg(fwdgetx, Owner(l), self , source, l) pending(l) : = true else if ∃u : Sharer(l, u) then ∀u : Sharer(l, u)SendMsg(inv, u, self , source, l) pending(l) : = true else SendMsg(putx, source, self , source, l) Owner(l) : = source if M essT ype = fwdgetx then . . .

if M essT ype = fwdAck then . . .

if M essT ype = inv then SendMsg(invAck, home, self , source, l) if State(l) = shared then State(l) : = invalid else if curP hase(l) = wait then curP hase(l) : = invalidP hase if M essT ype = invAck then Sharer(l, M essSender) : = false if ∀a : Agents | a = M essSender ∧ Sharer(l, a) = false then SendMsg(putx, source, self , source, l) pending(l) : = false if M essT ype = putx then . . .

if M essT ype = rpl then . . .

if M essT ype = wb then . . .

Fig. 2. Agent behavior modeled by ASM transition rules


343

In an ASM model, introducing a sub-step is structure preserving: in addition to the ASM for message computation (explained above) we specify an ASM for the message passing through. An overall ASM invokes both “sub-ASMs” in turn. Taking this, we benefit from the clear and understandable structure of the abstract model. The entire refined ASM-model is available on the web at http://www.first.gmd.de/~kirsten/publications/flash_param.asm. 4.2

Model Checking the Transformed System Specification

We take model checking of the transformed ASM model as an evolutionary process of debugging: we edit the ASM model, transform it automatically into an SMV model, run SMV to check the properties under investigation, investigate the resulting counterexample (if any) within the ASM model, and debug the ASM model. Since there are no restrictions on the behavior of the environment (producing requests on a line), we do not suffer from “wrong” counterexamples that are not suitable for debugging the ordinary system behavior. (We call counterexamples wrong, if they are caused by non-reasonable environment behavior that should be excluded. They obstruct the debugging process, since only one counterexample will be produced.) As the debugging process is more efficient if the model checking terminates in a reasonable span of time, we keep our model as small as possible. We find that, even when the model is restricted to few agents and lines, we detect errors in the abstract model as well as in our refinement. In the following we describe two of them as examples. We check the model for safety and liveness, i.e.: – No two agents have exclusive access on the same line simultaneously. – Each request will eventually be acknowledged. – Whenever an agent gets shared access, home will note it as a sharer. We formalize these requirements in CTL, e.g.13 : i=j [AG (!(State(a(i),l)=exclusive & State(a(j),l)=exclusive))] i [AG (curPhase(a(i),l) = wait -> AF (curPhase(a(i),l) = ready))] i [AG (State(a(j),l)=shared -> AX (Sharer(l,a(i)) = true))] Our first counterexample shows simultaneous exclusive access (for reasons of space we have to omit the listing here). The error that caused the counterexample can also be found in the abstract ASM model of [4]: Whenever a putx-message is sent to grant exclusive access the addressed requester has to be noted as owner of the line. This is specified in the getx-rule but it is missing in the invAck-rule that might also cause a putx-message to be send (see also Fig. 2). The protocol is unsafe since simultaneous exclusive access may occur, and written data may be lost. 13

Though the third specification is rather weak, it yields helpful counterexamples.

344


The following counterexamples are dedicated to the problem of racing (i.e., conflicts) on the finite message queue. Although our data space is limited to a very short queue, we can derive more general remarks, e.g.: Each sharer of a requested line has to process the rule for invalidation (inv-rule). It sends an invAck-message to home for acknowledging the invalidation. When receiving an invAck-message, home deletes the sender from the list of sharers. If home is sharer too,14 a deadlock may occur if the number of sharers is greater or equal than the length of the message queue: home may fail to complete with the inv-rule when the queue is full and sending a message is not possible (since every other sharer may have sent before); home stays busy and can not process the incoming invAck-rule to clear the queue. In general, we found out that the message queue must be larger or equal than the number of agents since in the worst case each agent is a sharer and will send simultaneously an invAck-message to the home node. The examples show that helpful borderline cases can be detected more easily by a model checker than by pure simulation. The computational effort for the automated transformation of our models ranges from three to five seconds. The size of the resulting SMV models is given below.15 The variable ordering is determined by the automatic reordering facility that is given by the SMV. resources used: 2 agents, 1 line 3 agents, 1 line 2 agents, 2 lines user time/system time: 4.69 s/0.13 s 5687.52 s/0.6 s 17263.2 s/0.86 s 1612740 2975127 BDD nodes allocated: 70587 37748736 54657024 Bytes allocated: 4849664 288986 + 82 78365 + 96 BDD nodes repr. transition relation: 19261 + 78

Although checking our model of the FLASH protocol is only feasible for a small number of agents and lines, the results show that the counterexamples yield extremely helpful scenarios for locating errors.

5

Related Work

Extending tool environments for high-level specification languages with an interface to a model checker is an upcoming topic. One can find approaches that are quite similar to ours but work on a different language: [3] suggests a transformation from Statecharts into SMV, in [10] Controller Specification (CSL) models are transformed and model checked by SVE, [12] equips the multi-language environment Synchronie with an interface to the VIS model checker, etc. Closer to our approach from the language point of view, [13] also investigates automatic verification of ASM. Spielmann represents an ASM model independently of its possible input by means of a logic for computation graphs (called 14 15

This is possible if we allow intra-node communication. The experiments were carried out on an UltraSPARC-II station with 296MHz and 2048 Mb memory, the operating system is Solaris 2.6.


345

CGL*). The resulting formula is combined with a CTL*-like formula which specifies properties and checked by means of deciding its finite validity. This approach addresses the problem of checking systems with infinitely many inputs, but it is only applicable to ASM with only 0-ary dynamic functions (i.e. ASM0 programs) and relational input, which is the second result of [13].

6

Conclusions

We presented an interface from the ASM Workbench to SMV, based on a transformation from ASM to the SMV language extending the one defined in [14] by the treatment of dynamic functions of arity n > 0. This is essential, as most ASM specifications benefit from the abundant use of parametric dynamic functions. The practicability of our approach is demonstrated by a non-trivial case study: the ASM model of the FLASH protocol. By example we show that errors can be found in the ASM model that will hardly be detected by pure mathematical proofs, and deduce more general constraints for the model at hand from the counterexamples. We support the exploitation of the model checking facility by means of introducing finiteness constraints into the ASM specification language for easy control of the function ranges in order to restrict the state space of the model. Additionally, the developer benefits from the automatically generated proof obligations to be checked by SMV: the no-conflict conditions and the range conditions. Some improvements of our tool, which are still to be implemented in order to make the transition between ASM and SMV smoother and thus ease the validation process, include the automatic translation of the counterexamples into a form which can be immediately read and simulated by the Workbench and the embedding of CTL operators into the ASM-SL language.

References 1. E. B¨ orger. Specification and Validation Methods. Oxford University Press, 1995. 331 2. G. Del Castillo. Towards comprehensive tool support for Abstract State Machines: The ASM Workbench tool environment and architecture. In D. Hutter et al., eds., Applied Formal Methods – FM-Trends 98 , LNCS 1641, pp. 311–325. Springer, 1999. 331, 335 3. N. Day. A model checker for Statecharts (linking case tools with formal methods). TR 93-35, CS Dept., Univ. of British Columbia, Vancouver, B.C., Canada, 1993. 344 4. A. Durand. Modeling cache coherence protocol - a case study with FLASH. In U. Gl¨ asser and P. Schmitt, editors, Procs. of the 5th International ASM Workshop, pages 111–126, Magdeburg University, 1998. 340, 341, 343 5. T. Filkorn et. al. SVE Users’ Guide. Siemens AG, M¨ unchen, 1996. 331 6. The VIS Group. Vis: A system for verification and synthesis. In T. Henzinger and R. Alur, editors, 8th Int. Conf. on Computer Aided Verification, CAV’96, number 1102 in LNCS, pages 428–432, July 1996. 331

346


7. Y. Gurevich. Evolving Algebras 1993: Lipari Guide. In E. B¨ orger, editor, Specification and Validation Methods. Oxford University Press, 1995. 331, 332, 335, 337 8. J.K. Huggins. Abstract State Machines home page. EECS Department, University of Michigan. http://www.eecs.umich.edu/gasm/. 331 9. J. Kuskin et al. The Stanford FLASH multiprocessor. In 21th Int. Symp. on Computer Architecture. Chicago, IL, 1994. 340 10. P. Liggesmeyer and M. Rothfelder. Towards automated proof of fail-safe behavior. In W. Ehrenberger, editor, Computer Safety, Reliablity and Security, SAFECOMP’98, LNCS 1516, pages 169–184, 1998. 344 11. K. McMillan. Symbolic Model Checking. Kluwer Academic Publishers, 1993. 331 12. A. Merceron, M. M¨ ullerburg, and G.M. Pinna. Verifying a time-triggered protocol in a multi-language environment. In W. Ehrenberger, editor, Computer Safety, Reliablity and Security, SAFECOMP’98, LNCS 1516, pages 185–195, 1998. 344 13. M. Spielmann. Automatic verification of Abstract State Machines. In N. Halbwachs and D. Peled, editors, Computer Aided Verification, CAV ’99 , number 1633 in LNCS, pages 431–442, Trento, Italy, 1999. 344, 345 14. K. Winter. Model checking for abstract state machines. J.UCS Journal for Universal Computer Science (special issue), 3(5):689–702, 1997. 332, 336, 345

A Markov Chain Model Checker Holger Hermanns1 , Joost-Pieter Katoen1 , Joachim Meyer-Kayser2 , and Markus Siegle2 1 2

Formal Methods and Tools Group, University of Twente P.O. Box 217, 7500 AE Enschede, The Netherlands Lehrstuhl f¨ ur Informatik 7, University of Erlangen-N¨ urnberg Martensstraße 3, 91058 Erlangen, Germany

Abstract. Markov chains are widely used in the context of performance and reliability evaluation of systems of various nature. Model checking of such chains with respect to a given (branching) temporal logic formula has been proposed for both the discrete [17,6] and the continuous time setting [4,8]. In this paper, we describe a prototype model checker for discrete and continuous-time Markov chains, the Erlangen–Twente Markov Chain Checker (E M C 2 ), where properties are expressed in appropriate extensions of CTL. We illustrate the general benefits of this approach and discuss the structure of the tool. Furthermore we report on first successful applications of the tool to non-trivial examples, highlighting lessons learned during development and application of E M C 2 .

1

Introduction

Markov chains are widely used as simple yet adequate models in diverse areas, ranging from mathematics and computer science to other disciplines such as operations research, industrial engineering, biology and demographics. Markov chains can be used to estimate performance characteristics of various nature, for instance to quantify throughput of manufacturing systems, locate bottlenecks in communication systems, or to estimate reliability in aerospace systems. Model checking is a very successful technique to establish the correctness of systems from similar application domains, usually described in terms of a non-deterministic finite-state model. If non-determinism is replaced by randomized, i.e. probabilistic decisions, the resulting model boils down to a finitestate discrete-time Markov chain (DTMC). For these models, qualitative and quantitative model checking algorithms have been investigated extensively, see e.g. [3,5,6,10,13,17,29]. In a qualitative setting it is checked whether a property holds with probability 0 or 1; in a quantitative setting it is verified whether the probability for a certain property meets a given lower- or upper-bound. Markov chains are memoryless. In the discrete-time setting this is reflected by the fact that probabilistic decisions do not depend on the outcome of decisions taken earlier, only the state currently occupied is decisive to completely

supported by the German Research Council DFG under HE 1408/6-1.


348

Holger Hermanns et al.

determine the probability of next transitions. For continuous-time Markov chains (CTMCs), where time ranges over (positive) reals (instead of discrete subsets thereof) the memoryless property further implies that probabilities of taking next transitions do not depend on the amount of time spent in the current state. The vast majority of applications of Markov chain modelling involves CTMCs, as opposed to DTMCs.1 In particular, CTMCs are the underlying semantic model of major high-level performance modelling formalisms such as stochastic Petri nets [1], stochastic automata networks [26], stochastic process algebras [24,21], Markovian queueing networks [12], and various extensions thereof. Model checking of CTMCs has been discussed in [8], introducing a (branching) temporal logic called continuous-time stochastic logic (CSL) to express properties over CTMCs. This logic is an extension of the (equally named) logic by Aziz et al. [4] with an operator to reason about steady-state probabilities: e.g. the formula Sp (Φ) asserts that the steady-state probability for being in a Φ-state is at least p, for p ∈ [0, 1]. Apart from the usual quantifiers like next and until, a time-bounded until U t , for t a non-negative real, is incorporated, for which standard derivatives, such as a time-bounded eventually ✸t , can be defined. The usual path quantifiers ∀ and ∃ are replaced by the probabilistic operator Pp (.) for comparison operator and p ∈ [0, 1]. For instance, P 0 for more than one state s , a competition between the transitions exists, known as the race condition. Let E(s) = s ∈S R(s, s ), the total rate at which any transition emanating from state s is taken. This rate is the reciprocal of the mean sojourn time in s. More precisely, E(s) specifies that the probability of leaving s within t time-units (for positive t) is 1 − e−E(s)·t , due to the fact that the minimum of exponential distributions (competing in a race) is again exponentially distributed, and characterized by the sum of their rates. Consequently, the probability of moving from state s to s by a single transition, denoted P(s, s ), is determined by the probability that the delay of going from s to s finishes before the delays of other outgoing edges from s; formally, P(s, s ) = R(s, s )/E(s) (except if s is an absorbing state, i.e. if E(s) = 0; in this case we define P(s, s ) = 0). Remark that the matrix P describes an embedded DTMC. A path σ is a finite or infinite sequence s0 , t0 , s1 , t1 , s2 , t2 , . . . with for i ∈ IN , si ∈ S and ti ∈ IR>0 such that R(si , si+1 ) > 0, if σ is infinite. For infinite i path σ, t ∈ IR0 and i the smallest index with t j=0 tj let σ@t = si , the state of σ at time t. If σ is finite and ends in sl , we require that sl is absorbing, l−1 and R(si , si+1 ) > 0 for all i < l. For finite σ, σ@t = sl for t > j=0 tj , for other t it is defined as above. Let Path(s) be the set of paths starting in s. Continuous stochastic logic. CSL is a branching-time, CTL-like temporal logic where the state-formulas are interpreted over states of a CTMC. Definition 1. For a ∈ AP, p ∈ [0, 1] and formulas of by the grammar defined CSL are Φ ::= a Φ ∧ Φ ¬Φ Pp (XΦ) Pp (Φ U Φ)

∈ { , }, the state Pp (Φ U t Φ) Sp (Φ)

The other boolean connectives are derived in the usual way. The probabilistic operator Pp (.) replaces the usual CTL path quantifiers ∃ and ∀ that can

350


be re-invented – up to fairness [9] – as the extremal probabilities P>0 (.) and P1 (.). Formula Pp (XΦ) (Pp (Φ1 U Φ2 ), respectively) asserts that the probability measure of the paths satisfying XΦ (Φ1 U Φ2 ) satisfies p. The meaning of X (“next step”) and U (“until”) is standard. The temporal operator U t is the real-time variant of U ; Φ1 U t Φ2 asserts that Φ1 U Φ2 will be satisfied in the time interval [0, t]; i.e. there is some x ∈ [0, t] such that Φ1 continuously holds during the interval [0, x[ and Φ2 becomes true at time instant x. The state formula Sp (Φ) asserts that the steady-state probability for a Φ-state satisfies p. Temporal operators like ✸, ✷ and their real-time variants ✸t or ✷t can be derived, e.g. Pp (✸t Φ) = Pp (true U t Φ) and Pp (✷ Φ) = P1−p (✸ ¬Φ). Semantics of CSL. Let M = (S, R, L) with proposition labels in AP. The semantics for atomic propositions, negation, and conjunction is standard [11]. Let Sat(Φ) = { s ∈ S | s |= Φ }. The steady-state operator is defined by: s |= Sp (Φ) iff πSat (Φ) (s) p where πS (s) denotes the steady-state probability for S ⊆ S when starting in s, πS (s) =

lim Pr{ σ ∈ Path(s) | σ@t ∈ S }.

t→∞

This limit exists for finite S [27]. Obviously, πS (s) = s ∈S πs (s), where we write πs (s) instead of π{ s } (s). We let π∅ (s) = 0. For path-formula ϕ of the form XΦ, Φ1 U Φ2 , or Φ1 U t Φ2 we have: s |= Pp (ϕ) iff P rob(s, ϕ) p, where P rob(s, ϕ) = Pr{ σ ∈ Path(s) | σ |= ϕ } i.e., P rob(s, ϕ) denotes the probability measure of all paths σ ∈ Path(s) satisfying ϕ The fact that, for each state s, the set { σ ∈ Path(s) | σ |= ϕ } is measurable, follows by easy verification given the Borel space construction on paths through CTMCs in [8]. The semantics of next and until-formulas is standard [11] and is omitted here. For time-bounded until we have: σ |= Φ1 U t Φ2

3

iff

∃x ∈ [0, t]. (σ@x |= Φ2 ∧ ∀y ∈ [0, x[. σ@y |= Φ1 ) .

The Model Checker E M C 2

E M C 2 is a prototype tool supporting the verification of CSL-properties over CTMCs. It is a global model checker, i.e. it checks the validity of a formula for all states in the model. E M C 2 has been developed as a model checker that can easily be linked to a wide range of existing high-level modelling tools based on, for instance, stochastic process algebras, stochastic Petri nets, or queueing networks. A whole variety of such tools exists [20], most of them using dedicated formats to store the rate matrix R that is obtained from the high-level specification. The matrix R, together with the proposition-labelling function L, constitutes the interface between the high-level formalism at hand and the model checker E M C 2 . Currently, E M C 2 accepts CTMCs represented in the tra-format

A Markov Chain Model Checker

351

as generated by the stochastic process algebra tool TIPPtool [22], but the tool is designed in such a way that it enables a filter plug-in functionality to bridge to various other input formats. This is realized via Java’s dynamic class loading capability. 3.1

The Model Checking Algorithm

Once the matrix R and the labelling L of a CTMC M have been initialised, the model checking algorithm implemented in E M C 2 essentially proceeds in the same way as for model checking CTL [11]. For a given formula Φ it recursively computes the sets of states Sat(.) satisfying the sub-formulas of Φ, and constructs the set Sat(Φ) from them. The verification of probabilistic and steadystate properties relies on the constructive characterizations for P rob(s, ϕ) and πS (s) as established in [8]. Steady-state properties. For calculating Sp (Φ) the tool follows a two-phase approach: first, the bottom strongly connected components (BSCC) of M are determined by a standard graph algorithm [28]. Then, the steady-state probability distribution is calculated for each of the BSCC. Each step requires the solution of a linear system of equations in the size of the BSCC. More precisely, let G be the underlying directed graph of M where vertices represent states and where there is an edge from s to s iff R(s, s ) > 0. Sub-graph B is a BSCC of G if it is a strongly connected component such that for any s ∈ B, Reach(s) ⊆ B. We have πs (s) = 0 iff s does not occur in any BSCC reachable from s. Let B be a BSCC of G with Reach(s)∩B = ∅, or equivalently, B ⊆ Reach(s), and assume that aB is an atomic proposition such that aB ∈ L(s) iff s ∈ B. Then ✸aB is a path-formula in CSL and P rob(s, ✸aB ) is the probability of reaching B from s at some time t. For s ∈ B, πs (s) is given by πs (s) = P rob(s, ✸aB ) · πB (s ) where πB (s ) =1 if B = {s }, and otherwise πB satisfies the linear system of equations2 πB (s) · R(s, s ) = πB (s ) · R(s , s) such that πB (s) = 1. (1) s∈B s =s

s∈B s =s

s∈B

Linear systems of equations can be solved either directly (e.g. Gaussian elimination or LU-decomposition) or by iterative methods such as the power method, Jacobi iteration, Gauß-Seidel iteration and successive over-relaxation [27]. Iterative methods compute approximations to the exact result up to a prespecified precision ε. Although (except for the power method) convergence of the iterative methods is not guaranteed, this problem only appears for pathological cases in practice. The major advantage of these methods is that the involved matrices do not change during the computation (i.e. fill-in is avoided), and hence the buildup of rounding errors is nonexistent [19,27]. In addition, direct methods are known 2

In [8] the above linear system of equations is defined in a slightly different way, by characterizing the steady-state probabilities in terms of the embedded DTMC.

352


to be only practical for state spaces of up to a few hundred states, while iterative methods have successfully been applied for much larger systems (up to 107 states) [14]. For these reasons, E M C 2 supports all of the above mentioned iterative methods to solve (1). Probabilistic path-formulas. Calculating the probabilities P rob(s, ϕ) proceeds as in the discrete-time case [13,17,5], except for the time-bounded until that is particular to the continuous-time case. More precisely: Next: P rob(s, XΦ) is obtained by multiplying the transition probability matrix P with the (boolean) vector iΦ = (iΦ (s))s∈S characterizing Sat(Φ), i.e. iΦ (s) = 1 if s |= Φ, and 0 otherwise. Until: P rob(s, Φ1 U Φ2 ) is obtained by solving a linear system of equations of the form x = P · x + iΦ2 where P(s, s ) = P(s, s ) if s |= Φ1 ∧ ¬Φ2 and 0 otherwise. P rob(s, Φ1 U Φ2 ) is the least solution of this set of equations. E M C 2 computes the least solution by one of the standard methods mentioned above for the steady-state operator. Time-bounded until: to compute the time-bounded until operator, we use the following characterization: Theorem 1. [8] The function S × IR0 → [0, 1], (s, t) → P rob(s, Φ1 U t Φ2 ) is the least fixed point of the higher-order operator Ω : (S × IR0 → [0, 1]) → (S × IR0 → [0,1]) where3 if s |= Φ2  1 t −E(s)·x Ω(F )(s, t) = R(s, s ) · e · F (s , t−x) dx if s |= Φ1 ∧ ¬Φ2 0  s ∈S 0 otherwise. This result suggests the following iterative method to approximate P rob(s, Φ1 U t Φ2 ): let F0 (s, t) = 0 for all s, t and Fk+1 = Ω(Fk ). Then, lim Fk (s, t) = P rob(s, Φ1 U t Φ2 ). k→∞

Each step in the iteration amounts to solve an integral of the following form: t Fk+1 (s, t) = R(s, s ) · e−E(s)·x · Fk (s , t−x) dx, s ∈S

0

if s |= Φ1 ∧ ¬Φ2 . In [8], we proposed to solve these integrals numerically based on quadrature formulas with, say, N + 1 equally spaced interpolation points xm = m · Nt (0 m N ) such as trapezoidal, Simpson, or Romberg integration schemes. For the trapezoidal method, for instance, this amounts to approximate m Fk+1 (s, xm ) ≈ R(s, s ) · αj · e−E(s)·xj · Fk (s , xm − xj ) s ∈S

j=0

t and αj = Nt for 0 < j < m. However, where for fixed m, α0 = αm = 2N practical experiments with E M C 2 revealed that these schemes may result in inaccurate results by overestimating the impact of the ‘leftmost’ intervals. We therefore take a different route by using piecewise integration, and approximating 3

The underlying partial order on S × IR>0 → [0, 1] is defined for F1 , F2 : S × IR>0 → [0, 1] by F1 F2 iff F1 (s, t) F2 (s, t) for all s, t.

6

6


Fk+1 (s, xm ) ≈

s ∈S

R(s, s ) ·

m

xj +β j+1

j=0 xj −βj t 2N for 0
0 (ϕ) where the numerical analysis tends to produce ‘wrong’ results (such as 0.99999 . . . rather than 1.0) due to machine imprecision. State Space Manager represents DTMCs and CTMCs in a uniform way. In fact, it provides an interface between the various checking and analysis components of E M C 2 and the way in which DTMCs and CTMCs are actually represented. This eases the use of different, possibly even symbolic state space representations. It is designed to support input formats of various kinds, by means of a simple plug-in-functionality (using dynamic class loading). It maintains information about the validity of atomic propositions and of sub-formulas for each state, encapsulated in a ‘Sat’ sub-component. After checking a sub-formula, this sub-component stores the results, which might be used later. In the current version of the tool, the state space is represented as a sparse matrix [27]. The rate matrix R (and its transposed RT ) is stored, while the entries of E and P are computed on demand. All real values are stored in the IEEE 754 floating point format with double precision (64 bit).

4

Application Case Studies

In this section we report on experiences with E M C 2 in the context of model checking two Markov chain models that have been generated from high-level formalisms, namely queueing networks and generalized stochastic Petri nets. Based on these experiments we assess the sensitivity of the model checker with respect to various parameters. We ran the experiments on a 300 MHz SUN Ultra 5/10 workstation with 256 MB memory under the Solaris 2.6 operating system. In the case studies we solve linear systems of equations by means of the Gauß-Seidel method. All recorded execution times are wall clock times. 4.1

A Simple Tandem Queue

As a first, simple example we consider a queueing network (with blocking) taken from [23]. It consists of a M/Cox2 /1-queue sequentially composed with a M/M/1queue, see Fig. 3. Due to space constraints, we have to refer to [12] for a thorough introduction to networks of queues. Both queueing stations have a capacity of c

356


λ

µ1

a1 µ 2 1−a1

κ

Fig. 3. A simple tandem network with blocking [23] jobs, c > 0. Jobs arrive at the first queueing station with rate λ. The server of the first station executes jobs in one or two phases; that is, with probability 1 − a1 a job is served with rate µ1 only, and with probability a1 , the job has to pass an additional phase with rate µ2 . Once served, jobs leave the first station, and are queued in the second station where service takes place with rate κ. In case the second queueing station is fully occupied, i.e. its server is busy and its queue is full, the first station is said to be blocked. Note that in this situation, the second phase of the first server is blocked and the first server can only pass a job that just finished the first phase to the second phase (which happens with probability a1 ), but the “bypass” of the second phase is also blocked. For the experiments we take the following values for the parameters of the queue: λ = 4 · c, µ1 = 2, µ2 = 2, κ = 4, and a1 = 0.1. We consider c = 2, which amounts to 15 states and 33 transitions, c = 5, i.e. 66 states and 189 transitions and c = 20, i.e. 861 states and 2851 transitions. The following atomic propositions are considered: – full is valid iff the entire tandem network is entirely populated, i.e. iff both queueing stations contain c jobs, – fst is valid iff no new arriving job (with rate λ) can be accepted anymore, because the first queue is entirely populated. – snd is valid iff the first queueing station is blocked, because the second queue is entirely populated. It should be noticed that full characterizes a single state, and hence, for large c identifies a rare event, i.e. a situation that appears with very low probability. The following steady-state properties are checked: Sp (full), Sp (fst), and Sp (Pq (Xsnd)), for arbitrary p and q. The latter property is valid if the steadystate probability to be in a state that can reach a state in which the first queueing station is blocked in a single step with probability q satisfies p. We do not instantiate p and q, as the execution times and computed probabilities will be the same for all p and q (except for the extremal cases 0 and 1); only the comparison with the bounds might lead to a different outcome. Thus, p, q ∈ ]0, 1[. For the steady-state properties we vary the precision ε of the computed probability, which is a parameter to the model checker. The results are listed in Table 1. The third column indicates the number of iterations needed to reach the result with the desired precision. Recall that the model checker checks the validity of CSL-formulas for all states in the CTMC. The following probabilistic path properties are checked: Pp (✸t full), Pp (✸t fst) and Pp (snd U t ¬snd). The latter property refers to the prob-


357

Table 1. Statistics for checking steady-state properties on the tandem queue # states

ε

10−4 10−6 (c = 2) 10−8 66 10−4 10−6 (c = 5) 10−8 861 10−4 10−6 (c = 20) 10−8 15

Sp (full) Sp (fst) Sp (Pq (Xsnd)) # iterations time (in sec) time (in sec) time (in sec) 62 107 146 77 121 159 74 118 158

0.012 0.016 0.017 0.028 0.041 0.048 0.569 0.644 0.811

0.012 0.017 0.018 0.028 0.042 0.085 0.498 0.643 0.778

0.013 0.016 0.019 0.065 0.076 0.181 1.567 1.935 2.369

Table 2. Statistics for checking Pp (Φ1 U t Φ2 )-formulas on the tandem queue # interpolation Pp (✸t full) Pp (✸t fst) Pp (snd U t ¬snd) points # iter. time (in sec) # iter. time (in sec) # iter. time (in sec) 64 18 2.497 11 1.045 4 0.144 128 18 9.762 11 4.082 4 0.566 256 18 22.19 11 16.30 4 2.248 512 18 156.2 11 69.04 4 9.067 1000 18 602.3 11 248.6 4 34.27 (c = 2) 15 10 64 45 6.506 12 1.140 4 0.145 128 43 24.00 12 4.575 4 0.568 256 43 52.85 12 17.94 4 2.309 512 43 383.1 12 75.13 4 8.994 1000 43 1433 12 274.9 4 34.38 (c = 2) 15 100 64 472 104.6 12 2.133 4 0.229 128 344 284.9 12 7.682 4 0.817 256 285 958.1 12 31.07 4 3.361 512 260 3582 12 123.8 4 13.51 1000 252 13201 12 493.8 4 51.49 (c = 2) 861 2 64 36 448.3 29 347.3 21 9.608 128 36 1773 29 1336 21 38.90 256 36 7028 29 5293 21 150.5 512 36 28189 29 21914 21 600.1 (c = 20)

# states t 15 2

ability of leaving a situation in which the second queue is entirely populated. All path-properties are checked with precision ε = 10−6 . We vary the time-span t (over 2, 10 and 100), and the number of interpolation points for the piecewise integration from 64 up to 1000. The results for c = 2 are listed in the upper part of Table 2. Note the difference in computation time for the different properties. Whereas Pp (snd U t ¬snd) can be checked rather fast, calculating the probability for reaching a fst-state within a certain time bound, and — in particular — until reaching a full-state takes significantly more time. Since the CTMC is strongly connected, a full- or fst-state can (eventually) be reached from any other state, and hence for all states the probability for reaching these states within time t must be calculated. In addition, the probability of reaching the single full-state is low, especially for larger c, and quite a number of iterations are needed in that case to obtain results with the desired precision. Since there are several fst-states in the CTMC, this effect is less important for Pp (✸t fst). For the last property (last two columns), probabilities need only be computed

358


for snd-states rather than for all states, and precision is reached rather quickly as the real probabilities are close to 1. These effects become more apparent when increasing the state space. This is reflected by the results in the lower part of Table 2 where we considered a CTMC of almost 1000 states. 4.2

A Cyclic Server Polling System

In this section, we consider a cyclic server polling system consisting of d stations and a server, modelled as a GSPN.4 The example is taken from [25], where a detailed explanation can be found. For d = 2, γ1 i.e. a two-station polling system, the GSPN λ1 busy1 idle1 model is depicted on the left. For a d-station serve1 polling system, the Petri net is extended in the skip1 obvious way. Place idlei represents the condiµ1 tion that station i is idle, and place busyi reppoll2 resents the condition that station i has generated a job. The server visits the stations in γ2 a cyclic fashion. After polling station i (place λ2 busy2 idle2 polli ) the server serves station i (place servei ), serve2 and then proceeds to poll the next station. skip2 The times for generating a message, for polling µ2 a station and for serving a job are all dispoll1 tributed exponentially with parameters λi , γi and µi , respectively. In case the server finds station i idle, the service time is zero which is modelled by the immediate transition skipi and the inhibitor arc from place busyi to transition skipi . In this study we consider polling systems with d = 3, 5, 7 and 10 stations (like in [25]). The corresponding CTMCs have 36, 240, 1344 and 15360 states (84, 800, 5824 and 89600 transitions). The polling systems are assumed to be symmetric, i.e. all λi have the same numerical values, and the same is true for all γi = 1 and all µi = 200. We set λi = µi /d. In the context of GSPNs, it is rather natural to identify the set of places that possess a token in a given marking — i.e. a state of our CTMC — with the set of atomic propositions valid in this state. Based on these atomic propositions, we check the following properties on the polling system: ¬(poll1 ∧poll2 ), stating that the server never polls both stations at the same time; Pp (¬serve2 U serve1 ), i.e. with probability p station 1 will be served before station 2; busy1 ⇒ P1 (✸poll1 ), so once station 1 has become busy, it will eventually be polled; busy1 ⇒ Pp (✸t poll1 ), once station 1 has become busy, with probability p it will be polled within t time units. (We let t = 1.5.) The following steady state 4

We refer to [1] for details on the semantics of GSPNs. In particular, the existence of immediate transitions (i.e. the black transitions) leads to so-called vanishing markings in the reachability graph which, however, can be eliminated easily. Our model checker works on the resulting tangible reachability graph which is isomorphic to a CTMC.


359

formulas are considered: Sp (busy1 ∧ ¬serve1 ), which says that the probability of station 1 being waiting for the server is p; and Sp (idle1 ), stating that the probability of station 1 being idle is p. Like before, p ∈]0, 1[. All pathTable 3. Statistics for checking CSL-formulas on the polling system d # states 3 36 240 5 1344 7 10 15360

¬(poll1 ∧ poll2 ) Pp (¬serve2 U serve1 ) busy1 ⇒ P1 (✸poll1 ) time (in sec) time (in sec) time (in sec) 0.002 0.031 0.005 0.002 0.171 0.009 0.005 1.220 0.011 0.037 16.14 0.080

busy1 ⇒ Pp (✸1.5 poll1 ) Sp (busy1 ∧ ¬serve1 ) Sp (idle1 ) time (in sec) # iter. time (in sec) # iter. time (in sec) d # states # iter. 3 36 8 2.308 39 0.044 39 0.038 240 12 30.92 61 0.103 61 0.102 5 1344 14 308.5 80 0.677 80 0.658 7 18 7090 107 11.28 107 11.29 10 15360

properties were checked with precision ε = 10−6 , and the number of interpolation points for numerical integration was set to 64. The steady-state properties were checked for ε = 10−8 . 4.3

Assessment of the Tool

Verification time. From the results of our case studies we observe that checking CSL-formulas consisting of just atomic propositions and logical connectives is very fast. Checking steady-state properties and unbounded until-formulas is also a matter of only a few seconds, even for the 15360 state case. Measurements have shown that the performance of our tool’s steady-state solution algorithm is comparable to the one of TIPPtool [22] which is based on a sophisticated sparse matrix library implemented in C. The model checking algorithm for time-bounded until Pp (Φ1 U t Φ2 ), which involves the approximate solution of a system of integral equations, becomes very time consuming for larger state spaces. Obviously, the execution times for checking time-bounded until strongly depend on the chosen number of interpolation points: each iteration in the piecewise integration in the worst case is of order O(N 2 · K), where K is the number of transitions and N the number of interpolation points. In addition, the execution times depend on the arguments (i.e. Φ1 and Φ2 ) and the considered time-span (i.e. parameter t). For instance, checking Pp (✸t Φ2 ) involves a computation for each state (that has a non-zero and non-trivial probability of reaching a Φ2 -state), while checking Pp (a U t Φ2 ) only involves a computation for the alabelled states (of this set). The case studies, and other experiments which we conducted showed that the main performance bottleneck of our tool is the algorithm for time-bounded until. Accuracy of numerical results. In order to assess the numerical accuracy of the algorithm for time-bounded until, we used our tool to compute (amongst

360


others) the cumulative distribution function of the Erlang k-distribution, that is, a convolution of k identical exponential distributions. For small k the results of the iterative algorithm are quite accurate, even for a small number of interpolation points N . The accuracy further improves as N is increased, as expected. For k 100 and small N , the accuracy of the results is unacceptable, while for larger N the run-time becomes excessive. Accuracy of verification result. Another issue — that is inherently present in all model checking approaches that rely on numerical recipes — is to avoid wrong outcomes of comparisons with a probability bound p in a sub-formula, that is then propagated upwards. Because round-off and truncation errors cannot be avoided (due to machine imprecision), this effect can happen if the computed value is very close to the bound p. For the extremal probability bounds (i.e. bounds > 0 and 1), we have circumvented this problem by applying the standard model checking algorithms for ∀ and ∃ as in [17]. Furthermore we intend to use a three-valued logic such that the tool can avoid potentially wrong results, and answers ‘don’t know’ in case some calculated (i.e. approximated) probability is within some tolerance to a probability bound p occurring in a (sub-)formula to be checked.

5

Conclusion

In this paper we have presented a model checker for (state labelled) discrete and continuous-time Markov chains. We reported on the structure of the tool, and on experiments using the model checker to verify CTMCs derived from high-level formalisms such as stochastic Petri nets and queueing networks. As far as we know, E M C 2 is the first implementation of a bridge between such high-level specification formalisms for CTMCs and model checking. E M C 2 is a prototype, in particular for the moment it does not use symbolic, i.e. (MT)BDD-based, data structures. Although our own experience (and of others, cf. [16]) has shown that very compact encodings of Markov chains are possible with MTBDDs and similar data structures [23], and symbolic model checking algorithms for CTMCs do exist [8], we favor a separation of concerns: to our belief the issues of numerical stability, convergence, accuracy and efficiency are worth to be studied in isolation, without interference of the (sometimes unpredictable) effects of BDD-based computations. In addition, none of the highlevel modelling tools for generating CTMCs uses BDD-based data structures, as far as we know. Our decision to implement the model checker E M C 2 in Java turned out to be a good choice. In particular it allowed us to develop an easy-to-use user interface along with the model checker engine. Also the numerical computations have a good performance in Java; e.g., the computation of steady-state properties is comparable to (optimised) existing C implementations. Our experiments with E M C 2 have shown that the checking of time-bounded until-properties requires an efficiency improvement. We are currently considering alternative ways to model check this operator [7].


361

Acknowledgement The authors thank Lennard Kerber (Erlangen) for his contribution to assessing the accuracy of the tool output and Christel Baier (Bonn) for her valuable contributions and discussions.

References 1. M. Ajmone Marsan, G. Conte, and G. Balbo. A class of generalised stochastic Petri nets for the performance evaluation of multiprocessor systems. ACM Tr. on Comp. Sys., 2(2): 93–122, 1984. 348, 358 2. L. de Alfaro, M.Z. Kwiatkowska, G. Norman, D. Parker and R. Segala. Symbolic model checking for probabilistic processes using MTBDDs and the Kronecker representation. In TACAS, LNCS (this volume), 2000. 349 3. A. Aziz, V. Singhal, F. Balarin, R. Brayton and A. Sangiovanni-Vincentelli. It usually works: the temporal logic of stochastic systems. In CAV, LNCS 939: 155– 165, 1995. 347 4. A. Aziz, K. Sanwal, V. Singhal and R. Brayton. Verifying continuous time Markov chains. In CAV, LNCS 1102: 269–276, 1996. 347, 348 5. C. Baier. On algorithmic verification methods for probabilistic systems. Habilitation thesis, Univ. of Mannheim, 1999. 347, 352 6. C. Baier, E. Clarke, V. Hartonas-Garmhausen, M. Kwiatkowska, and M. Ryan. Symbolic model checking for probabilistic processes. In ICALP, LNCS 1256: 430– 440, 1997. 347 7. C. Baier, B.R. Haverkort, H. Hermanns and J.-P. Katoen. Model checking continuous-time Markov chains by transient analysis. 2000 (submitted). 360 8. C. Baier, J.-P. Katoen and H. Hermanns. Approximate symbolic model checking of continuous-time Markov chains. In CONCUR, LNCS 1664: 146–162, 1999. 347, 348, 349, 350, 351, 352, 360 9. C. Baier and M. Kwiatkowska. On the verification of qualitative properties of probabilistic processes under fairness constraints. Inf. Proc. Letters, 66(2): 71–79, 1998. 350, 353 10. I. Christoff and L. Christoff. Reasoning about safety and liveness properties for probabilistic systems. In FSTTCS, LNCS 652: 342-355, 1992. 347 11. E.M. Clarke, E.A. Emerson and A.P. Sistla. Automatic verification of finitestate concurrent systems using temporal logic specifications. ACM Tr. on Progr. Lang. and Sys., 8(2): 244-263, 1986. 350, 351 12. A.E. Conway and N.D. Georganas. Queueing Networks – Exact Computational Algorithms. MIT Press, 1989. 348, 355 13. C. Courcoubetis and M. Yannakakis. Verifying temporal properties of finite-state probabilistic programs. In Proc. IEEE Symp. on Found. of Comp. Sci., pp. 338– 345, 1988. 347, 352 14. D.D. Deavours and W.H. Sanders. An efficient disk-based tool for solving very large Markov models. In Comp. Perf. Ev., LNCS 1245: 58–71, 1997. 352 15. L. Fredlund. The timing and probability workbench: a tool for analysing timed processes. Tech. Rep. No. 49, Uppsala Univ., 1994. 348 16. G. Hachtel, E. Macii, A. Padro and F. Somenzi. Markovian analysis of large finitestate machines. IEEE Tr. on CAD of Integr. Circ. and Sys., 15(12): 1479–1493, 1996. 360

362


17. H. Hansson and B. Jonsson. A logic for reasoning about time and reliability. Form. Asp. of Comp., 6(5): 512–535, 1994. 347, 348, 352, 353, 360 18. V. Hartonas-Garmhausen, S. Campos and E.M. Clarke. ProbVerus: probabilistic symbolic model checking. In ARTS, LNCS 1601: 96–111, 1999. 348 19. B.R. Haverkort. Performance of Computer Communication Systems: A ModelBased Approach. John Wiley & Sons, 1998. 351 20. B.R. Haverkort and I.G. Niemegeers. Performability modelling tools and techniques. Perf. Ev., 25: 17–40, 1996. 350 21. H. Hermanns, U. Herzog and J.-P. Katoen. Process algebra for performance evaluation. Th. Comp. Sci., 2000 (to appear). 348 22. H. Hermanns, U. Herzog, U. Klehmet, V. Mertsiotakis and M. Siegle. Compositional performance modelling with the TIPPtool. Perf. Ev., 39(1-4): 5–35, 2000. 351, 359 23. H. Hermanns, J. Meyer-Kayser and M. Siegle. Multi-terminal binary decision diagrams to represent and analyse continuous-time Markov chains. In Proc. 3rd Int. Workshop on the Num. Sol. of Markov Chains, pp. 188-207, 1999. 355, 356, 360 24. J. Hillston. A Compositional Approach to Performance Modelling. Cambridge University Press, 1996. 348 25. O.C. Ibe and K.S. Trivedi. Stochastic Petri net models of polling systems. IEEE J. on Sel. Areas in Comms., 8(9): 1649–1657, 1990. 358 26. B. Plateau and K. Atif, Stochastic automata networks for modeling parallel systems. IEEE Tr. on Softw. Eng., 17(10): 1093–1108, 1991. 348 27. W. Stewart. Introduction to the Numerical Solution of Markov Chains. Princeton Univ. Press, 1994. 348, 349, 350, 351, 355 28. R.E. Tarjan. Depth-first search and linear graph algorithms. SIAM J. of Comp., 1: 146–160, 1972. 351 29. M.Y. Vardi. Automatic verification of probabilistic concurrent finite state programs. In Proc. IEEE Symp. on Found. of Comp. Sci., pp. 327–338, 1985. 347

Model Checking SDL with Spin Dragan Boˇsnaˇcki1, Dennis Dams2 , Leszek Holenderski1 , and Natalia Sidorova2 1

2

Dept. of Computing Sci., Eindhoven University of Technology PO Box 513, 5600 MB Eindhoven, The Netherlands {D.Bosnacki,L.Holenderski}@tue.nl Dept. of Electrical Eng., Eindhoven University of Technology PO Box 513, 5600 MB Eindhoven, The Netherlands {D.Dams,N.Sidorova}@tue.nl

Abstract. We present an attempt to use the model checker Spin as a verification engine for SDL, with special emphasis put on the verification of timing properties of SDL models. We have extended Spin with a front-end that allows to translate SDL to Promela (the input language of Spin), and a back-end that allows to analyse timing properties. Compared with the previous attempts, our approach allows to verify not only qualitative but also quantitative aspects of SDL timers, and our translation of SDL to Promela handles the SDL timers in a correct way. We applied the toolset to the verification of a substantial part of a complex industrial protocol. This allowed to expose several non-trivial errors in the protocol’s design.

1

Introduction

We present an approach to automating the formal verification of SDL, by model checking SDL specifications with Spin. SDL [8] is a visual specification language, especially well suited for communication protocols, and quite popular in industry. Spin [5] is one of the most successful enumerative model checkers. In order to connect the Spin verification engine to SDL, we had to extend Spin in two ways. First, we had to implement a front-end which would allow to automatically translate SDL to Promela (the input language of Spin). Second, we had to extend Spin with the notion of discrete time, to be able to model SDL timers. The extended version is called DT Spin and its input language is called DT Promela (where DT stands for discrete time). The translation of SDL to Promela is split into two steps. In the first step we use the sdl2if tool, implemented in Verimag, Grenoble, which transforms SDL programs to the intermediate format IF [3] that was designed for the representation of timed asynchronous systems. This first step flattens the hierarchic structure of SDL blocks to bare processes which can then be directly transformed to Promela processes, in the second step, by our tool if2pml.

This research has been supported by the VIRES project (Verifying Industrial Reactive Systems, Esprit Long Term Research Project #23498).


364

Dragan Boˇsnaˇcki et al.

We applied our method to the verification of a substantial part of MASCARA which is a complex telecommunication protocol developed by the WAND (Wireless ATM Network Demonstrator) consortium [13]. As a result, we exposed several non-trivial errors in the design of MASCARA. In order to resolve the usual problems caused by the lack of the formal semantics of SDL, we decided to rely on the semantics of SDL as determined by the ObjectGEODE tool [11]. In particular, we assume that transitions are atomic and instantaneous, and timeout signals are not necessarily sent at the beginning of a time slice (in other words, the timer messages are treated like other messages, without any special priority). More details are given in Section 3.2. We are aware of two other attempts to use Spin as a verification engine for SDL [6,10]. In our opinion, they were not fully successful. First, both approaches tackle the qualitative aspects of SDL timers only, in the sense that they abstract out the concrete values of timers. Our approach allows to analyze the quantitative aspects of SDL timers as well. Second, the previous approaches are incorrect, as far as the timing issues are concerned. More precisely, instead of just introducing more behaviours, which is unavoidable when the concrete values of timers are abstracted out, they simultaneously remove some of the behaviours that are allowed by SDL, which may lead to unsound results (so called “false positives”). Some concrete examples are given in Section 3.3. The incorrectness of the previous attempts also shows that taking the timing issues of SDL into account, when using Spin to model check SDL, is not trivial. We do not claim that our approach is correct, in the formal sense. Ideally, one should prove that the approach is sound (no “false positives” are possible) and complete (no “false negatives” are possible). In principle, such a correctness result cannot be established, due to the lack of formal semantics, both for SDL and Promela, which would be simple enough to carry such correctness proofs. However, we give some informal justification of the correctness of our approach. We clearly separate the qualitative and quantitative aspects of SDL timers. This allows to analyze the SDL models that use timers, both in the abstract and concrete way. The two methods have their own benefits and drawbacks. In the abstract case, if DT Spin decides that some safety property holds then the property is true for all values of timers, and is thus time independent. This may be a desired feature of a model. On the other hand, proving the time independence may come at a price: “false negatives” are possible, in the case a property does depend on time. The analysis with the concrete values of timers does not lead to “false negatives”, but the price may be a bigger state space that must be enumerated by DT Spin. We put some effort in making DT Spin a “conservative” extension of Spin: DT Promela is designed in such a way that standard Spin can be used to model check DT Promela programs obtained from the SDL models with abstracted timers. This may be useful for those who prefer to use a proven technology, instead of our experimental DT Spin. The paper is organized as follows. In Section 2, we give an overview of Spin and DT Spin. Section 3 is devoted to the translation of SDL to DT Promela. The

Model Checking SDL with Spin

365

verification method and its application to the MASCARA protocol is presented in Sections 4 and 5. Finally, we conclude with Section 6.

2 2.1

Spin and DT Spin Spin and Promela

Spin [5] is a software tool that supports the analysis and verification of concurrent systems. The system descriptions are modelled in a high-level language, called Promela. Its syntax is derived from C, and extended with Dijkstra’s guarded commands and communication primitives from Hoare’s CSP. In Promela, system components are specified as processes that can interact either by message passing, via channels, or memory sharing, via global variables. The message passing can either be buffered or unbuffered (as in Hoare’s CSP). Concurrency is asynchronous (no assumptions are made on the relative speed of process executions) and modelled by interleaving (in every step only one enabled action is performed). Given a Promela model as input, Spin generates a C program that performs a verification of the system by enumerating its state space, using a depth-first search algorithm. This way, both safety properties (such as absence of deadlock, unspecified message receptions, invalid end states, and assertions) and liveness properties (such as non-progress cycles and eventual reception of messages) can be checked. The most general way of expressing properties in Spin is via so-called never claims, which are best seen as monitoring processes that run in lock step with the rest of the system. The never claims are, in fact, B¨ uchi Automata, and thus can express arbitrary omega-regular properties. Spin provides an automatic translator from formulae in linear-time temporal logic (LTL) to never claims, so it can be used as a full LTL model checker. In case the system violates a property, the trace of actions leading to an invalid state, or a cycle, is reported. The erroneous trace can be replayed, on the Promela source, by a guided simulation. To cope with the problem of state space explosion, Spin employs several techniques, such as partial-order reduction, state-vector compression, and bitstate hashing. 2.2

DT Spin and DT Promela

DT Spin [2] is an extension of Spin with discrete time. In the time model used in DT Spin, time is divided into slices indexed by natural numbers that can be seen as readings of a fictitious global digital clock that ticks at the end of each slice. The events happening in the same slice are assigned the same clock value, so the elapsed time between events is measured in ticks. In our model, time passes only if no other action in the system is possible. Since concurrency is modelled by interleaving, all the events happening in one run of a system are totally ordered and thus two events happening in the same slice are not considered necessarily simultaneous. Instead, they are considered

366


to be ordered, and their ordering inside one slice is determined by the ordering of the run. The properties that depend only on the ordering of events are called qualitative while those depending on the elapsed time between events are called quantitative. In order to capture timing features, standard Promela is extended to DT Promela. A new data type, called timer, is introduced. It is used to declare variables that represent discrete-time countdown timers. Three new statements that operate on timers are added: set(tmr,val) activates the timer tmr, by assigning the integer value val to tmr, reset(tmr) deactivates tmr, by setting it to −1, and expire(tmr) tests whether the value of tmr is 0. Initially, a timer has value −1. In fact, the new statements are defined as Promela macros, in a special header file included at the beginning of every DT Promela model: #define #define #define #define

timer set(tmr,val) reset(tmr) expire(tmr)

short /* a short integer */ tmr = val tmr = -1 tmr == 0

The new statements allow to model a broad class of timing constraints, and other timed statements can easily be defined as Promela macros, by combining set, reset and expire with the control flow statements offered by Promela. There is yet another operation on timers: the tick statement decreases the value of all active timers by 1. It is used internally by DT Spin, at the end of every time slice, and is not available to the user. DT Spin is fully compatible with Spin, and all features of Spin can be used to analyse discrete-time models. In particular, the partial order reduction algorithm of Spin [7,9] had to be adapted for timed systems [2]. Besides qualitative properties, a broad range of quantitative properties can be verified using boolean expressions on timer values, in the assertions and LTL formulae.

3

Translating SDL to DT Promela

The process of model checking an SDL specification is depicted in Figure 1. An SDL specification is pushed through the pipe of translators sdl2if and if2pml, to obtain a DT Promela program that serves as input to DT Spin or Spin. The result of a negative verification experiment (e.g., an erroneous trace) has to be checked manually against the SDL specification. sdl2if translates SDL to the language IF (Intermediate Format, [3]) which is a specification language for timed concurrent systems consisting of a fixed number of communicating automata. IF was designed as an intermediate formalism for connecting several industrial formal description techniques, such as LOTOS and SDL, to a number of verification tools developed in the research community. sdl2if is implemented with the help of the SDL/API Interface provided by the ObjectGEODE tool [11]. The current implementation of sdl2if is able to


SDL specification

sdl2if

IF translation

if2pml

367

DT Promela translation

spin

dtspin

Fig. 1. The tools used in the verification.

translate a substantial subset of SDL. The only essential omissions are dynamically created processes and abstract data types. In the overall SDL to DT Promela translation, sdl2if resolves the hierarchical aspects of SDL by “flattening” the hierarchy of blocks down to bare processes and resolving appropriately the sources, destinations and priorities of the signals exchanged between the processes. On the way, the SDL procedures are eliminated by inlining (when possible), and the syntactic sugar of SDL (enabling conditions, continuous signals, the special input none) is transformed to more primitive constructs. Moreover, some implicit constructs are made explicit (sender, offspring, parent, discarded signals). Details are given in [3]. On the other hand, if2pml performs the translation of the SDL core language, coping with issues that have more semantical flavor (like preserving the atomicity of the transitions or implementing the discard mechanism). Since IF is intended to be an intermediate language for a variety of high-level specification formalisms, it is quite expressive. As not all of its constructs are needed for representing SDL models, if2pml only translates the subset of IF that is relevant to SDL. IF and sdl2if were developed at Verimag, Grenoble, while if2pml and DT Spin were developed at the Eindhoven University of Technology. All the tools were developed in the framework of the VIRES project [12]. In what follows we describe the translation from IF to DT Promela in more detail. The presentation is divided into three parts. In Section 3.1 we describe how the SDL processes (i.e., IF automata) are represented in Promela. In Section 3.2, the DT Promela representation of the SDL/IF timers is given. Finally, in Section 3.3, the abstraction from the concrete values of timers is described. 3.1

IF to Promela: Translating Automata

As in Promela, the IF models are sets of processes that communicate via buffers. This provides an almost one-to-one translation of these concepts. Also, the IF data types can directly be translated to their Promela counterparts (with some minor restrictions on the range types).

368


The way the SDL/IF automata are represented in Promela is fairly standard, and can be grasped by comparing the IF source given in Fig. 2 with its Promela translation in Fig. 3. A state is represented by a Promela label. All the outgoing transitions are translated to the branches of the choice statement associated with the label. The discard mechanism is implemented via self-looping to the same state, after reading a signal that has to be discarded in the state. The atomicity of SDL/IF transitions is preserved by putting the if statement inside the atomic statement.1 process proc: buffer buf; state state1 discard sig3, sig4 in buf state2 ... transition from state1 input sig1 from buf do body1 to state2; from state1 input sig2 from buf do body2 to state3; ...

Fig. 2. A skeleton of an IF program. proctype proc() { state1: atomic { if :: buf?sig1 -> :: buf?sig2 -> ... :: buf?sig3 -> :: buf?sig4 -> fi }

translated_body1; goto state2; translated_body2; goto state3; goto state1; /* discard */ goto state1; /* discard */

state2: atomic{ ... } ... }

Fig. 3. Promela translation of the structure from Fig. 2

The implementation of if2pml is still in a prototype stage and some SDL features are not supported yet. The most notable omissions are the mechanism of saving a signal, the dynamic creation of processes, and the abstract data types. The implementation of the save mechanism in Promela is possible, but rather 1

A special care is taken to correctly handle the stable and non-stable states in IF.


369

involved. It may lead to a substantial growth of the state space during model checking, and for this reason we have chosen to omit it. The dynamic process creation is a basic feature of Promela, so it can easily be implemented once sdl2if supports it. Finding a satisfactory solution for the abstract data types remains a future work for both sdl2if and if2pml. 3.2

IF to DT Promela: Translating Timers

The crucial issue about time in SDL is the detection of timer expirations (timeouts). In SDL, a timer expiration results in sending a timeout pseudo-signal to the input queue of the process the timer belongs to. The timeout signal is then handled as an ordinary signal: it is either consumed, by a transition that is guarded by the timeout signal, or discarded, in a state with no such transitions. In both cases, the corresponding timer is deactivated. Our implementation of timers does not use such timeout signals. Instead, we associate with each SDL timer a DT Promela timer variable, and detect the expiration of the timer by testing whether the timer variable has value 0, and the timer is deactivated by setting the timer variable’s value to −1. More precisely, for each timer tmr declared in an SDL process, we add a new branch to all the choice statements associated with states (see figure 3). Assume a state, say state1, with an outgoing transition guarded by tmr. For such a state we add the branch :: expire(tmr) -> reset(tmr); translated body1; goto state2; If state1 has no outgoing transitions guarded by tmr, we add the branch :: expire(tmr) -> reset(tmr); goto state1; /* discard */ It turns out that under the time semantics given below (as determined by the ObjectGEODE tool [11]), these two approaches to timers are equivalent. However, the “variable” approach has an advantage over the “signal” approach, from the verification point of view, since it generates smaller state spaces. In the “signal” approach, an additional Promela process (or even several processes) would be needed, in order to generate the timeout signals in a right way. This, together with the overhead of exchanging timeout signals, increases the state space. In what follows, we give an informal justification of the above mentioned equivalence. The semantics of time in SDL. Transitions are instantaneous. Time can only progress if at least one timer is active and all SDL processes are waiting for further input signals (i.e., all input queues are empty, except for saved signals). Time progression amounts to performing a special transition that makes time increment until an active timer expires. In the sequel, we refer to the segments of time separated by the special transition as time slices. (Note that time progression is discretized.)

370


With each timer there is associated a pseudo-signal and an implicit transition, called a timeout transition. When a timer expires, in some time slice, its timeout transition becomes enabled and can be executed at any point of the time slice. The execution of this transition adds the associated pseudo-signal to the process queue. The timeout transitions of the timers that expire simultaneously can be executed in any order. If the set or reset operation is performed on a timer after its timeout transition becomes enabled, the timeout transition is disabled. If the timer is set or reset after adding its associated pseudo-signal to the process queue, the pseudo-signal is removed from the queue. Model equivalence. In order to justify the equivalence of the two models we need to show that any execution sequence in the signal model can be simulated by an execution sequence in the variable model, and vice versa. In what follows, we assume that SDL timers are never set to the special value now (i.e., our timer variables are never set to 0, explicitly), and we only concentrate on the simulation of the transitions which relate to timers, since the two models coincide on the untimed features. There are two issues which have to be considered: the set and reset operations on timers, and the expiration of timers. The set and reset operations coincide in the two models, so this issue does not cause problems. As far as the expiration of timers is concerned, it should be obvious that the time slice in which a timer expires is recognized in the same way, in both models. The only problematic issue is whether consuming/discarding the timeout signals, in the signal model, is properly simulated with our count-down timers, and vice versa. Our claim that, in fact, this is the case is based on the assumption that the following, more direct, translation of SDL/IF to Promela would be correct. Assume ts T denotes the timeout signal corresponding to timer T , in the signal model. In order to handle the consumption of ts T like the consumption of an ordinary signal, by an SDL/IF transition guarded by ts T, the following branch :: buf?ts_T -> translated_body1; goto state2; could be added to the Promela translation in figure 3. Similarly, in order to handle the discarding of ts T as an ordinary signal, the following branch :: buf?ts_T -> goto state1; /* discard */ could be added to the choice statements that corresponds to the states with no outgoing transitions guarded by ts T. Observe that the :: expire(tmr) -> reset(tmr); ...


371

branches, in our real Promela code, correspond directly to the above branches. More precisely, expire(tmr) -> reset(tmr) corresponds directly to buf?ts T. Namely, expire(tmr) corresponds to the check whether ts T is in the input queue, and reset(tmr) corresponds to the removal of ts T from the queue. 3.3

Timer Abstraction

It turns out that standard Spin can also be used to model check a DT Promela model, for a property that does not depend on time. The advantage of using Spin instead of DT Spin is that Spin usually consumes less resources than DT Spin. In order to convert a DT Promela model into a Promela model, it suffices to change the special header file included at the beginning of every DT Promela model (see Section 2.2): #define #define #define #define

timer set(tmr,val) reset(tmr) expire(tmr)

bool tmr = true tmr = false tmr == true

The new definitions abstract out the concrete values of active timers, by consistently mapping them to true. The concrete value −1, which is used to mark an inactive timer, is consistently mapped to false (under the assumption that each timer is initialised to false). Obviously, such an abstraction is sound since no behaviours are lost. More precisely, any behaviour with concrete timers can be simulated with abstract timers, since the active timers are allowed to expire nondeterministically, at any time. This is not the case in the related approaches [6,10], where some heuristic approximations of the timer behaviour are used rather than a proper abstraction. The approximations do not only add some behaviours, but also loose some of them, as shown in the following examples. In [6] the authors try to minimize the number of timer expirations, in the abstract system, that do not correspond to expirations in the concrete system. They take advantage of the observation that, in practice, the transitions guarded by a timer expiration are supposed to resolve the kind of deadlocks when no other transitions except the ones triggered by timeout signals would be enabled. The timers are represented by processes that send the corresponding timeout signals when the special Promela statement timeout becomes enabled. The timeout statement becomes enabled when no other transition is enabled, in the system. However, there are situations when a behaviour of the concrete system cannot be simulated by the approximate one. Let us consider two concurrent processes, say P1 and P2 , specified by the following transition systems: T1 /A

B/

T2 /B

A/

P1 : • − −−→ • − −−→ • −−→ • − −−→ • P2 : • −

372


where T1 and T2 are timer signals, A and B are normal signals, and X/Y denotes “receive X and send Y to the other process”. If both T1 and T2 expire simultaneously then, in the concrete system, P1 and P2 may exchange signals A and B, and both reach their final states. However, in the abstract system, one of the processes will not be able to reach its final state. Initially, the first transitions of both processes are enabled. If P1 performs its first transition (and thus sends A to P2 ), the first transition of P2 becomes disabled. P2 must discard A, before its first transition becomes enabled again, and thus it will not be able to pass the A/ guard. Similarly, if P2 performs its first transition, P1 will not be able to pass the B/ guard. In the approximation used in [10], one pseudo-process is used to handle all timer expirations. After each set operation this pseudo-process immediately sends the corresponding timeout signal to the input queue of the process that sets the timer. As a result, if an SDL process uses two timers, they can only expire in the order they are set, no matter what values they are set to. Obviously, the behaviour in which an SDL process sets the timers T1 and T2 (in that order) to such values that T2 expires before T1 cannot be simulated by the abstract system.

4

Verification Methodology

The aim of this section is to present the way the real verification process is performed. Industrial-size SDL models normally cannot be verified with existing model-checking tools as a whole, so the first natural task is to split a protocol in some relatively autonomous parts of a reasonable size and apply to them compositional verification. Fortunately, due to their block-structure, SDL-systems can be usually split in a natural way without much effort. The obtained sub-models are not self-contained, i.e. the behaviour of their environment is not specified. Since Spin can only model-check closed systems we need to close our model first. We achieve this by adding an “environment” process specified in SDL at the same hierarchy level as the extracted model itself. The simplest possible approach is to construct an environment producing all the “possible” behaviours but practice shows that this is not of much use in real life. Such an environment leads to adding to the model too many erroneous behaviours and thus one gets too many “false negatives” during model-checking. Local livelocks, cycles with non-progressing time, and non-existing deadlocks are the typical examples of those false-errors. Moreover, since many redundant behaviours are added, this may also lead to a state explosion. Another possibility is to construct an environment being able to send/receive a signal whenever the modelled system is ready to get/send it. Applying such an approach reduces the added behaviours but it still adds some unwanted behaviours caused by sending non-realistic signal sequences. Both these approaches are not safe: in case of adding non-progressing time cycles, we loose some behaviour of the system. So they can be considered as


373

a kind of heuristics only, that may be of some use at the first stage of system debugging. A different approach is to provide an SDL-specification of the “right” environment, i.e. the one, which faithfully models the assumptions under which the component was designed, giving an abstraction of a real environment. Although it makes the soundness of verification results dependent on the quality of the environment model, it usually turns out to be a practical method. The closed SDL-model can be automatically translated into DT Promela through the translators sdl2if and if2pml. Then one should choose between verification of the concrete model with DT Spin and verification of the model with abstracted time in the standard Spin. First, the built-in Spin features (finding deadlocks and livelocks, unreachable code) are used. After correcting discovered structural errors, functional properties defined by a designer or drawn from the informal specification of the system can be verified. It would seem obvious to verify all non-timed properties with an abstractedtime model and all timed properties with a concrete model. However, sometimes it is more convenient to verify non-timed properties with a concrete model as well. If some functional property was proved with the abstracted-time model, it is proved for all possible values of timers. However if it was disproved, or a deadlock in the model was found, the next step is to check whether the erroneous trace given by Spin is a real error in the system or it is a false error caused by adding erroneous behaviour either with abstracting from time or with too abstract specification of the environment. It can happen that the property does not hold for the concrete model, however the erroneous trace given by Spin is one of the added behaviours. This behaviour cannot be reproduced for the SDL model with SDL-simulation tools and we cannot conclude whether the property holds or not. One can not force Spin to give the trace from the non-added behaviours. DT Spin allows to reduce the set of added behaviours guaranteeing that timers are expiring in the correct order. In our verification experiments we had a number of cases when application of DT Spin, instead of Spin, gave a chance to get a real erroneous trace and disprove the property (see the next section).

5

Case Study: Verifying the MASCARA Protocol

We have applied our tools to the verification of an industrial-size communication protocol called MASCARA (Mobile Access Scheme based on Contention and Reservation for ATM), developed by the WAND (Wireless ATM Network Demonstrator) consortium [13]. The protocol is an extension of the ATM (Asynchronous Transfer Mode) networking protocol to wireless networks. A wireless ATM network comprises of a fixed wire-based ATM network that links a number of geographically distributed access points, which transparently extend ATM services to mobile users, via radio links operating in the 5.2 GHz frequency band and achieving data rates of 23.5 MBits/s. The task of MASCARA is to mediate between the mobile users and the access points, to offer

374


the mobile users the advantages of the standard wire-based ATM protocol: high reliability, capacity-on-demand, and service-independent transport. The transparent extension of ATM over radio links is a challenge, as standard ATM has not been designed to work in a wireless environment. The radio medium is characterised by a high bit error rate, the transmission mode is typically broadcast (or at least multicast) and the scarcity of available radio bandwidth calls for a time division duplex (i.e. half duplex) mode. All this leads to the necessity of extra functionality allowing to cope with these dissimilar environmental properties. A crucial feature of MASCARA is the support of mobility. A mobile terminal (MT) can reliably communicate with an access point (AP) only within some area called the AP’s cell. Whenever an MT moves outside the cell of its current AP it has to perform a so-called handover to an AP whose cell the MT has moved into. A handover must be managed transparently with respect to the ATM layer, maintaining the agreed quality of service for the current connections. So the protocol has to detect the need for a handover, select a candidate AP to switch to and redirect the traffic with minimal interruption. The protocol is too large to be automatically verified as a whole so we have concentrated our efforts on the verification of a substantial part called MCL (MASCARA Control). The main purpose of MCL is to support the mobility issues. It contains 9 processes, each with up to 10 states (6 on average). Its main function is to monitor the current radio link quality, gather information about radio link qualities of its neighbouring APs (to make a quick handover, in the case of deterioration of the current link quality), and switch from one AP to another (during the handover procedure). During the first phase of the verification, several deadlocks were found. Most of them were related to improper synchronisation between various request/confirm subprotocols (a component requests a service from another component and waits until the confirmation arrives that the request is either rejected or served). The second source of deadlocks was the potential race conditions between various components of MCL, due to the fully asynchronous communication in SDL (non-blocking sending of messages). The following example describes one of the race conditions we have found. Most MASCARA components must be initialised before they are prepared to serve requests from other components. The components are grouped in various tree-like hierarchies, and the initialisation phase for a group is triggered by sending the INIT signal to the group’s root. Each node that receives the INIT signal resends the signal to all its children. However, in such a cascade of INIT signals there is a possible race condition: Spin found a trace in MCL where an already initialised component tried to immediately request a service from a component that had not been initialised yet. Such a request was simply discarded and thus its confirmation was never sent back, leading to a deadlock in MCL. After correcting these errors, we continued the verification, by exploiting another useful Spin feature—unreachable code diagnosis. The analysis of the unreachable code reported by Spin revealed that some code for serving one particular request is never reached and thus the request for that particular service


375

was never confirmed. Further analysis showed that there was a local deadlock possible. (This local deadlock could not be discovered by Spin, in previous experiments, since Spin can only discover global deadlocks.) Finally, we verified some functional properties that we derived from the informal specification. An example of such a property is given below. One of the tasks of MCL is to periodically update a list that contains information about the quality of radio links with the neighbouring APs. This updating phase is called the TI procedure. In order to judge the quality of a radio link with a particular AP, MCL must connect to that particular AP, so the connection with the current AP is suspended during the whole TI procedure. Therefore, another procedure, checking the quality of the current connection and making the decision on the necessity of a handover, should not interfere with TI procedure. This requirement was encoded as a simple observer for the following safety property: a handover request never comes in between the two messages that mark the beginning and the end of the TI procedure. The verification experiment with Spin, which was supposed to confirm this property, showed instead a trace violating it. Unfortunately, the erroneous trace could not be simulated by the SDL model of MCL (so we got a so-called “false negative”). However, when exactly the same experiment was repeated with DT Spin we got a different erroneous trace which could then be simulated by the SDL model. Thus, the property was indeed violated, DT Spin allowed us to find yet another error in MASCARA protocol. The explanation of the different results obtained with Spin and DT Spin is obvious. The TI procedure is triggered by a timer, so the behaviour of the TI protocol could indeed depend on proper timing. In the model with abstracted time, as used in Spin, timers can expire at any time, so Spin can produce a wrongly timed trace that is not accepted by an SDL simulator (which allows only properly timed traces, of course). After finding a way to re-design the components, some other functional properties were proved. When we planned the first series of verification experiments we expected to reach the limits of Spin and DT Spin quickly. We were proved wrong. In the experiment that consumed the most resources, Spin reported the following statistics: State-vector 416 byte, depth reached 3450, errors: 0 55959 states, stored 23.727 memory usage for states (in MB) 25.582 total memory usage (in MB) 14.2 total time (in seconds) which should be read in the following way: State-vector 416 byte is the memory needed to represent one state. 55959 states, stored is the number of different states found in the model (all the states must be kept during the state space enumeration, so 23.727MB memory was needed for states).

376


depth reached 3450 is the greatest depth reached during the depth-first search (since Spin must keep a state stack of at least this depth, about 1.7MB was needed in addition to the state memory). It is quite likely that with our 2048MB memory we will be able to handle even more complex case studies.

6

Conclusions and Future Work

We have developed a tool, if2pml, that enables the translation from SDL to Promela. It can be used, together with the accompanying tool sdl2if, to model check SDL specifications with Spin. Our approach preserves the timing aspects of SDL. This is in contrast to other translators that we know, which only approximate timing aspects. SDL timers, which expire by sending signals, are in our approach translated into the timer variables provided by DT Promela. We have argued the correctness of this translation. The approach has been successfully used on an industrial case study. More information is available from http://radon.ics.ele.tue.nl/~vires/public/ results. As a future work, we consider to extend the tool by implementing the translation of dynamic process creation in SDL and the save construct. SDL supports various styles of specifying data types. It needs to be investigated how the specification of data aspects can be combined with the translation from SDL to Promela.

Acknowledgments We gratefully acknowledge VERILOG for giving us free access to their ObjectGEODE tool. We would also like to thank Marius Bozga, Lucian Ghirvu, Susanne Graf (Verimag, Grenoble) and Gerard Holzmann (Bell Labs) for fruitful discussions during the implementation of the if2pml tool.

References 1. R. Alur, D.L. Dill, A Theory of Timed Automata, Theoretical Computer Science, 126, pp.183-235, 1994. 2. D. Boˇsnaˇcki, D. Dams, Integrating Real Time into Spin: A Prototype Implementation, S. Budkowski, A. Cavalli, E. Najm, editors, Formal Description Techniques and Protocol Specification, Testing and Verification (FORTE/PSTV’98), Kluwer, 1998. 365, 366 3. M. Bozga, J-C. Fernandez, L. Ghirvu, S. Graf, J.P. Karimm, L. Mounier, J. Sifakis, If: An Intermediate Representation for SDL and its Applications, In Proc. of SDLFORUM’99, Montreal, Canada, 1999. 363, 366, 367


377

4. I. Dravapoulos, N. Pronios, S. Denazis et al., The Magic WAND, Deliverable 3D2, Wireless ATM MAC, September 1997. 5. G. J. Holzmann, Design and Validation of Communication Protocols, Prentice Hall, 1991. Also: http://netlib.bell-labs.com/netlib/spin/whatispin.html 363, 365 6. G.J. Holzmann, J. Patti, Validating SDL Specification: an Experiment, In E. Brinksma, G. Scollo, Ch.A. Vissers, editors, Protocol Specification, Testing and Verification, Enchede, The Netherlands, 6-9 June 1989, pp. 317-326, Amsterdam, 1990. North-Holland. 364, 371 7. G.J. Holzmann, D. Peled, An Improvement of Formal Verification, PSTV 1994 Conference, Bern, Switzerland, 1994. 366 8. A. Olsen et al., System Engineering Using SDL-92, Elsevier Science, NorthHolland, 1997. 363 9. D. Peled, Combining Partial Order Reductions with On-the-Fly Model Checking, Computer Aided Verification CAV 94, LCNS 818, pp. 377-390, 1994. 366 10. H. Tuominen, Embedding a Dialect of SDL in PROMELA, 6th Int. SPIN Workshop, LNCS 1680, pp. 245-260, 1999. 364, 371, 372 11. Verilog, ObjectGEODE tutorial, Version 1.2, Verilog SA, Toulouse, France, 1996. 364, 366, 369 12. VIRES, Verifying Industrially Relevant Systems, Esprit Long Term Research Project #23498, http://radon.ics.ele.tue.nl/~vires, 1996. 367 13. WAND consortium, Magic WAND - Wireless ATM Network Demonstrator, http://www.tik.ee.ethz.ch/~wand, 1996. 364, 373

Salsa: Combining Constraint Solvers with BDDs for Automatic Invariant Checking Ramesh Bharadwaj1 and Steve Sims2 1

Center for High Assurance Computer Systems, Naval Research Laboratory Washington, DC 20375-5320 [email protected] 2 Reactive Systems, Inc. [email protected] www.reactive-systems.com

Abstract. Salsa is an invariant checker for specifications in SAL (the SCR Abstract Language). To establish a formula as an invariant without any user guidance, Salsa carries out an induction proof that utilizes tightly integrated decision procedures, currently a combination of BDD algorithms and a constraint solver for integer linear arithmetic, for discharging the verification conditions. The user interface of Salsa is designed to mimic the interfaces of model checkers; i.e., given a formula and a system description, Salsa either establishes the formula as an invariant of the system (but returns no proof) or provides a counterexample. In either case, the algorithm will terminate. Unlike model checkers, Salsa returns a state pair as a counterexample and not an execution sequence. Also, due to the incompleteness of induction, users must validate the counterexamples. The use of induction enables Salsa to combat the state explosion problem that plagues model checkers – it can handle specifications whose state spaces are too large for model checkers to analyze. Also, unlike general purpose theorem provers, Salsa concentrates on a single task and gains efficiency by employing a set of optimized heuristics.

1

Introduction

Model checking[17] has emerged as an effective technique for the automated analysis of descriptions of hardware and protocols. To analyze software system descriptions, however, a direct application of model checking to a problem (i.e., without a prior reduction of its state space size by the application of abstraction) rarely succeeds [9]. For such systems, theorem proving affords an interesting alternative. Conventional theorem proving systems, however, are often too general or too expensive to use in a practical setting because they require considerable user sophistication, human effort, and system resources. Additionally, the counterexample provided by a model checker when a check fails serves practitioners as a valuable debugging aid. However, in contrast, conventional theorem provers provide little or no diagnostic information (or worse, may not terminate) when a theorem is not true. S. Graf and M. Schwartzbach (Eds.): TACAS/ETAPS 2000, LNCS 1785, pp. 378–395, 2000. c Springer-Verlag Berlin Heidelberg 2000

Salsa: Combining Constraint Solvers with BDDs

379

Salsa is an invariant checker for system descriptions written in a language based on the tabular notation of SCR [24] called SAL (the SCR Abstract Language). Given a logical formula and a system description in SAL, Salsa uses induction to determine whether the formula is true in all states (or transitions) the system may reach. Unlike concurrent algorithms or protocol descriptions, on which model checkers are very effective, practical SAL models usually do not contain interleaving concurrency and are more easily amenable to induction proofs. If a proof fails, Salsa provides a counterexample. Unlike model checkers, however, the returned counterexample is a state or a state pair and not an execution sequence. Also, due to the incompleteness of induction, users must validate a returned counterexample. Salsa has the attributes of both a model checker and a theorem prover: It is automatic and provides counterexamples just like a model checker. Like a theorem prover, it uses decision procedures, can handle infinite state systems, and can use auxiliary lemmas to complete an analysis. The design of Salsa was motivated by the need within the SCR Toolset [23] for more automation during consistency checking [24] and invariant checking [9,22]. Salsa achieves complete automation of proofs by its reliance on decision procedures, i.e., algorithms that establish the logical truth or falsity of formulae of decidable sub-theories, such as the fragment of arithmetic involving only integer linear constraints called Presburger arithmetic. Salsa’s invariant checker consists of a tightly integrated set of decision procedures, each optimized to work within a particular domain. Currently, Salsa implements decision procedures for propositional logic, the theory of unordered enumerations, and integer linear arithmetic. Although they are capable of checking more general properties (such as liveness), in practice model checkers are most often used to check invariant properties. The advantage of using Salsa over a standard model checker for this task is that Salsa can handle large (even infinite state) specifications that current day model checkers cannot analyze. This is due to the use of induction and the symbolic encoding of expressions involving integers as linear constraints. The primary disadvantage of Salsa (and proof by induction in general) is its incompleteness – a failed check does not necessarily imply that a formula is not an invariant because the returned state pair may not be reachable. After some experimentation, we arrived at the following practical method for checking state and transition invariants using Salsa (see Figure 1): Initially apply Salsa. If Salsa returns yes then the property is an invariant of the system, and we are done. If Salsa returns no, then we examine the counterexample to determine whether the states corresponding to the counterexample are reachable in the system. If so, the property is false and we are done. However, if one concludes after this analysis that the counterexample states are unreachable, then one looks for stronger invariants to prove the property. Salsa currently includes a facility that allows users to include such auxiliary lemmas during invariant checking. There are promising algorithms for automatically deducing such invariants [5,6,11,26], although Salsa currently does not implement them.

380

Ramesh Bharadwaj and Steve Sims

Salsa No/Counterexample

SAL Specification S Is I an invariant of S ? Potential Invariant I New I = I

Yes

L Produce auxiliary Lemma L (Manually or with automatic generator)

Is Counterexample Reachable? No

Yes

Fig. 1. Process for applying Salsa

Related Work. The use of SMV [28] and SPIN [25] on software specifications for consistency and invariant checking has been well documented [2,9,16,22]. SCR* [23] is a toolset that includes a consistency checker which uses a method based on semantic tableaux extended to handle simple constraints over the integers and reals. This tool has proved very useful in a number of practical case studies; however, the tool is unable to complete the checks on certain examples involving numbers. Systems that largely automate induction proofs by employing decision procedures include the Stanford Temporal Prover (STeP) [11]. Other tools that are built upon the interactive theorem prover PVS [30] include TAME (Timed Automata Modeling Environment) [3] and the tools of Graf et al. [21,32]. These tools are implemented as a set of special-purpose PVS strategies. The tool InVeSt includes sophisticated algorithms for invariant generation and heuristics for invariant strengthening [5,6]. Also, if invariance cannot be established on a finite abstraction, an execution sequence is provided as a diagnostic. Validity checkers such as Mona [18], Mosel [31], and the Stanford Validity Checker (SVC) [4] are another class of systems that employ decision procedures for proving logical formulae. Although these tools do not directly check invariants, they may be used to discharge the verification conditions generated during an induction proof in a tool such as Salsa. The idea of combining decision procedures for program verification dates back to the work of Shostak [33] and Nelson and Oppen [29]. The decision procedures of Salsa for both propositional logic and enumerated types are based on standard BDD algorithms. The integer constraint solver employs an automatatheoretic algorithm presented in [12], with extensions to handle negative numbers using ideas from [34]. Salsa’s technique of combining BDD algorithms with constraint solvers was largely inspired by the approaches of [14] and [15] where, by incorporating constraint solvers into BDD-based fixpoint computation algorithms, verification of infinite state systems becomes a possibility. However, since the underlying algorithms of these systems are variants of the model checking algorithm for computing a fixpoint, we speculate that Salsa, due to its use of induction, can handle larger specifications than these systems. Also, the constraint solver of [14] is incomplete for integer linear arithmetic, whereas the one used by Salsa is complete. The system of [15], which uses an off-the-shelf backtracking solver that can be very inefficient in practice, can handle a class of non-linear constraints in addition to linear constraints.


381

The rest of this paper is organized as follows. In the following section we introduce the state machines that serve as the underlying models for SAL specifications and define the invariant checking problem. Section 3 describes the core algorithms of Salsa, and Section 4 presents the algorithms and heuristics of the unsatisfiability checker which is used by Salsa to discharge the verification conditions. Section 5 provides some preliminary experimental results of applying Salsa to several practical specifications of moderate size. Finally, Section 6 discusses ongoing work and future research.

2 2.1

Background Model for System Behavior

The SCR Abstract Language (SAL), a specification language based on the SCR Formal Model [24], was designed to serve as an abstract interface to analysis tools such as theorem provers, model checkers, and consistency checkers. An example SCR specification in SAL is presented in Appendix A. Unlike concurrent algorithms or protocol descriptions, practical SAL specifications usually do not involve interleaving concurrency and are therefore more easily amenable to induction proofs. A SAL specification may be translated into a state machine that models a system’s behavior. We now introduce the state machine model for systems and the supporting machinery used in the paper. We define formulae in a simple constraint logic (SCL) by the following grammar: Φ := C | Xb | ¬Xb | Φ ∨ Φ | Φ ∧ Φ C := Ci | Ce Ce := Xe = V ale | Xe = V ale | Xe = Ye | Xe = Ye Ci := SUM ≤ V ali | SUM = V ali | SUM = V ali SUM := V ali × Xi | SUM + SUM

(simple formulae) (constraints) (enum. constraints) (integer constraints)

where Xb , Xe /Ye , and Xi range over boolean, enumerated, and integer variables respectively. Similarly V alb , V ale , and V ali respectively range over constants of the three types. We let V ars(Φ) denote the free variables in Φ. Set V ars(Φ) is partitioned by the three variable types: V ars(Φ) = V arsb (Φ) ∪ V arse (Φ) ∪ V arsi (Φ). Note that SCL formulae will be interpreted in the context of either 1) a single state s that maps variable names to values or 2) a pair of states (s, s ), where s is a successor of s. We adopt the convention that primed formulae and variable names (those ending in ) are evaluated in the “new state” whereas unprimed names are evaluated in the “old state.” Formulae containing primed variables are called two-state predicates and those without primed variables are called one-state predicates. Definition 1. A state machine Σ is a quadruple V, S, θ, ρ where – V is a set of variable names. This set is partitioned into monitored variables which denote environmental quantities the system observes; controlled variables which denote quantities in the environment that the system controls;

382


and internal variables which are updated by the system but not visible to the environment. – S is the set of system states such that each state s ∈ S maps each x ∈ V to a value in its set of legal values. We write x(s) to mean the value of variable x in state s, Φ1 (s) to mean the value of one-state predicate Φ1 evaluated in s, and Φ2 (s, s ) to mean the value of two-state predicate Φ2 evaluated with values from s replacing unprimed variables and values from s replacing primed variables. – θ is a one-state SCL predicate defining the set of initial states. – ρ is a two-state SCL predicate defining the transitions (execution steps) of Σ. A state s may evolve to a state s if ρ(s, s ) is true. The transition relation ρ additionally includes environmental assumptions as well as assumptions introduced by users. For details, see [10].

2.2

The Invariant Checking Problem

Definition 2. Given a state machine Σ = V, S, θ, ρ , a state s ∈ S is reachable (denoted ReachableΣ (s)) if and only if θ(s) or ∃s2 ∈ S : ReachableΣ (s2 )∧ρ(s2 , s) Definition 3. Given a state machine Σ = V, S, θ, ρ , a one-state SCL predicate Φ1 is a state invariant of Σ if and only if ∀s ∈ S : ReachableΣ (s) ⇒ Φ1 (s) A two-state SCL predicate Φ2 is a transition invariant of Σ if and only if ∀s, s ∈ S : (ReachableΣ (s) ∧ ρ(s, s )) ⇒ Φ2 (s, s ) The invariant checking problem : Given a state machine Σ and a one(two)-state predicate Φ, determine whether Φ is a state(transition) invariant.

3

The Invariant Checker

Theorem 1. Let Σ = V, S, θ, ρ , then Φ1 is a state invariant of Σ if the following hold: 1) ∀s ∈ S : θ(s) ⇒ Φ1 (s) and 2) ∀s, s ∈ S : Φ1 (s) ∧ ρ(s, s ) ⇒ Φ1 (s ) Proof: By induction on the number of steps of Σ to reach a state. Theorem 2. Let Σ = V, S, θ, ρ , then Φ2 is a transition invariant of Σ if the following holds: ∀s, s ∈ S : ρ(s, s ) ⇒ Φ2 (s, s ) Proof: Follows directly from Definition 3.


3.1

383

The Invariant Checking Algorithms

Using Theorems 1 and 2 we check invariants of Σ = V, S, θ, ρ as follows: State Invariants. To determine if Φ1 is a state invariant of Σ: 0. if ¬Φ1 is unsatisfiable then return yes. 1. if θ ∧ ¬Φ1 is not unsatisfiable then return no and the satisfying state as counterexample. 2. if Φ1 ∧ ρ ∧ ¬Φ1 is unsatisfiable then return yes. else return no and the satisfying state pair as counterexample. Transition Invariants. To determine if Φ2 is a transition invariant of Σ: 0. if ¬Φ2 is unsatisfiable then return yes. 1. if ρ ∧ ¬Φ2 is unsatisfiable then return yes. else return no and the satisfying state pair as counterexample. These algorithms are sound but not complete – whenever Salsa returns yes the given formula is an invariant; however, a no answer with a counterexample (a state or a state pair) does not necessarily mean that the formula is not an invariant. Consequently, the user must validate that the counterexample is reachable1 . Either there is a problem or additional theorems are used to “push through” the invariant. Of course, all added theorems should be proved as invariants by the user (either with Salsa or by some other means). 3.2

Optimizations

A naive application of the above algorithms to invariant checking will always fail, even for specifications of a moderate size. We perform several optimizations in Salsa to make invariant checking feasible. One important technique used extensively is to cache results as they are computed. In addition to the caching provided by BDD algorithms, we cache the results of calls to the integer constraint solver, the BDD encodings of components of the transition relation, etc. To partition an unsatisfiability check into simpler sub-problems, we use a technique called disjunctive partitioning which corresponds to a case split in a standard proof. This approach takes advantage of the fact that a disjunction is unsatisfiable only if each of its disjuncts is unsatisfiable. The disjunctive form of the transition relation in SAL specifications has proven to be an effective basis for disjunctive partitioning. The application of abstraction [9,22] is also very beneficial. We restrict ourselves to applying abstractions that are both sound and complete, by which we mean the following. Given a property Φ and a state machine Σ, an abstraction ΣA is a sound and complete abstraction of Σ relative to Φ when Φ is an invariant of ΣA if and only if Φ is an invariant of Σ. Currently, we apply what is termed “Abstraction Method 1” [8,9] that uses the set of variable names occurring in the predicate Φ and dataflow analysis to eliminate unneeded variables. 1

The single state counterexample returned by step 1 of the algorithm for State Invariants (for a failed check of unsatisfiability of θ ∧¬Φ1 ) is always a true counterexample.

384

4 4.1


The Unsatisfiability Checker Overview

To discharge the verification conditions that arise during invariant checking, Salsa uses a routine that decides the unsatisfiability of SCL formulae. Both the problem of propositional unsatisfiability and the decision problem for integer linear arithmetic are NP-complete [20], and known algorithms for the latter problem have super-exponential worst case behavior [19]. The unsatisfiability checker uses a combination of binary decision diagrams and an integer constraint solver as a decision procedure for SCL formulae. Using the formula x ≤ 4 ∧x = 7 as an example we outline the algorithm (for specifics, see [10]). The initial step transforms a formula into one containing only logical connectives and boolean variables. This is done by assigning a fresh boolean variable to each integer constraint in the original formula. Fresh boolean variables are also introduced to encode expressions involving variables of enumerated type in the obvious way [10,28]. For the example, substituting a for x ≤ 4 and b for x = 7 yields the formula a ∧ b. Next, a BDD for this formula (which encodes the propositional structure of the original formula) is constructed: a

b

False

True

The next step brings in the information contained in the integer constraints. This is done by searching for paths from the root to “True”, each path yielding a set of integer constraints. For the example, the only path from the root to “True” sets both a and b to true, which yields the set {x ≤ 4, x = 7}. The final step is to determine whether each such set is infeasible (i.e., has no solution) using an integer constraint solver. If a set is feasible, this information is returned to the user as a counterexample. For the example, the (single) set of constraints is infeasible and the formula is unsatisfiable. We now describe the integer constraint solver in detail. 4.2

The Integer Constraint Solver

As an initial step, a set of integer constraints is partitioned into independent subsets. For example, the set of constraints {x < 4, x > 7, y < 10} may be partitioned into {x < 4, x > 7} and {y < 10}. Definition 4. Constraints c1 and c2 are independent if V ars(c1 )∩V ars(c2 ) = ∅. The partition of a set of constraints CS = {c1 , ..., cn } into independent subsets (denoted Π(CS)) is defined as Π(CS) = {CS1 , ..., CSm } such that:


385

1. Π(CS) partitions CS. 2. Constraints in different partitions are independent. 3. For each partition containing more than one constraint, every constraint in the partition depends on some other constraint in the partition. To compute Π(CS) Salsa uses a union-find algorithm that starts with each constraint in its own partition and iteratively merges partitions when they contain dependent constraints. After partitioning a set of constraints into independent subsets, an integer constraint solver determines the feasibility of each independent subset. For a set of constraints, we may conclude that the whole set is infeasible if any independent subset is infeasible. Salsa’s constraint solver is a decision procedure that determines whether a set of integer constraints is infeasible, i.e., given {c1 , c2 , ..., cn } the solver checks whether c1 ∧c2 ∧...∧cn is unsatisfiable. Note that the ci are terms from the integer constraint fragment of SCL (defined in Section 2.1). Among several methods available for solving linear integer constraints, one possible approach is the use of automata theoretic methods. The idea, which dates back to B¨ uchi in the early sixties [13], is to associate with each constraint an automaton accepting the solutions of the constraint. The feasibility of a set of constraints may then be computed by constructing a composite automaton (from the constraint automata for each ci , 1 ≤ i ≤ n) using the standard construction for automata intersection. Salsa’s solver employs the algorithm of Boudet and Comon [12], extended to handle negative number based on ideas of Wolper [34]. We give an overview of the algorithm, for details see the above references. Let us first examine how a constraint automaton may encode constraints over the natural numbers, and then extend this idea to automata for integer constraints. Let c be a constraint, let V ars(c) = {x1 , x2 , ..., xn }, and let c[y1 /x1 , y2 /x2 , ..., yn /xn ] denote the result of substituting yi for each xi in c. We then define the constraint automaton for c, denoted CAut(c), such that the language of CAut(c) is {(y1 , ..., yn ) ∈ Intn | c[y1 /x1 , ..., yn /xn ] is true}. Each number yi is encoded in base two, so each yi is a string in {0, 1}∗. The constraint automaton will recognize solutions to a constraint by simultaneously reading one bit for each of its free variables, i.e., the edges of the automaton will be labeled by elements of {0, 1}n. For example, the satisfying assignments of “x1 + x2 = 4” are {(0, 4), (1, 3), (2, 2), (3, 1), (4, 0)}, so CAut(x1 +x2 = 4) encodes this as shown in Figure 2. We now explain how to construct a constraint automaton for a constraint c of the form a1 x1 + a2 x2 + . . . + an xn = b, where a1 , a2 , . . . an , b are integer constants and x1 , x2 , . . . xn are variables over the natural numbers. The resulting automaton will be of the form CAut(c) = S, E, St, Acc where S ⊆ Integers is the set of states and E ⊆ S × {0, 1}n × S is the set of edges, St ⊆ S is the set of start states, and Acc ⊆ S is the set of accepting states. During construction we let Snew represent the set of states still to be processed. The construction proceeds backwards from the accepting state as follows.

386

Ramesh Bharadwaj and Steve Sims (x1 , x2 ) Accepted string 000 (0,4) 100 01 (1,3) 11 10 (2,2) 10 11 (3,1) 01 100 (4,0) 000

0 1

0 0

0

1 1

1 1 0

0 0

4 0 0

1 1

2

Fig. 2. The constraint automaton encoding x1 + x2 = 4 1. Initialize both Snew and Acc to contain only b (the right hand side of the constraint) and initialize S = E = St = ∅. 2. Remove a state s from Snew for processing. (a) Add s to S. If s = 0 then also add s to St. (b) For each β ∈ {0, 1}n where β = b1 , b2 , ..., bn let δ = s − (a1 b1 + a2 b2 + . . . + an bn ) in if δ is even then β • add edge (δ div 2) −→ s to E • if (δ div 2) ∈ / (S ∪ Snew ) then add (δ div 2) to Snew 3. if Snew = ∅ then return S, E, St, Acc else goto 2.

Some simple modifications to the above algorithm extend it to handle negative numbers. For integer constraint c, the states of CAut(c) range over integers and we add a special state I that will encode the start state, thus S ⊆ Int ∪ I. Instead of the standard binary encoding employed for natural numbers the two’s complement representation is used for integers. The above algorithm must also be modified to handle the sign bit of the two’s complement notation via a special encoding for the start state (I) and extra edges from I. We do this by removing “if s = 0 then also add s to St” from 2(a) and adding the following to 2(b) above. if s = (−a1 b1 − a2 b2 − . . . − an bn )

β

then add I to S and St and add edge I −→ s to E.

The basic algorithm may also be changed to build constraint automata for constraints involving “=” and “≤”. For “=” the construction is exactly the same except that Acc = S − b, i.e., the accepting state becomes non-accepting and all others become accepting. For details of the slightly more complicated modifications for “≤” see [10]. The constraint automaton for a set of constraints CS = {c1 , c2 , ..., cn }, den noted CAut(CS), is defined as CAut(CS) = i=1 CAut(ci ). The automaton CAut(CS) is constructed on the fly, thereby avoiding the need to build each CAut(ci ). Let Si denote the states of CAut(ci ), then the states of CAut(CS) are SCS ⊆ S1 × S2 × . . . × Sn . An unsatisfiability check of CS then proceeds backwards from the accepting state and terminates with false when the initial state is reached or terminates with true if the automaton construction completes without reaching the start state.


5 5.1

387

Empirical Results Motivation

Salsa was designed expressly for the problems of consistency checking and invariant checking SCR requirements specifications. More specifically, the consistency checker of the SCR Toolset [23] was unable to carry out certain checks, such as checks for unwanted nondeterminism called disjointness checks, especially on specifications containing expressions with numbers. We have also been using SPIN and SMV, and more recently TAME [3], to verify user formulated properties of SCR specifications. We compare Salsa with TAME/PVS to gain an insight into how well the Salsa approach performs in relation to that of a state-of-the-art theorem prover. We compare Salsa with model checkers for the following reason. During the course of our experiments with SCR specifications we have discovered that for model checking to succeed on these specifications requires the application of abstraction, which currently requires user-direction but is automatable [9,22]. Further, SPIN and SMV are unable to provide a definitive answer for invariant checks on a number of examples, especially when they contain a large number of expressions with numbers [27]. Also, since several researchers are currently investigating the use of SPIN and SMV for invariant checking software specifications, it is our intention to demonstrate that Salsa affords a viable, perhaps more automated and cheaper, alternative to model checking. Whereas mechanical theorem provers are regarded as being difficult to use and therefore restricted to sophisticated users, model checking too is often misrepresented as fully automatic or “push button”. Our intention is to demonstrate an approach to invariant checking that avoids both the ad hoc abstraction used in model checking and the sophistication required to apply mechanical theorem proving. The specifications we use in our experiments were developed using the SCR Toolset. Since Salsa seems to work well on all of this limited set of examples, readers may express skepticism about the generality of our results – they may feel that there must be benchmarks for which the roles would be reversed. By using induction, abstract encodings for linear constraints, and application-specific heuristics, our experience is that the Salsa approach can in general be more efficient than fixpoint computation over a finite domain, i.e., model checking. However, Salsa has the disadvantage of not working in all cases, due to the associated problem of incompleteness. Test Cases. These include a simplified specification of the control software for a nuclear power plant [24] (safety-injection), versions of the bomb-release component of the flight-control software of an attack aircraft [1] (bomb-release-1 and bomb-release-2), a simplified mode control panel for the Boeing 737 autopilot [7] (autopilot), a control system for home heating (home-heating), an automobile cruise control system (cruise-control), a navy application [27] (navy), the mode logic for the Operational Flight Program of an attack aircraft [1] (a7-modes), and a weapons control panel [22] (wcp).

388

5.2


Disjointness Checking

To evaluate the performance of Salsa, we checked the above specifications for disjointness errors (unwanted nondeterminism) and compared the results with the consistency checker of the SCR Toolset. The results of our experiments are shown in the table of Figure 3. No auxiliary lemmas were used for any of the checks. The column labeled “number of verification conditions” indicates how many invariant checks are required to establish disjointness for the corresponding entire specification. The number of BDD variables is an indicator of a specification’s size, and the number of integer constraints correlates loosely with the degree to which integers are used in the specification. In these tables, symbol “∞t ” means that the corresponding system either ran out of memory or failed to terminate (over a weekend). The column labeled “number of failed VCs” shows the number of verification conditions that were not provable. Note: for the specification a7-modes Salsa reports more failed VCs than the SCR toolset because certain cases of overlap in table entries are misdiagnosed as disjointness errors when they should probably be warnings. For specification cruise-control Salsa establishes disjointness in three cases for which the SCR Toolset cannot. The tests were conducted on a PC running Linux with a 450 MHz Pentium II processor and 256 MBytes RAM.

Time (in seconds) Number of Number of to Check Disjointness Failed VCs Verification BDD SCR SCR Specification Conditions Variables Constraints Toolset Salsa Toolset Salsa Specifications containing mostly booleans and enumerated types safety-injection 13 16 3 0.5 0.2 0 0 bomb-release-1 12 34 9 0.4 0.2 0 0 a7-modes 6171 158 3 145.9 68.9 110 152 Specifications containing mostly numerical variables home-heating 98 112 55 ∞t 4.8 n.a. 0 cruise-control 123 114 75 21.0 3.6 6 3 navy 397 147 102 390.1 198.2 0 0 bomb-release-2 339 319 230 ∞t 246.0 n.a. 11

Fig. 3. Results of Disjointness Checks

Figure 3 shows that for specifications containing mostly variables of boolean and enumerated type, both the SCR Toolset and Salsa can complete the analysis but Salsa is somewhat faster. For specifications containing mostly numerical variables, there were two specifications in which Salsa could perform the analysis but the SCR Toolset could not.


5.3

389

Checking Application Properties

To evaluate Salsa’s performance on properties formulated by users, we compared the run times with the theorem prover TAME/PVS and the two popular model checkers SPIN [25] and SMV [28]. (We used SPIN Version 2.9.7 of April 18, 1997, SMV r2.4 of December 16, 1994, and PVS version 2.1 for our experiments.) The results are shown in Figure 4. Note that the PVS proof times do not include time for type checking, which can be substantial. We ran the experiments on a SPARC Ultra-2 running Solaris with a 296 MHz UltraSparc II processor and 262 MBytes RAM. All Salsa proofs were completely automatic, but for property 304 of wcp, which had to be split into two verification conditions for Salsa to complete; the time indicated with an asterisk is the sum of the running times of the two sub-proofs. All auxiliary lemmas were automatically generated by the algorithm of [26] and proved as invariants by Salsa. Both SPIN and SMV ran out of memory (or ran indefinitely) when run on all examples other than safety-injection. This is probably because they contain a large number of numerical variables. Dashes (“-”) in the SMV column indicate that we did not run SMV on these examples. Specification

Number of Properties

safety-injection 4 bomb-release-1 2 autopilot 2 navy 7 wcp property 303 property 304 property 305

Time (in seconds) Properties Auxiliary Salsa SPIN SMV TAME/PVS Proved? Lemmas Used? 0.8 36.0 155.0 68 Yes Yes 1.3 ∞t ∞t 30 Yes No 1.5 ∞t ∞t 82 Yes No 396.0 ∞t 874 Yes Yes 295.4 ∞t ∞t No No 923.3∗ ∞t 19 No No 2.4 ∞t 8 No No

Fig. 4. Results of Invariant Checks

6

Conclusions

In this paper, we show that the Salsa approach affords a useful alternative to model checking, especially for the analysis of descriptions of software. Mechanical theorem provers such as PVS are regarded as being too general and too expensive to use, requiring sophistication on the part of their users. Salsa provides the advantages of both mechanical theorem proving and model checking – it is automatic, easy to use, and provides counterexamples along the lines of model checkers. The counterexamples, however, are over two adjacent states and not entire execution sequences. The main advantage of our approach is that we are able to handle much larger specifications, even infinite state specifications, that current day model checkers cannot handle (without a prior application of abstraction).

390


The major disadvantage of the Salsa approach over conventional model checking is its incompleteness – a proof failure does not imply that the theorem does not hold. However, this is generally true of model checking too, because an initial application of model checking to a practical problem rarely succeeds – users of model checkers routinely apply abstractions (mostly manually and sometimes in ad-hoc ways) for model checking to proceed [9]. These abstractions are usually sound, but are often incomplete – consequently, if one model checks an incomplete abstraction of a problem, the entire process is incomplete. Model checking, however, remains very useful for refuting properties, i.e., as a debugging aid. As with Salsa, the resulting counterexample must be validated against the full specification. We plan to extend Salsa to include decision procedures for the rationals, the congruence closure algorithm to reason about uninterpreted function symbols, and special-purpose theories such as for arrays and lists. We would also like to reason about quantifiers. We have designed Salsa to be general, i.e., to check a variety of state machine models for invariant properties. We plan on trying out the tool on state machine models other than SCR.

Acknowledgements This project is funded by the Office of Naval Research. The work of Steve Sims was carried out at NRL under a contract from ONR. We thank Susanne Graf, Connie Heitmeyer, Ralph Jeffords, and the anonymous referees for their comments on previous drafts of this paper. Connie’s very useful comments, her constructive criticism, and numerous suggestions for improvement greatly helped the presentation. Ralph was the first user of Salsa! We thank Myla Archer for data on the PVS proofs and Ralph for the mode invariants.

References 1. T. A. Alspaugh et al. Software requirements for the A-7E aircraft. Technical Report NRL-9194, Naval Research Laboratory, Wash., DC, 1992. 387 2. R. J. Anderson, P. Beame, et al. Model checking large software specifications. In Proc. Fourth ACM FSE, October 1996. 380 3. M. Archer, C. Heitmeyer, and S. Sims. TAME: A PVS interface to simplify proofs for automata models. In Proc. User Interfaces for Theorem Provers, Eindhoven, Netherlands, July 1998. Eindhoven University CS Technical Report. 380, 387 4. C. Barrett, D. Dill, and J. Levitt. Validity checking for combinations of theories with equality. In Formal Methods In Computer-Aided Design, volume 1166 of LNCS, pages 187–201, November 1996. 380 5. S. Bensalem and Y. Lakhnech. Automatic Generation of Invariants. Formal Methods in Systems Design, July 1998. 379, 380 6. S. Bensalem, Y. Lakhnech, and H. Saidi. Powerful techniques for the automatic generation of invariants. In Conference on Computer Aided Verification CAV’96, LNCS 1102, July 1996. 379, 380


391

7. R. Bharadwaj and C. Heitmeyer. Applying the SCR requirements method to a simple autopilot. In Proc. Fourth NASA Langley Formal Methods Workshop (LFM97), NASA Langley Research Center, September 1997. 387 8. R. Bharadwaj and C. Heitmeyer. Verifying SCR requirements specifications using state exploration. In 1st ACM Workshop on Autom. Analysis of Software, 1997. 383 9. R. Bharadwaj and C. Heitmeyer. Model checking complete requirements specifications using abstraction. Journal of Automated Software Eng., January 1999. 378, 379, 380, 383, 387, 390, 393 10. R. Bharadwaj and S. Sims. Salsa: Combining decision procedures for fullyautomatic verification. Technical report, Naval Research Laboratory, To appear. 382, 384, 386 11. N. Bjorner, A. Browne, M. Colon, B. Finkbeiner, Z. Manna, H. Sipma, and T. Uribe. Verifying temporal properties of reactive systems: A step tutorial. Formal Methods in System Design, 1999. 379, 380 12. A. Boudet and H. Comon. Diophantine equations, Presburger arithmetic and finite automata. In Trees and Algebra in Programming – CAAP, LNCS 1059, 1996. 380, 385 13. J. R. B¨ uchi. On a decision method in restricted second order arithmetic. In Proc. Int. Congress Logic, Methodology, and Philosophy of Science, pages 1–11. Stanford University Press, 1960. 385 14. T. Bultan, R. Gerber, and C. League. Verifying systems with integer constraints and boolean predicates: A composite approach. Technical Report UMIACS-TR97-62, University of Maryland, College Park, MD, August 1997. 380 15. W. Chan, R. Anderson, P. Beame, and D. Notkin. Combining constraint solving with symbolic model checking for a class of systems with non-linear constraints. In Computer Aided Verification, LNCS, pages 316–327, 1997. 380 16. William Chan, Richard J. Anderson, Paul Beame, Steve Burns, Francesmary Modugno, David Notkin, and Jon D. Reese. Model checking large software specifications. IEEE Trans. on Softw. Eng., 24(7), July 1998. 380 17. E. M. Clarke, E. Emerson, and A. Sistla. Automatic verification of finite state concurrent systems using temporal logic specifications. ACM Trans. on Prog. Lang. and Systems, 8(2):244–263, April 1986. 378 18. J. Elgaard, N. Klarlund, and A. Moller. Mona 1.x: new techniques for ws1s and ws2s. In Computer Aided Verification, CAV ’98, LNCS 1427, 1998. 380 19. Fischer and Rabin. Super-exponential complexity of Presburger arithmetic. In Complexity of Computation: Proceedings of a Symposium in Applied Mathematics of the American Mathematical Society and the Society for Industrial and Applied Mathematics, 1974. 384 20. M.R. Garey and D.S. Johnson. Computers and Intractability: A guide to the theory of NP-Completeness. W.H. Freeman and Company, 1979. 384 21. S. Graf and H. Saidi. Verifying invariants using theorem proving. In Conference on Computer Aided Verification CAV’96, LNCS 1102, Springer Verlag, 1996. 380 22. C. Heitmeyer, J. Kirby, B. Labaw, M. Archer, and R. Bharadwaj. Using abstraction and model checking to detect safety violations in requirements specifications. IEEE Transactions on Software Engineering, 24:927–947, November 1998. 379, 380, 383, 387 23. C. Heitmeyer, J. Kirby, B. Labaw, and R. Bharadwaj. SCR*: A toolset for specifying and analyzing software requirements. In Proc. Computer-Aided Verification, 10th Annual Conf. (CAV’98), Vancouver, Canada, June 1998. 379, 380, 387

392


24. C. L. Heitmeyer, R. D. Jeffords, and B. G. Labaw. Automated consistency checking of requirements specifications. ACM Transactions on Software Engineering and Methodology, 5(3):231–261, July 1996. 379, 381, 387 25. G. J. Holzmann. The model checker SPIN. IEEE Trans. on Softw. Eng., 23(5):279– 295, May 1997. 380, 389 26. R. Jeffords and C. Heitmeyer. Automatic generation of state invariants from requirements specifications. In Proc. Sixth ACM SIGSOFT Symp. on Foundations of Software Engineering, November 1998. 379, 389 27. J. Kirby, Jr., M. Archer, and C. Heitmeyer. SCR: A practical approach to building a high assurance COMSEC system. In Proceedings of the 15th Annual Computer Security Applications Conference (ACSAC ’99), December 1999. 387 28. K. L. McMillan. Symbolic Model Checking. Kluwer Academic Publishers, 1993. 380, 384, 389 29. G. Nelson and D. C. Oppen. Simplification by cooperating decision procedures. ACM Transactions on Programming Languages and Systems, 1(2):245–257, 1979. 380 30. S. Owre, J. Rushby, N. Shankar, and F. von Henke. Formal verification for faulttolerant architectures: Prolegomena to the design of PVS. IEEE Transactions on Software Engineering, 21(2):107–125, February 1995. 380 31. P.Kelb, T.Margaria, M.Mendler, and C.Gsottberger. Mosel: A flexible toolset for monadic second–order logic. In Workshop on Tools and Algorithms for the Construction and Analysis of Systems (TACAS’97), volume 1217 of (LNCS), pages 183–202, Heidelberg, Germany, March 1997. Springer–Verlag. 380 32. Y. Lakhnech S. Bensalem and S. Owre. InVeSt: A tool for the verification of invariants. In Proc. Computer-Aided Verification, 10th Annual Conf. (CAV’98), Vancouver, Canada, June 1998. 380 33. Robert E. Shostak. Deciding combinations of theories. JACM, 31(1):1–12, January 1984. 380 34. P. Wolper and B. Boigelot. Verifying systems with infinite but regular state spaces. In Computer Aided Verification – 10th Int’l. Conference, LNCS 1427, 1998. 380, 385

A

SAL Specification of Safety Injection System

A module is the unit of specification in SAL and comprises variable declarations, assumptions and guarantees, and definitions. The assumptions section typically includes assumptions about the environment and previously proved invariants (lemmas). The required invariants of a module are specified in the guarantees section. The definitions section specifies updates to internal and controlled variables. A one-state definition, of the form var x = rhs1 (where rhs1 is a one-state SAL expression), defines the value of variable x in terms of the values of other variables in the same state. A two-state variable definition, of the form var x initially init := rhs2 (where rhs2 is a two-state SAL expression), requires the initial value of x to equal expression init; the value of x in the “new” state of each state transition is defined in terms of the values of variables in the “new” state as well as the “old” state. Expression @T(x) WHEN y is syntactic sugar for ¬x ∧ x ∧ y and @F(x) denotes @T(NOT x). A conditional expression consists of a sequence of branches “[] guard → expression”, where the guards


393

are boolean expressions, bracketed by the keywords “if” and “fi”. In a given state, the value of a guarded expression is equivalent to the expression on the right hand side of the arrow whose associated guard is true. If more than one guard is true, the expression is nondeterministic. A conditional event expression (which is bracketed by the keywords “ev” and “ve”) requires each guard to denote an event, where an event is a two-state expression that is true in a pair of states only if they differ in the value of at least one state variable. We specify in SAL a simplified version of a control system for safety injection [9]. The system monitors water pressure and injects coolant into the reactor core when the pressure falls below a threshold. The system operator may override safety injection by pressing a “Block” button and may reset the system by pressing a “Reset” button. To specify the requirements of the control system, we use variables WaterPres, Block, and Reset to denote the monitored quantities and variable SafetyInjection to denote the controlled quantity. The specification includes a mode class Pressure, an abstract model of WaterPres, which has three modes: TooLow, Permitted, and High. It also includes a term Overridden and several conditions and events.

394


module sis functions Low = 900; Permit = 1000; monitored variables Block, Reset : {On, Off}; WaterPres : int in [0,2000]; controlled variables SafetyInjection : {On, Off}; internal variables Overridden : bool; Pressure : {TooLow, Permitted, High}; assumptions /* Mode invariant generated by the algorithm of Jeffords [26] */ LemmaZ = (Overridden => Reset = Off and not (Pressure = High)); guarantees /* The following properties are true */ Property1 = (Reset = On and Pressure != High) => not Overridden; Property2 = (Reset = On and Pressure = TooLow) => SafetyInjection = On; /* The following properties are false */ Property3 =(Block = Off and Pressure = TooLow) => SafetyInjection = On; Property4 =(@T(Pressure=TooLow) when Block=Off) => SafetyInjection’=On; definitions var Overridden initially false := ev [] @T(Pressure = High) -> false [] @T(Block = On) when (Reset = Off and Pressure != High) -> true [] @T(Pressure != High) or @T(Reset = On) when (Pressure != High) -> false ve

Salsa: Combining Constraint Solvers with BDDs var Pressure initially TooLow := case Pressure [] TooLow -> ev [] @T(WaterPres [] Permitted -> ev [] @T(WaterPres [] @T(WaterPres ve [] High -> ev [] @T(WaterPres esac

>= Low) -> Permitted < Low) -> TooLow >= Permit) -> High

ve

< Permit) -> Permitted ve

var SafetyInjection = case Pressure [] High, Permitted -> if [] true -> Off [] false -> On fi [] TooLow -> if [] Overridden -> Off [] not Overridden -> On fi esac end module

Fig. 5. SAL specification of Safety Injection System

395

Symbolic Model Checking of Probabilistic Processes Using MTBDDs and the Kronecker Representation Luca de Alfaro1 , Marta Kwiatkowska2 , Gethin Norman2 , David Parker2, and Roberto Segala3 1

3

Department of Electrical Engineering and Computing Science, University of California at Berkeley [email protected] 2 University of Birmingham, Birmingham B15 2TT, United Kingdom {M.Z.Kwiatkowska,G.Norman,D.A.Parker}@cs.bham.ac.uk Dipartimento di Scienze dell’Informazione, Universit` a di Bologna, Mura Anteo Zamboni 7, 40127 Bologna, Italy [email protected]

Abstract. This paper reports on experimental results with symbolic model checking of probabilistic processes based on Multi-Terminal Binary Decision Diagrams (MTBDDs). We consider concurrent probabilistic systems as models; these allow nondeterministic choice between probability distributions and are particularly well suited to modelling distributed systems with probabilistic behaviour, e.g. randomized consensus algorithms and probabilistic failures. As a specification formalism we use the probabilistic branching-time temporal logic PBTL which allows one to express properties such as “under any scheduling of nondeterministic choices, the probability of φ holding until ψ is true is at least 0.78/at most 0.04 ”. We adapt the Kronecker representation of (Plateau 1985), which yields a very compact MTBDD encoding of the system. We implement an experimental model checker using the CUDD package and demonstrate that model construction and reachability-based model checking is possible in a matter of seconds for certain classes of systems consisting of up to 1030 states.

1

Introduction

There have been many advances in the BDD technology since BDDs were first introduced and applied to symbolic model checking [10,25]. There are several free and commercial BDD packages in existence, as well as a range of alternative techniques for efficient automatic verification. Model checking tools (to mention smv, SPIN, fdr2) are extensively used by industrial companies in the process of developing new designs for e.g. hardware circuits, network protocols, etc. More

Supported in part by EPSRC grant GR/M04617. Supported in part by EPSRC grant GR/M13046.


396

Luca de Alfaro et al.

recently tremendous progress has been made with tools for the model checking of real-time systems, e.g. Uppaal [6]. One area that is lagging behind as far as experimental work is concerned, despite the fact that the fundamental verification algorithms have been known for over a decade [32,15,28], is model checking of probabilistic systems. This is particularly unsatisfactory since many systems currently being designed would benefit from probabilistic analysis performed in addition to the conventional, qualitative checks involving temporal logic formulas or reachability analysis available in established model checking tools. This includes not only quality of service properties such as “with probability 0.9 or greater, the system will respond to the request within time t”, but also steady-state probability (until recently, see [17,4], separate from temporal logic model checking), which allows the computation of characteristics such as long-run average, resource utilization, etc. In order to support efficient verification of probabilistic systems, BDD-based packages must allow a compact representation for sparse probability matrices. Such a representation, Multi-Terminal Binary Decision Diagrams (MTBDDs), was proposed in [14] along with some matrix algorithms. MTBDDs are also known as Algebraic Decision Diagrams (ADDs) [1] and are implemented in the Colorado University Decision Diagram (CUDD) package of Fabio Somenzi [31]. Based on [22], an MTBDD-based symbolic model checking procedure for purely probabilistic processes (state-labelled discrete Markov chains) for the logic PCTL of [22] (a probabilistic variant of CTL) was first presented in [3], and since extended to concurrent probabilistic systems in [2] (without implementation). Similarly, a symbolic model checking procedure for continuous time Markov chains is proposed in [4]. An alternative representation for Markov chains called Probabilistic Decision Graphs (PDGs) was introduced in [9], where early experimental results are also reported. In this paper we consider concurrent probabilistic systems [5], based on Markov Decision Processes [7], similar to those of [32,8]. These are state-labelled systems which admit nondeterministic choice between discrete probability distributions on the successor states, and are particularly appropriate for the representation of randomized distributed algorithms, fault-tolerant and self-stabilising systems. The model checking procedure, first proposed in [15,8] for the case without fairness and extended to incorporate fairness constraints in [5,18], reduces to the computation of the minimum/maximum reachability probability. We can derive a set of linear inequalities, and maximize/minimize the sum of the components of the solution vector subject to the constraints given by the inequalities. Multi-Terminal Binary Decision Diagrams [14] have the same structure as BDDs, except that terminals other than 0 and 1 are allowed. The similarity between the two types of diagrams means that many BDD operations generalise to the MTBDD case. MTBDDs are known to yield a compact and efficient representation for sparse matrices [14]. They share many positive features with BDDs: because they exploit regularity and sharing, they allow the representation of much larger matrices than standard sparse matrix representations. MTBDDs also combine well with BDDs in a shared environment, thus allowing reacha-

Symbolic Model Checking of Probabilistic Processes

397

bility analysis via conversion to BDDs (which coincide with 0-1 MTBDDs) and conventional BDD reachability. However, MTBDDs also inherit negative BDD features: they are exponential in the worst case, very sensitive to variable ordering heuristics, and may be subject to a sudden, unpredictable, increase in size as the regularity of the structure is lost through performing operations on it. As a consequence, algorithms that change the structure of the matrix, such as Gaussian elimination for solving linear equations [1] or simplex for solving systems of linear inequalities [24], are significantly less efficient than state-of-the-art sparse matrix packages due to the loss of regularity. Iterative methods [21,23], on the other hand, which rely on matrix-by-vector multiplication without changing the matrix structure, perform better. There has been very little work concerning MTBDD-based numerical linear algebra; a notable exception is the CUDD package [31], a free library of C routines which supports matrix multiplication in a shared BDD and MTBDD environment. In contrast, numerical analysis of Markov chains based on sparse matrices is much more advanced, particularly in the context of Stochastic Petri Nets. There, with the help of a Kronecker representation originally introduced by Brigitte Plateau [26], systems with millions of states can be analysed. The Kronecker representation applies to systems composed of parallel components; each component is represented as a set of (comparatively small) matrices, with the matrix of the full system defined as the reachable subspace of a Kroneckeralgebraic expression (usually referred to as the actual, versus the potential, state space). Then one can avoid having to store the full size matrix by storing the component matrices instead and reformulating steady-state probability calculation in terms of the component matrices. Existing implementation work in this area includes tools such as SMART [11] and PEPS [27]. In this paper we adapt and extend the ideas of [3,2] in order to represent concurrent probabilistic systems in terms of MTBDDs. The differences with the corresponding work in numerical analysis of Markov chains are: we allow nondeterminism as well as probability; we work with probability matrices, not generator matrices of continuous time Markov chains; we generate the matrix in full, then perform BDD reachability analysis to obtain the actual state space; and we perform model checking against PBTL through a combination of reachability analysis and numerical approximation instead of steady-state probability calculation. The main contribution of the paper is threefold: (1) we implement an experimental symbolic model checker for PBTL [5] using MTBDDs; (2) we adapt the Kronecker representation of [26] and provide a translation into MTBDDs; and (3) we improve the model checking algorithm by incorporating the probability-1 precomputation step of [19].

2

Concurrent Probabilistic Systems

In this section, we briefly summarise our underlying model for concurrent probabilistic systems; the reader is referred to [5,2] for more details. Our model is based on “Markov decision processes”, and is similar to “Concurrent Markov

398


Chains” of [32,16] and “simple deterministic automata” of [29]. Some familiarity with Markov chains and probability theory is assumed. Concurrent probabilistic systems generalise ordinary Markov chains in that they allow a nondeterministic choice between possibly several probability distributions in a given state. Formally, a concurrent probabilistic system is a pair S = (S, Steps) where S is a finite set of states and Steps a function which assigns to each state s ∈ S a finite, non-empty set Steps(s) of distributions on S. Elements of Steps(s) are called transitions. Systems S = (S, Steps) such that Steps(s) is a singleton set for each s ∈ S are called purely probabilistic and coincide with discrete time Markov chains. Paths in a concurrent probabilistic system arise by resolving both the nondeterministic and probabilistic choices. A path of the system S = (S, Steps) is a p0 p1 p2 non-empty finite or infinite sequence π = s0 −→ s1 −→ s2 −→ · · · where si ∈ S, pi ∈ Steps(si ) with pi (si+1 ) > 0. We let π(i) denote the ith state of the path π. The selection of a probability distribution is made by an adversary (also known as a scheduler), a function mapping every finite path of the system onto one of the distributions in Steps(s) where s is the last state of the path. Note we use deterministic adversaries, rather than randomized adversaries as in [8]. For an adversary A of a concurrent probabilistic system S = (S, Steps) we define Path A ful to be the set of infinite paths corresponding to the choices of the adversary. In the standard way, we define the measure Prob over infinite paths. Since we allow nondeterministic choice between probability distributions, we may have to impose fairness constraints to ensure that liveness properties can be verified. In a distributed environment fairness corresponds to a requirement for each each concurrent component to progress whenever possible. Without fairness, certain liveness properties may trivially fail to hold in the presence of simultaneously enabled transitions of a concurrent component. An adversary is called fair if any choice of transitions that becomes enabled infinitely often along a computation path is taken infinitely often. The interested reader is referred to [5,20] for more information on the subject.

3

The Logic PBTL

In this section, based on [5,8], we recall the syntax and semantics of the probabilistic branching-time temporal logic PBTL. PBTL derives from CTL [13] and PCTL [22], borrowing the temporal operator U (“until”) and the path quantifier ∃ from CTL, and the probabilistic operator [ · ]λ from PCTL. Let AP denote a finite set of atomic propositions. A PBTL structure is a tuple (S, AP, L) where S = (S, Steps) is a concurrent probabilistic system and L : S → 2AP is a labelling function which assigns to each state s ∈ S a set of atomic propositions. The syntax of PBTL is: φ ::= true | a | φ1 ∧ φ2 | ¬φ | [φ1 ∃U φ2 ]λ where a is an atomic proposition, λ ∈ [0, 1], and is either ≥ or >.


399

The branching time quantifier ∃ involves quantification over adversaries, meaning “there exists an adversary” of a given type. Note that to simplify this presentation, we have omitted the “bounded until”, “next state” and “universal until” operators which can easily be added. The latter is defined similarly to the “existential until” operator included above. For a PBTL formula φ and set Adv of adversaries we define the satisfaction relation s |=Adv φ inductively as follows: s |=Adv s |=Adv s |=Adv s |=Adv s |=Adv

true a φ1 ∧ φ2 ¬φ [φ1 ∃ U φ2 ]λ

π |=Adv φ1 U φ2

for all s ∈ S ⇔ a ∈ L(s) ⇔ s |=Adv φ1 and s |=Adv φ2 ⇔ s |=Adv φ ⇔ Prob({π | π ∈ Path A ful (s) & π |=Adv φ1 U φ2 }) λ for some adversary A ∈ Adv ⇔ there exists k ≥ 0 such that π(k) |=Adv φ2 and for all j = 0, 1, . . . , k − 1, π(j) |=Adv φ1

We denote satisfaction for all adversaries by |= and satisfaction for all fair adversaries by |=fair .

4

PBTL Model Checking

With the exception of “until” formulas and fairness, model checking for PBTL is straightforward, see [8,5]. It proceeds by induction on the parse tree of the formula, as in the case of CTL model checking [13]. We only consider existential “until” for reasons of space. To establish whether s |=Adv [φ ∃U ψ]λ , we calculate the maximum probability: (φ U ψ) = sup{pA pmax s s (φ U ψ) | A ∈ Adv } A where pA s (φ U ψ) = Prob({π | π ∈ Path ful (s) & π |= φ U ψ}) and compare the result to the threshold λ, i.e. establish the inequality pmax λ. First we s introduce an operator on sets of states which will be used in the algorithm. For U0 , U1 ⊆ S, define reachE (U0 , U1 ) = µZ[H] as the least fixed point of the map H : 2S → 2S , where:

H = λx.(((x ∈ U0 ) ∧ ∃p ∈ Steps(x) ∃y(p(y) > 0 ∧ y ∈ Z)) ∨ (x ∈ U1 )). The algorithm is shown in Figure 1. We use ε = 10−6 as the termination criterion for the iteration in step 3. Observe that we compute approximations to the actual (minimum/maximum) probabilities from below to within ε. Alternatively, (φ U ψ) can be calculated by reduction to linear optimization the values pmax s problems [8,5,2]. Fairness assumptions, which are necessary in order to verify liveness properties of concurrent probabilistic processes, for example “under any scheduling, process P will eventually enter a successful state with probability at least 0.7”,

400


1. 2.

3.

Compute the sets of states Sat (φ), Sat (ψ) that satisfy φ, ψ. Let (a) S yes := Sat(ψ) (b) S >0 := reachE (Sat (φ), S yes ) (c) S no := S \ S >0 (d) S ? := S \ (S yes ∪ S no ) Set pmax (φ U ψ) = 1 if s ∈ S yes and pmax (φ U ψ) = 0 if s ∈ S no . s s ? max For s ∈ S , calculate ps (φ U ψ) iteratively as the limit, as n tends to ∞, of the approximations xs,n n∈IN , where xs,0 = 0 and for n = 1, 2, . . . (

xs,n = max 4.

P

t∈S ?

r(t) · xt,n−1 +

P

)

r(t) | r ∈ Steps (s) .

t∈S yes

Finally, let Sat ([φ ∃U ψ]λ ) := {s ∈ S | pmax (φ U ψ) λ}. s

Fig. 1. The Algorithm EU can also be handled. This is possible via reduction of the model checking for |=fair to that for ordinary satisfaction |= using results from [5,2]. For purely probabilistic systems, model checking of “until” reduces to a linear equation system in |S ? | unknowns which can be solved either through a direct method such as Gaussian elimination, or iteratively via e.g. Jacobi or GaussSeidel iteration. 4.1

Probability-1 Precomputation Step

The model checking algorithm for “until” properties given below can be improved by pre-computing the set of all states from which the formula holds with maximal probability 1. The algorithm for this precomputation step is based on results of [15,16] and can be derived from that in [19] for computing the set of states that can reach a goal with probability 1. We have here adapted it to “until” formulas. For any Z0 , Z1 ⊆ S let Pre(Z0 , Z1 ) be the set of states defined by: Pre(Z0 , Z1 ) = {x | ∃p ∈ Steps(x)(∀y(p(y) > 0 → y ∈ Z0 ) ∧ ∃y(p(y) > 0 ∧ y ∈ Z1 ))}. Intuitively, s ∈ Pre(Z0 , Z1 ) if one can go from s to Z1 with positive probability without leaving Z0 . Theorem 1. Let S = (S, Steps) be a concurrent probabilistic transition system, U0 , U1 ⊆ S subsets of states and prob1E (U0 , U1 ) be the set of states given by the solution to νZ0 µZ1 [G] where G = λx.((x ∈ U1 ) ∨ ((x ∈ U0 ) ∧ x ∈ Pre(Z0 , Z1 ))).


401

Then s ∈ prob1E (U0 , U1 ) if and only if from s, for some adversary, one reaches a state in U1 via a path through states in U0 with probability 1. It follows from this theorem that we can strengthen the assignment to S yes at step 2(a) of Algorithm EU to: S yes := prob1E (Sat (φ), Sat (ψ)). Hence, in cases of qualitative properties, i.e. properties which are required to hold with probability 1, no further computation of the probability vector will be required. In particular, this avoids potential difficulties with approximations. 4.2

Symbolic Model Checking

A symbolic method is obtained from the above procedure by representing the system and probability vector as MTBDDs, Sat(φ) as a BDD, and expressing the probability calculations as MTBDD/BDD operations (for more details see [3,2]). The operators reachE (·, ·) and prob1E (·, ·) can be expressed in terms of BDD fixed point computation with respect to the transition relation extracted from the MTBDD. The iterative calculation of the probability vector requires matrixby-vector multiplication and the operation Abstract(max).

5

Representing Probabilistic Processes with MTBDDs

MTBDDs were introduced in [14] as a generalisation of BDDs. Like BDDs, they take the form of a rooted directed acyclic graph, the nonterminal nodes of which are labelled with Boolean variables from an ordered set. Unlike BDDs however, the terminal nodes are labelled with values taken from a finite set D (usually a subset of the reals), not just 0 and 1. The operations on MTBDDs are derived from their BDD counter-parts, and include Reduce, Apply and Abstract, see [1,14]. An MTBDD with n Boolean variables and terminals taken from the finite set D, can be considered as a map f : {0, 1}n → D. In [14] it is shown how to represent matrices in terms of MTBDDs. Consider a square 2m × 2m –matrix A with entries taken from D. Its elements aij can be viewed as the values of a function fA : {1, . . . , 2m } × {1, . . . , 2m } → D, where fA (i, j) = aij , mapping the position indices i, j to the matrix element aij . Using the standard encoding c : {0, 1}m → {1, . . . , 2m } of Boolean sequences of length m into the integers, this function may be interpreted as a Boolean function f : {0, 1}2m → D where f (x, y) = fA (c(x), c(y)) for x = (x1 , . . . , xm ) and y = (y1 , . . . , ym ). We require the variables for the rows and columns to alternate, that is, use the MTBDD obtained from f (x1 , y1 , x2 , y2 , . . . , xm , ym ). This convention imposes a recursive structure on the matrix from which efficient recursive algorithms for all standard matrix operations are derived [1,14]. Probability matrices are sparse, and thus can have a compact MTBDD representation. This compactness results from sharing of substructures, and increases with the regularity of the original matrix. Though in the worst case exponential, compared to sparse matrix representation and depending on the degree of regularity of the original matrix, MTBDDs can be much more space-efficient than sparse matrices. They also combine efficiently with BDDs.

402


Concurrent probabilistic transition systems with n states that enable at most l nondeterministic transitions each can be represented as a nl × n matrix, which can then be stored as an MTBDD. (For simplicity assume that n and l are powers of 2). Each row of the matrix represents a single nondeterministic choice, where the element in position (i.k, j) represents the probability of reaching state j from state i in the k th transition that leaves from i. Unfortunately, experimental evidence has shown that this simple MTBDD representation of concurrent probabilistic systems suffers from a disproportionately large number of internal nodes, due to the lack of regularity. Instead, we will adapt the Kronecker representation originally introduced for space-efficient storage of Markov processes as Stochastic Automata Networks [26]. 5.1

A Modular Description Language for Probabilistic Processes

We propose a modular description language for concurrent probabilistic systems in an attempt to derive a more efficient MTBDD encoding. The system is considered as a composition of modules, acting concurrently, more specifically via the asynchronous parallel composition of probabilistic processes whose local transitions may be dependent on the global state of the system. This model bears similarities to the Stochastic Automata Networks (SANs) of [26]. One difference between the two approaches is that we consider probabilistic, as opposed to stochastic processes. Secondly, SANs permit two types of process interaction: synchronization between components, and functional transitions, where the rate or probability with which one component makes a transition may depend on the state of another component. For simplicity, we discuss here only the latter type of interaction. Most importantly, the motivation is different: the fundamental idea with SANs is that since the transition matrix for the composed system is formulated as a Kronecker expression, only the small matrices which make up this expression need to be stored and explicit construction of the whole (often huge) transition matrix can be avoided. Although our aim is also to obtain a space efficient method of storage, we construct the whole matrix and use a Kronecker expression to derive an efficient MTBDD variable ordering. We consider the system as a composition of n modules M1 , . . . , Mn , each with a set of local variables Var i . Each variable x ∈ Var i has a finite range of values, range(x). The local state space Si of module Mi is x∈Var i range(x). n The global state space of the combined system is then S = i=1 Si . Each module defines the transitions that it can make, depending on its current state and the state of the other modules in the system. The behaviour of a module Mi is given by a finite non-empty set Li of tuples of the form (c, p), where c = ∧nj=1 cj is a conjunction of n variable constraints, cj is a formula over Var j and p is a probability distribution over Si . Intuitively, c represents the condition under which transitions corresponding to the probability distribution p can be made. We can associate with a tuple l = (c, p) the set of global states Sl = {s ∈ S | s |= c} which satisfy the variable contraints. We require, for all modules Mi , that the sets Sl where l ∈ Li form a disjoint union of S.


403

We interpret the formal description of the behaviour of the modules as follows. If the global state of the system is s = (s1 , . . . , sn ) and s ∈ Sl for a tuple l = (c, p) ∈ Li then the probability of module Mi moving from its current local state si to the local state ti is p(ti ). Hence, in each global state of the system, any of the n modules can make a move. The behaviour of each individual module is essentially that of a Markov chain. It is necessary to decide on some form of scheduling between the modules to define the behaviour of the composed system. We consider two possibilities: probabilistic and nondeterministic scheduling. In the former, each module has an equal probability of being scheduled, giving a Markov chain. In the latter, we allow a nondeterministic choice between modules, which gives a concurrent probabilistic system as described in Section 2.

Module M1 : (x = 0) → 12 : (x = 0) + 12 : (x = 1) (x = 1) ∧ (y ≤ 1) → (x = 2) (x = 1) ∧ (y = 2) → (x = 1) (x = 2) → 12 : (x = 0) + 12 : (x = 2) Module M2 : (y = 0) → 12 : (y = 0) + 12 : (y = 1) (y = 1) ∧ (x ≤ 1) → (y = 2) (y = 1) ∧ (x = 2) → (y = 1) (y = 2) → 12 : (y = 0) + 12 : (y = 2)

1 2

x= 0 1 2 1 2

x= 2

1 2

y=2 y=2

x=1

Fig. 2. (i) A system composed of two modules. (ii) Transition system of module M1 Consider the example shown in Figure 2 of the modules M1 , M2 , with corresponding variable sets Var 1 = {x} and Var 2 = {y}, where x and y have range {0, 1, 2}. Figure 2(i) shows a textual description of the modules. Each line corresponds to a tuple (c, p) where the condition c and the probability distribution p are separated by a → symbol. For example, in line 1 of module M1 , the condition is (x = 0) and the distribution is 12 : (x = 0) + 12 : (x = 1), where x denotes the value of x in the state after the transition. Note c = (x = 0) is in fact c = c1 ∧ c2 where c1 = (x = 0) and c2 = true, i.e. there is no constraint on y. 5.2

A Kronecker Expression for the Modular Description

We now derive a Kronecker expression for the transition matrix of the composed system. As pointed out in [26], the transition matrix for the composition of n non-interacting stochastic automata can be written as: Q = ⊕ni=1 Li =

n i=1

n Qi where Qi = (⊗i−1 j=1 Inj ) ⊗ Li ⊗ (⊗j=i+1 Inj ).

In the above, Li is the local transition matrix for component i, In the identity matrix of size n, and nj the dimension of local matrix Lj . We use the same

404


basic construction here, but with probability matrices Pi for each module, rather than Qi . These local matrices are then combined through scheduling rather than simply summation. We also account for the fact that the behaviour of one module can depend on the state of another. As with functional transitions in SANs, this does not affect the overall structure of the Kronecker expression: some transitions are simply removed by zeroing out the relevant entry in the component matrix. For a given module Mi , we want an expression for the corresponding transi⊗, we can break the expression up into tion matrix Pi . Since + distributes over separate matrices Pi,l , such that Pi = l∈Li Pi,l . The restrictions on transitions are handled by zeroing out some entries of the identity matrices. We first convert the information from the module descriptions to vectors. For module Mi and line l ∈ Li where l = (c, p) and c = ∧nj=1 cj , we associate with each cj the column vector cj , indexed over local states Sj , with cj (s) = 1 if s |= cj and cj (s) = 0 otherwise. Similarly, the probability distribution p is converted to a row vector p, indexed over local states from Si , with p(s) = p(s). The unwanted elements of the jth identity matrix are removed by a pointwise multiplication with the vector cj . Then: n Pi,l = (⊗i−1 j=1 cj · Inj ) ⊗ (ci ⊗ p) ⊗ (⊗j=i+1 cj · Inj )

Consider the example given previously. We can write the matrices P1,1 and P2,2 for line 1 of module M1 and line 2 of module M2 respectively, as: 00 1

P1,1

1 = @@ 0 A ⊗ 0 00 1 0

P2,2

5.3

1 1 2 2

1

00 1 0

11

0

1

0

1

0

1

1

0

1

1 1 1 100 0 100 2 2 @ @ A @ A A @ A 1 · 010 0 ⊗ = 0 0 0A ⊗ @0 1 0A 1 001 0 00 001

11

00 1

1 100 0 10 = @@ 1 A · @ 0 1 0 AA ⊗ @@ 1 A ⊗ 0 0 1 A = @ 0 1 0 001 0 00

0 000 0A ⊗ @0 0 1A 0 000

Module to MTBDD Translation

The construction of the transition matrix, as described above, can be derived directly from the syntax in Figure 2(i) by means of BDD and MTBDD operations. First, we encode all the module variables with Boolean variables. For convenience, we assume that the range of each variable, x, is a power of 2, i.e. range(x) = {0, . . . , 2k − 1} for some k. Hence, x can be encoded with k Boolean variables x1 , . . . , xk , and x with x1 , . . . , xk . This gives a set of MTBDD row (unprimed) and column (primed) variables for each module variable in the system. The ordering of the modules in the textual description and of the module variables within them gives us an overall ordering for the Boolean variables in our MTBDDs. In our small example, we get x1 < x1 < x2 < x2 < y1 < y1 < y2 < y2 . The column vectors cj , row vector p and identity matrices Inj can then be represented as MTBDDs, using the appropriate Boolean variables. The Kronecker product operation on matrices and vectors represented as MTBDDs can


405

be performed using the Apply(×) operator. The only precaution which must be taken is to ensure that the relative order of the MTBDD variables is correct. If the MTBDDs f and g represent the matrices F and G respectively and all the variables in f precede all those of g in the overall variable ordering then Apply(×, f , g) gives the MTBDD for the matrix F ⊗ G which depends on the variables of both. Because we have ensured that our Boolean variables are grouped and ordered by module, the Kronecker expression can be computed easily with Apply(×). Since pointwise multiplication is also carried using Apply(×), the MTBDD expression for Pi,l is as shown below. Pi,l = Apply(×, c1 , In1 , . . . , ci−1 , Ini−1 , ci , p, ci+1 , Ini+1 , . . . , cn , Inn ). Since × is commutative and Apply(×, c1 , . . . , cn ) = c, rearranging: Pi,l = Apply(×, c, p, In1 , . . . , Ini−1 , Ini+1 , . . . , Inn ). We then obtain Pi by summing the Pi,l for l ∈ Li using Apply(+). Finally, we compute the MTBDD P for the whole system. For probabilistic scheduling: P = Apply(×,

1 , Apply(+, P1 , . . . , Pn )). n

For nondeterministic scheduling, we add MTBDD variables to encode the scheduler’s choice: one variable, si , for each process, where si = 1 iff module Mi is scheduled. This variable can be inserted in the variable ordering next to the variables for Mi , to preserve regularity. Returning to our simple example, we would have the variable ordering s1 < x1 < x1 < x2 < x2 < s2 < y1 < y1 < y2 < y2 . The computation of P becomes: P = Apply(+, ITE(s1 = 1, P1 , 0), . . . , ITE(sn = 1, Pn , 0)). where ITE(·, ·, ·) refers to the MTBDD operation IfThenElse(·, ·, ·). The central observation of the paper is that if we convert each of the component matrices into an MTBDD using the Boolean variables and ordering given above, then this yields a very efficient state-space encoding through increase in regularity (for example, over the matrix obtained through breadth-first search1 ) and sharing. This complies with similar results in [23,30]. Moreover, Kronecker product and ordinary sum of two matrices are also very efficient as they respectively correspond to the MTBDD operations Apply(×) and Apply(+).

6


We have implemented an experimental symbolic model checking tool using the CUDD package [31]. This package provides support for BDDs and MTBDDs, together with matrix multiplication algorithms from [1,14]. 1

See www.cs.bham.ac.uk/~dxp/prism/ for Matlab spy plots of matrices obtained via breadth-first search and Kronecker.

406


Our tool performs model checking for PBTL, with and without fairness. The MTBDD for a system of modules is automatically generated from its textual description using the translation described above. Forward reachability analysis is then performed to filter out the unreachable states. To model check qualitative properties (typically ‘with probability 1’), reachability analysis through fixed point computation suffices. Quantitative properties, however, require numerical computation. We work with double-precision floating point arithmetic, which is standard for numerical calculations. Our implementation relies on the matrix-by-vector multiplication obtained from the matrix-bymatrix multiplication algorithms supplied with the CUDD package. The model checking of unbounded “until” properties is through the Algorithm EU. For purely probabilistic processes we use Jacobi iteration, which has the following advantages: it is simple and numerically stable, relies only on the matrix-byvector multiplication, and can deal with very large matrices (since it does not change the matrix representing the system). The limiting factor is thus the size of the probability vector (which can only be represented efficiently in MTBDDs if it has regularity). We have tested our tool on several scalable examples from the literature, in particular the kanban problem [12] known from manufacturing and the randomized dining philosophers [28]. For more information see www.cs.bham.ac.uk/~dxp/prism/. Figures 3–6 show a summary of results for the dining philosophers model. The concurrent model corresponds to that presented in [28], whereas the probabilistic model corresponds to the same model with probabilistic scheduling. The tables give the MTBDD statistics, construction and model checking times in seconds of the liveness property in [28] (with fairness), performed on an Ultra 10 with 380MB. The main observations we have made so far are as follows: (1) the variable ordering induced from the Kronecker representation results in very compact MTBDDs (see comparison of the number of internal nodes in breadth-first and Kronecker); (2) because of sharing, MTBDDs allow space-efficiency gains over conventional sparse matrices for certain systems; (3) the model construction is very fast, including the computation of the reachable subspace; (4) through use of probability-1 precomputation step, model checking of qualitative properties (with and without fairness) is very fast, and results in orders of magnitude speed-up; (5) performance of numerical calculation with MTBDDs is considerably worse than with sparse matrices, though MTBDDs can potentially handle larger matrices and vectors (e.g. up to 5 million) depending on their regularity.

7

Conclusion

We have demonstrated the feasibility of symbolic model checking for probabilistic processes using MTBDDs. In particular, the state encoding induced from the Kronecker representation allows us to verify qualitative properties of systems containing up to 1030 states in a matter of seconds. Moreover, model creation is


407

Model:

Breadth-first: States: NNZ: Nodes: phil 3 770 2, 845 3, 636 phil 4 7, 070 34, 125 30, 358 phil 5 64, 858 384, 621 229, 925

Model: phil 3 phil 4 phil 5 phil 10 phil 20 phil 25

Kronecker: States: NNZ: 1, 331 4, 654 14, 641 67, 531 161, 051 919, 656 2.59 × 1010 2.86 × 1011 6.73 × 1020 1.43 × 1022 1.08 × 1026 2.86 × 1026

After reachability: Nodes: States NNZ: Nodes: 647 770 2, 845 873 1, 329 7, 070 34, 125 2, 159 2, 388 64, 858 384, 621 3, 977 14, 999 4.21 × 109 4.72 × 1010 26, 269 174, 077 1.77 × 1019 3.81 × 1020 291, 760 479, 128 1.14 × 1024 3.06 × 1025 798, 145

Fig. 3. Statistics for probabilistic models and their MTBDD representation Model:

Breadth-first: States: NNZ: Nodes: phil 3 770 2, 910 4, 401 phil 4 7, 070 35, 620 41, 670 phil 5 64, 858 408, 470 354, 902

Model: phil 3 phil 4 phil 5 phil 10 phil 20 phil 30

Kronecker: States: NNZ: 1, 331 34, 848 14, 641 1, 022, 208 161, 051 2.81 × 107 2.59 × 1010 2.90 × 1014 6.73 × 1020 1.54 × 1028 1.75 × 1031 6.13 × 1041

After reachability Nodes: States NNZ: Nodes: 451 770 20, 880 779 669 7, 070 511, 232 1556 887 64, 858 1.17 × 107 2, 178 1, 977 4.21 × 109 4.87 × 1013 6, 379 4, 157 1.77 × 1019 4.19 × 1026 14, 429 6, 337 7.44 × 1028 2.71 × 1039 22, 479

Fig. 4. Statistics for concurrent models and their MTBDD representation very fast (typically seconds) due to the close correspondence between Kronecker product and Apply(×), and efficiency of reachability analysis implemented as the usual BDD fixed point computation. Likewise, model checking of qualitative properties (expressed as ‘with probability 1’ PBTL formulas) is very fast. Many quantitative properties, however, are not handled efficiently by our present tool. This is due to poor efficiency of numerical computation, such as Jacobi iteration or simplex, compared to the corresponding sparse matrix implementation. The causes of this are a sudden loss of regularity of the probability vector due to explosion in the number of distinct values computed in the process of approximation (in the case of Jacobi) or fill-in of the tableau (in the case of simplex). Future work will involve further development of the front end for our tool, comparison with the prototype tools of [4,9,12], and addressing the inefficiency of numerical calculations with MTBDDs.

408

Luca de Alfaro et al. Model: Construction: Reachability: Model checking: Time (s): Time (s): Iterations: Time (s): Iterations: phil3 0.02 0.06 18 0.02 6 phil4 0.04 0.33 24 0.04 6 phil5 0.07 1.08 30 0.06 6 phil10 0.45 28.28 60 0.23 6 phil20 4.45 404.15 120 0.65 6 phil25 10.81 766.03 150 0.99 6

Fig. 5. Times for construction and model checking of probabilistic models Model: Construction: Reachability: Model checking: Time (s): Time (s): Iterations: Time (s): Iterations: phil3 0.02 0.07 18 0.02 6 phil4 0.03 0.35 24 0.04 6 phil5 0.05 1.00 30 0.07 6 phil10 0.24 27.03 60 0.22 6 phil20 1.45 389.56 120 0.49 6 phil30 4.10 5395.00 180 11.40 6

Fig. 6. Times for construction and model checking of concurrent models

Acknowledgements The authors Kwiatkowska, Norman and Parker are members of the ARC project 1031 Stochastic Modelling and Verification funded by the British Council and DAAD. We also thank the anonymous referees for their helpful comments.

References 1. I. Bahar, E. Frohm, C. Gaona, G. Hachtel, E.Macii, A. Pardo, and F. Somenzi. Algebraic Decision Diagrams and their Applications. Journal of Formal Methods in Systems Design, 10(2/3):171–206, 1997. 396, 397, 401, 405 2. C. Baier. On algorithmic verification methods for probabilistic systems. Habilitation thesis, 1998. 396, 397, 399, 400, 401 3. C. Baier, E. Clarke, V. Hartonas-Garmhausen, M. Kwiatkowska, and M. Ryan. Symbolic model checking for probabilistic processes. In Proceedings, 24th ICALP, volume 1256 of LNCS, pages 430–440. Springer-Verlag, 1997. 396, 397, 401 4. C. Baier, J.-P. Katoen, and H. Hermanns. Approximate symbolic model checking of continuous-time Markov chains. In CONCUR’99, volume 1664 of LNCS, pages 146–161. Springer-Verlag, 1999. 396, 407 5. C. Baier and M. Kwiatkowska. Model checking for a probabilistic branching time logic with fairness. Distributed Computing, 11:125–155, 1998. 396, 397, 398, 399, 400 6. J. Bengtsson, K. G. Larsen, F. Larsson, P. Pettersson, W. Yi, and C. Weise. New generation of uppaal. In Proceedings of the International Workshop on Software Tools for Technology Transfer, Aalborg, Denmark, July 1998. 396


409

7. D. Bertsekas. Dynamic Programming and Optimal Control. Athena Scientific, 1995. 396 8. A. Bianco and L. de Alfaro. Model checking of probabilistic and nondeterministic systems. In Proceedings, FST&TCS, volume 1026 of LNCS, pages 499–513. Springer-Verlag, 1995. 396, 398, 399 9. M. Bozga and O. Maler. On the representation of probabilities over structured domains. In Proc. CAV’99, 1999. Available as Volume 1633 of LNCS. 396, 407 10. J. R. Burch, E. M. Clarke, K. L. McMillan, D. L. Dill, and J. Hwang. Symbolic model checking: 1020 states and beyond. In LICS’90, June 1990. 395 11. G. Ciardo and A. Miner. SMART: Simulation and markovian analyzer for reliability and timing. In Tools Descriptions from PNPM’97, pages 41–43, 1997. 397 12. G. Ciardo and A. Miner. A data structure for the efficient Kronecker solution of GSPNs. In Proc. PNPM’99, 1999. 406, 407 13. E. Clarke, E. Emerson, and A. Sistla. Automatic verification of finite state concurrent systems using temporal logic specifications: A practical approach. In Proceedings, 10th Annual Symp. on Principles of Programming Languages, 1983. 398, 399 14. E. Clarke, M. Fujita, P. McGeer, J.Yang, and X. Zhao. Multi-Terminal Binary Decision Diagrams: An Efficient Data Structure for Matrix Representation. In International Workshop on Logic Synthesis, 1993. 396, 401, 405 15. C. Courcoubetis and M. Yannakakis. Markov decision processes and regular events. In Proc. ICALP’90, volume 443 of LNCS, pages 336–349. Springer-Verlag, 1990. 396, 400 16. C. Courcoubetis and M. Yannakakis. The complexity of probabilistic verification. Journal of the ACM, 42(4):857–907, 1995. 398, 400 17. L. de Alfaro. How to specify and verify the long-run average behavior of probabilistic systems. In Proc. LICS’98, pages 454–465, 1998. 396 18. L. de Alfaro. Stochastic transition systems. In Proc. CONCUR’98, volume 1466 of LNCS. Springer-Verlag, 1998. 396 19. L. de Alfaro. Computing minimum and maximum reachability times in probabilistic systems. In Proc. CONCUR’99, volume 1664 of LNCS, 1999. 397, 400 20. L. de Alfaro. From fairness to chance. In Proc. PROBMIV’98, volume 21 of ENTCS. Elsevier, 1999. 398 21. G. Hachtel, E. Macii, A. Pardo, and F. Somenzi. Markovian Analysis of Large Finite State Machines. IEEE Transactions on CAD, 15(12):1479–1493, 1996. 397 22. H. Hansson and B. Jonsson. A logic for reasoning about time and probability. Formal Aspects of Computing, 6:512–535, 1994. 396, 398 23. H. Hermanns, J. Meyer-Kayser, and M. Siegle. Multi Terminal Binary Decision Diagrams to represent and analyse continuous time Markov chains. In Proc. NSMC’99, 1999. 397, 405 24. M. Kwiatkowska, G. Norman, D. Parker, and R. Segala. Symbolic model checking of concurrent probabilistic systems using MTBDDs and simplex. Technical Report CSR-99-1, University of Birmingham, 1999. 397 25. K. McMillan. Symbolic Model Checking. Kluwer Academic Publishers, 1993. 395 26. B. Plateau. On the Stochastic Structure of Parallelism and Synchronisation Models for Distributed Algorithms. In Proc. 1985 ACM SIGMETRICS Conference on Measurement and Modeling of Computer Systems, pages 147–153, May 1985. 397, 402, 403 27. B. Plateau, J. M. Fourneau, and K. H. Lee. PEPS: a package for solving complex Markov models of parallel systems. In R. Puigjaner and D. Potier, editors, Modelling techniques and tools for computer performance evaluation, 1988. 397

410


28. A. Pnueli and L. Zuck. Verification of multiprocess probabilistic protocols. Distributed Computing, 1:53–72, 1986. 396, 406 29. R. Segala. Modelling and Verification of Randomized Distributed Real-Time Systems. PhD thesis, MIT, 1995. 398 30. M. Siegle. Compact representation of large performability models based on extended BDDs. In Fourth International Workshop on Performability Modeling of Computer and Communication Systems (PMCCS4), pages 77–80, 1998. 405 31. F. Somenzi. CUDD: CU decision diagram package. Public software, Colorado University, Boulder, 1997. 396, 397, 405 32. M. Vardi. Automatic verification of probabilistic concurrent finite-state programs. In Proceedings, FOCS’85, pages 327–338. IEEE Press, 1987. 396, 398

Symbolic Reachability Analysis Based on SAT-Solvers Parosh Aziz Abdulla1 , Per Bjesse2 , and Niklas Eén2 1

Uppsala University and Prover Technology, Sweden [email protected] 2 Chalmers University of Technology, Sweden {bjesse,een}@cs.chalmers.se

Abstract. The introduction of symbolic model checking using Binary Decision Diagrams (BDDs) has led to a substantial extension of the class of systems that can be algorithmically verified. Although BDDs have played a crucial role in this success, they have some well-known drawbacks, such as requiring an externally supplied variable ordering and causing space blowups in certain applications. In a parallel development, SAT-solving procedures, such as St˚ almarck’s method or the DavisPutnam procedure, have been used successfully in verifying very large industrial systems. These efforts have recently attracted the attention of the model checking community resulting in the notion of bounded model checking. In this paper, we show how to adapt standard algorithms for symbolic reachability analysis to work with SAT-solvers. The key element of our contribution is the combination of an algorithm that removes quantifiers over propositional variables and a simple representation that allows reuse of subformulas. The result will in principle allow many existing BDD-based algorithms to work with SAT-solvers. We show that even with our relatively simple techniques it is possible to verify systems that are known to be hard for BDD-based model checkers.

1

Introduction

In recent years model checking [CES86,QS82] has been widely used for algorithmic verification of finite-state systems such as hardware circuits and communication protocols. In model checking, the specification of the system is formulated as a temporal logical formula, while the implementation is described as a finitestate transition system. Early model-checking algorithms suffered from state explosion, as the size of the state space grows exponentially with the number of components in the system. One way to reduce state explosion is to use symbolic model checking [BCMD92,McM93], where the transition relation is coded symbolically as a boolean expression, rather than explicitly as the edges of a graph. Symbolic model checking achieved its major breakthrough after the introduction of Binary Decision Diagrams (BDDs) [Bry86] as a data structure for representing boolean expressions in the model checking procedure. An important property of BDDs is that they are canonical. This allows for substantial S. Graf and M. Schwartzbach (Eds.): TACAS/ETAPS 2000, LNCS 1785, pp. 411–425, 2000. c Springer-Verlag Berlin Heidelberg 2000

412

Parosh Aziz Abdulla et al.

sub-expression sharing, often resulting in a compact representation. In addition, canonicity implies that satisfiability and validity of boolean expressions can be checked in constant time. However, the restrictions imposed by canonicity can in some cases lead to a space blowup, making memory a bottleneck in the application of BDD-based algorithms. There are examples of functions, for example multiplication, which do not allow sub-exponential BDD representations. Furthermore, the size of a BDD is dependent on the variable ordering which in many cases is hard to optimize, both automatically and by hand. BDD-based methods can typically handle systems with hundreds of boolean variables. A related approach is to use satisfiability solvers, such as implementations of St˚ almarck’s method [St˚ a] and the Davis-Putnam procedure [Zha97]. These methods have already been used successfully for verifying industrial systems [SS00,Bor97,Bor98,SS90,GvVK95]. SAT-solvers enjoy several properties which make them attractive as a complement to BDDs in symbolic model checking. For instance, their performance is less sensitive to the size of the formulas, and they can in some cases handle propositional formulas with thousands of variables. Furthermore, SAT-solvers do not suffer from space explosion, and do not require an external variable ordering to be supplied. Finally, satisfiability solving is an NP-complete problem, whereas BDD-construction solves a #P-complete problem [Pap94] as it is possible to determine the number of models of a BDD in polynomial time. #P-complete problems are widely believed to be harder than NP-complete problems. The aim of this work is to exploit the strength of SAT-solving procedures in order to increase the class of systems amenable to verification via the traditional symbolic methods. We consider modifications of two standard algorithms— forward and backward reachability analysis—where formulas are used to characterize sets of reachable states [Bje99]. In these algorithms we replace BDDs almarck’s by satisfiability checkers such as the P ROVER implementation of St˚ method [St˚ a] or S ATO [Zha97]. We also use a data structure which we call Reduced Boolean Circuits (RBCs) to represent formulas. RBCs avoid unnecessarily large representations through the reuse of subformulas, and allow for efficient storage and manipulation of formulas. The only operation of the reachability algorithms that does not carry over straightforwardly to this representation is quantification over propositional variables. Therefore, we provide a simple procedure for the removal of quantifiers, which gives adequate performance for the examples we have tried so far. We have implemented a tool F IX I T [Eén99] based on our approach, and carried out a number of experiments. The performance of the tool indicates that even though we use simple techniques, our method can perform well in comparison to existing ones. Related Work. Bounded Model Checking (BMC) [BCC+ 99,BCCZ99,BCRZ99] is the first approach in the literature to perform model checking using SATsolvers. To check reachability, the BMC procedure searches for counterexamples (paths to undesirable states) by “unrolling” the transition relation k steps. The unrolling is described by a (quantifier-free) formula which characterizes the set

Symbolic Reachability Analysis Based on SAT-Solvers

413

of feasible paths through the transition relation with lengths smaller than or equal to k. The search can be terminated when the value of k is equal to the diameter of the system—the maximum length of all shortest path between states in the system. Although the diameter can be specified by a logical formula, its satisfiability is usually hard to check, making BMC incomplete in practice. Furthermore, for “deep” transition systems, formulas characterizing the set of reachable states may be much smaller than those characterizing witness paths. Since our method is based on encodings of sets of states, it may in some cases cope with systems which BMC fails to analyze as it generates formulas that are too large. Our representation of formulas is closely related to Binary Expression Diagrams (BEDs) [AH97,HWA97]. In fact there are straightforward linear space translations back and forth between the representations. Consequently, RBCs share the good properties of BEDs, such as being exponentially more succinct than BDDs [AH97]. The main difference between our approach and the use of BEDs is the way in which satisfiability checking and existential quantification is handled. In [AH97], satisfiability of BEDs is checked through a translation to equivalent BDDs. Although many simplifications are performed at the BED level, converting to BDDs during a fixpoint iteration could cause degeneration into a standard BDD-based fixpoint iteration. In contrast, we check satisfiability by mapping RBCs back to formulas which are then fed to external SAT-solvers. In fact, the use of SAT-solvers can also be applied to BEDs, but this does not seem to have been explored so far. Furthermore, in the BED approach, existential quantification is either handled by introducing explicit quantification vertices, or by a special transformation that rewrites the representation into a form where naive expansion can be applied. We use a similar algorithm that also applies an extra inlining rule. The inlining rule is particularly effective in the case of backward reachability analysis, as it is always applicable to the generated formulas. To our knowledge, no results have been reported in the literature on applications of BEDs in symbolic model checking. We would like to emphasize that we view RBCs as a relatively simple representation of formulas, and not as a major contribution of this work.

2

Preliminaries

We verify systems described as synchronous circuits constructed from elementary combinational gates and unit delays—a simple, yet popular, model of computation. The unit delays are controlled by a global clock, and we place no restriction on the inputs to a circuit. The environment is free to behave in any fashion. We define the state-holding elements of a circuit to be the primary inputs and the contents of the delays, and define a valuation to be an assignment of boolean values to the state-holding elements. The behaviour of a circuit is modelled as a state-transition graph where (1) each valuation is a state; (2) the initial states comprise all states that agree with the initial values of the delays; and (3) there

414


D

v0

&

1

v1 v2

D 0

v3

≥1

Fig. 1. A simple circuit built from combinational gates and delays

is a transition between two states if the circuit can move between the source state and the destination state in one clock cycle. We construct a symbolic encoding of the transition graph in the standard manner. We assign every state-holding element a propositional state variable vi , and make two copies of the set of state variables, s = {v0 , v1 , . . . , vk } and s = {v0 , v1 , . . . , vk }. Given a circuit we can now generatetwo characteristic formulas. The first of the characteristic formulas, Init(s) = i vi ↔ φi , defines the initial values of the state-holding elements. The second characteristic formula, T r(s, s ) = i vi ↔ ψi (s), defines the next-state values of state-holding elements in terms of the current-state values. Example 1. The following formulas characterize the circuit in Figure 1: Init = (v0 ↔ ) ∧ (v3 ↔ ⊥) T r = (v0 ↔ (v0 ∧ v1 )) ∧ (v3 ↔ (v2 ∨ v3 )) We investigate the underlying state-transition graph by applying operations at the formula level. In doing so we make use of the following three facts. First, the relation between any points in a given circuit can be expressed as a propositional formula over the state-holding variables. Second, we can represent any set S of transition-graph states by a formula that is satisfied exactly by the states in S. Third, we can lift all standard set-level operations to operations on formulas (for example, set inclusion corresponds to formula-level implication and set nonemptiness checking to satisfiability solving, respectively).

3

Reachability Analysis

Given the characteristic formulas of a circuit and a formula Bad(s), we define the reachability problem as that of checking whether it is possible to reach a state that satisfies Bad(s) from an initial state. As an example, in the case of


Init

F1

F2

...

? ...

B2

B1

415

Bad

Fig. 2. The intuition behind the reachability algorithms

the circuit in Figure 1, we might be interested in whether the circuit could reach a state where the two delay elements output the same value (or equivalently, where the formula v0 ↔ v3 is satisfiable). We adapt two standard algorithms for performing reachability analysis. In forward reachability we compute a sequence of formulas Fi (s) that characterize the set of states that the initial states can reach in i steps: F0 (s) = Init Fi+1 (s ) = toP rop(∃s. T r(s, s ) ∧ Fi (s))) Each computation of Fi+1 gives rise to a Quantified Boolean Formula (QBF), which we translate back to a pure propositional formula using an operation toP rop (defined in in Section 5). We terminate the sequence generation if either (1) Fn (s) ∧ Bad(s) is satisfiable: this means that a bad state is reachable; hence n−1 n we answer the reachability problem positively; or (2) k=0 Fk (s) → k=0 Fk (s) holds: this implies that we have reached a fixpoint without encountering a bad state; consequently the answer to the reachability question is negative. In backward reachability we instead compute a sequence of formulas Bi (s) that characterize the set of states that can reach a bad state in i steps: B0 (s) = Bad Bi+1 (s) = toP rop(∃s . T r(s, s ) ∧ Bi (s ))) In a similar manner to forward reachability, we terminate n the sequence n−1generation if either (1) Bn (s) ∧ Init(s) is satisfiable, or (2) k=0 Bk (s) → k=0 Bk (s) holds. Figure 2 shows the intuition behind the algorithms. We remark that the two reachability methods can be combined by alternating between the computation of Fi+1 and Bi+1 . The generation can be terminated when either a fixpoint is reached in some direction, or when Fn and Bn intersect. However, we do not make use of hybrid analyses in this paper. We need to address three nontrivial issues in an implementation of the adapted reachability algorithms. First, we must avoid the generation of unnecessarily large formula characterizations of the sets Fi and Bi —formulas are not a canonical representation. Second, we must define the operation toP rop in such a way that it translates quantified boolean formulas to propositional logic without

416


reduce

y z x z

x

x

z

y

z Fig. 3. A non-reduced Boolean Circuit and its reduced form

needlessly generating exponential results. Third, we must interface efficiently to external satisfiability solvers. The remainder of the paper explains our solutions, and evaluates the resulting reachability checker.

4

Representation of Formulas

Let Bool denote the set of booleans; Vars denote the set of propositional variables, including a special variable for the constant true; and Op denote the set {↔, ∧}. We introduce the representation Boolean Circuit (BC) for propositional formulas. A BC is a directed acyclic graph, (V, E). The vertices V are partitioned into internal nodes, VI , and leaves, VL . The vertices and edges are given attributes as follows: – Each internal vertex v ∈ VI has three attributes: A binary operator op(v) ∈ Op, and two edges left (v), right (v) ∈ E. – Each leaf v ∈ VL has one attribute: var (v) ∈ Vars. – Each edge e ∈ E has two attributes: sign(e) ∈ Bool and target(e) ∈ V. We observe that negation is coded into the edges of the graph, by the sign attribute. Furthermore, we identify edges with subformulas. In particular, the whole formula is identified with a special top-edge having no source vertex. The interpretation of an edge as a formula is given by the standard semantics of ∧, ↔ and ¬ by viewing the graph as a parse tree (with some common sub-expressions shared). Although ∧ and ¬ are functionally complete, we choose to include ↔ in the representation as it would otherwise require three binary connectives to express. Figure 3 shows an example of a BC. A Reduced Boolean Circuit (RBC) is a BC satisfying the following properties:


417

reduce(And, left ∈ RBC, right ∈ RBC) reduce(Equiv, left ∈ RBC, right ∈ RBC) if (left = right) return left if (left = right) return elif (left = ¬right) return ⊥ elif (left = ¬right) return ⊥ elif (left = ) return right elif (left = ) return right elif (right = ) return left elif (left = ⊥) return ¬right elif (left = ⊥) return ⊥ elif (right = ) return left elif (right = ⊥) return ⊥ elif (right = ⊥) return ¬left else return nil else return nil mk Comp(op ∈ Op, left ∈ RBC, right ∈ RBC, sign ∈ Bool) result := reduce(op, left, right) if (result = nil) return id (result, sign) – id returns result or ¬result depending on sign if (right < left) (left, right) := (right, left)

– Swap the values of left and right

if (op = Equiv) sign := sign xor sign(left) xor sign(right) left := unsigned (left) right := unsigned (right) result := lookup(RBC env, (op, left, right)) – Look for vertex in environment if (result = nil) result := insert(RBC env, (op, left, right)) return id (result, sign)

Fig. 4. Pseudo-code for creating a composite RBC from two existing RBCs 1. All common subformulas are shared so that no two vertices have identical attributes. 2. The constant never occurs in an RBC, except for the single-vertex RBCs representing true or false. 3. The children of an internal vertex are syntactically distinct, left (v) = right (v). 4. If op(v) = ↔ then the edges to the children of v are unsigned. 5. For all vertices v, left (v) < right (v), for some total order < on BCs. The purpose of these constraints is to identify as many equivalent formulas as possible, and thereby increase the amount of subformula sharing. For this reason we allow only one representation of ¬(φ ↔ ψ) ⇐⇒ (¬φ ↔ ψ) (in 4 above), and (φ ∧ ψ) ⇐⇒ (ψ ∧ φ) (in 5 above). The RBCs are created in an implicit environment, where all existing subformulas are tabulated. We use the environment to assure property (1). Figure 4 shows the only non-trivial constructor for RBCs, mk Comp, which creates a composite RBC from two existing RBCs (we use x ∈ Vars(φ) to denote that x is a variable occurring in the formula φ). It should be noted that the above properties only takes constant time to maintain in mk Comp.

418

5


Quantification

In the reachability algorithms we make use of the operation toP rop to translate QBF formulas into equivalent propositional formulas. We reduce the translation of a set of existential quantifiers to the iterated removal of a single quantifier after we have chosen a quantification order. In the current implementation an arbitrary order is used, but we are evaluating more refined approaches. Figure 5 presents the quantification algorithm of our implementation. By definition we have: ∃x . φ(x) ⇐⇒ φ(⊥) ∨ φ()

(∗)

The definition can be used to naively resolve the quantifiers, but this may yield an exponential blowup in representation size. To try to avoid this, we use the following well-known identities (applied from left to right) whenever possible: Inlining: ∃x . (x ↔ ψ) ∧ φ(x)

⇐⇒ φ(ψ)

Scope Reduction: ∃x . φ(x) ∧ ψ ∃x . φ(x) ∨ ψ(x)

⇐⇒ (∃x.φ(x)) ∧ ψ (where x ∈ Vars(ψ)) ⇐⇒ (∃x.φ(x)) ∨ (∃x.ψ(x))

(where x ∈ Vars(ψ))

When applicable, inlining is an effective method of resolving quantifiers as it immediately removes all occurrences of the quantified variable x. The applicability of the transformation relies on the fact that the formulas occurring in reachability often have a structure that matches the rule. This is particularly true for backward reachability as the transition relation is aconjunction of next state variables defined in terms of current state variables i vi ↔ ψi (s). The first step of the inlining algorithm temporarily changes the representation of the top-level conjunction. Fromthe binary encoding of the RBC, we extract an equivalent set representation {φ0 , φ1 , . . . , φn }. If the set contains one or more elements of the form x ↔ ψ, the smallest such element is removed from the set and its right-hand side ψ is substituted for x in the remaining elements. The set is then re-encoded as an RBC. If inlining is not applicable to the formula (and variable) at hand, the translator tries to apply the scope reduction rules as far as possible. This may result in a quantifier being pushed through an Or (represented as negated And), in which case inlining may again be possible. For subformulas where the scope can no longer be reduced, and where inlining is not applicable, we resort to naive quantification (*). Reducing the scope as much as possible before doing this will help prevent blowups. Sometimes the quantifiers can be pushed all the way to the leaves of the RBC, where they can be eliminated. Throughout the quantification procedure, we may encounter the same subproblem more than once due to shared subformulas. For this reason we keep a table of the results obtained from all previously processed subformulas.


419

– Global variable processed tabulates the results of the performed quantifications. quant naive(φ ∈ RBC, x ∈ Vars) result = subst(φ, x, ⊥) ∨ subst(φ, x, ) insert(processed, φ, x, result) return result quant reduceScope(φ ∈ RBC, x ∈ Vars) if (x ∈ Vars(φ)) return φ if (φ = x) return result := lookup(processed, φ, x) if (result = nil) return result – In the following φ must be composite and contain x: if (φop = Equiv) result := quant naive(φ, x) elif (not φsign ) – Operator And, unsigned if (x ∈ Vars(φleft )) result := φleft ∧ quant reduceScope(φright , x) elif (x ∈ Vars(φright )) result := quant reduceScope(φleft , x) ∧ φright else result := quant naive(φ, x) else – Operator And, signed (“ Or”) result := quant inline(¬φleft , x) ∨ quant inline(¬φright , x) insert(processed, φ, x, result) return result quant inline(φ ∈ RBC, x ∈ Vars) – “Main” C := collectConjuncts(φ) – Merge all binary Ands at the top of φ into a “big” conceptual conjunction (returned as a set). ψ := findDef (C, x) –Return the smallest formula ψ such that (x ↔ ψ) is a member of C. if (ψ = nil) C := C \ (x ↔ ψ) return subst(makeConj (C ), x, ψ) else return quant reduceScope(φ, x)

– Remove definition from C. – makeConj builds an RBC.

Fig. 5. Pseudo-code for performing existential quantification over one variable. By φleft we denote left (target (φ)) etc. We use ∧, ∨ as abbreviations for calls to mk Comp

6

Satisfiability

Given an RBC, we want to decide whether there exists a satisfying assignment for the corresponding formula by applying an external SAT-solver. The naive translation—unfold the graph to a tree and encode the tree as a formula—

420


has the drawback of removing sharing. We therefore use a mapping where each internal node in the representation is allocated a fresh variable. This variable is used in place of the subformula that corresponds to the internal node. The generated formula is the conjunction of all the definitions of internal nodes and the literal that defines the top edge. Example 2. The right-hand RBC in Figure 3 is mapped to the following formula in which the ik variables define internal RBC nodes: (i0 ↔ ¬i1 ∧ i2 ) ∧ (i1 ↔ i3 ↔ i4 ) ∧ (i2 ↔ i3 ∧ i4 ) ∧ (i3 ↔ x ∧ z) ∧ (i4 ↔ z ∧ y) ∧ ¬i0 A formula resulting from the outlined translation is not equivalent to the original formula without sharing, but it will be satisfiable if and only if the original formula is satisfiable. Models for the original formula are obtained by discarding the values of internal variables.

7


We have implemented a tool F IX I T [Eén99] for performing symbolic reachability analysis based on the ideas presented in this paper. The tool has a fixpoint mode in which it can perform both forward and backward reachability analysis, and an unroll mode where it searches for counterexamples in a similar manner to the BMC procedure. We have carried out preliminary experiments on three benchmarks: a multiplier and a barrel shifter (both from the BMC distribution), and a swapper (defined by the authors). The first two benchmarks are known to be hard for BDD-based methods. In all the experiments, P ROVER outperforms S ATO, so we only present measurements made using P ROVER. Furthermore, we only present time consumption. Memory consumption is much smaller than for BDD-based systems. Garbage collection has not yet been implemented in F IX I T, but the amount of simultaneously referenced memory peaks at about 5-6 MB in our experiments. We also know that the memory requirements of P ROVER are relatively low (worst case quadratic in the formula size). The test results for F IX I T are compared with results obtained from VIS release 1.3, BMC version 1.0f and C ADENCE SMV release 09-01-99. The Multiplier. The example models a standard 16×16 bit shift-and-add multiplier, with an output result of 32 bits. Each output bit is individually verified against the C6288 combinational multiplier of the ISCAS’85 benchmarks by


421

Table 1. Experimental results for the multiplier Bit 0 1 2 3 4 5 6 7 8 9 10 11 12

F IX I T

Fwd sec

0.8 0.9 1.1 1.8 3.0 7.2 24.3 100.0 492.8 2350.6 11927.5 60824.6 –

F IX I T

Bwd sec

2.0 2.3 3.0 3.9 6.1 9.9 21.5 61.9 224.7 862.6 3271.0 13494.3 50000.0

F IX I T

Unroll sec

BMC sec

VIS sec

SMV sec

0.7 0.7 0.8 0.9 1.2 1.8 3.8 11.8 45.2 197.8 862.8 3838.0 16425.8

1.0 1.4 2.0 4.0 8.2 19.9 66.7 304.6 1733.7 9970.8 54096.8 – –

5.3 5.4 5.3 5.5 6.2 10.2 32.9 153.5

41.4 41.3 42.5 42.6

[>450 MB]

– – – –

[>450 MB]

– – – – – – – –

checking that we cannot reach a state where the computation of the shift-andadd multiplier is completed, but where the selected result bit is not consistent with the corresponding output bit of the combinational circuit. Table 1 presents the results for the multiplier. The SAT-based methods outperform both VIS and SMV. The unroll mode is a constant factor more efficient than the fixpoint mode. However, we were unable to prove the diameter of the system by the diameter formula generated by BMC, which means that the verification performed by the unroll method (and BMC) should be considered partial. The Barrel Shifter. The barrel shifter rotates the contents of a register file R with one position in each step. The system also contains a fixed register file R0 , related to R in the following way: if two registers from R and R0 have the same contents, then their neighbours also have the same contents. We constrain the initial states to have this property, and the objective is to prove that it holds throughout the reachable part of the state space. The width of the registers is log |R| bits, and we let the BMC tool prove that the diameter of the circuit is |R|. Table 2 presents the results for the barrel shifter. No results are presented for VIS due to difficulties in describing the extra constraint on the initial state in the VIS input format. The backward reachability mode of F IX I T outperforms SMV and BMC on this example. The reason for this is that the set of bad states is closed under the pre-image function, and hence F IX I T terminates after only one iteration. SMV is unable to build the BDDs characterising the circuits for larger problem instances. The BMC tool has to unfold the system all the way up to the diameter, producing very large formulas; in fact, the version of BMC that we used could

422


Table 2. Experimental results for the barrel shifter |R| 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... 30 ... 40 ... 50

F IX I T

Fwd sec

F IX I T

F IX I T

Unroll sec

BMC sec

Diam sec

SMV sec

0.1 0.1 0.2 0.3 0.5 0.5 1.0 1.6 2.3 2.3 4.1 3.9 7.8 8.6 12.1 11.0 30.5 15.6 49.1

0.0 0.0 0.0 0.1 0.3 0.4 1.2 2.4 8.6 3.3 25.6 7.1 80.1 75.1 150.0 34.6 ? ? ?

0.0 0.0 0.0 0.1 0.1 0.2 0.3 0.6 0.8 1.1 1.5 2.0 2.6 3.5 4.4 7.9 ? ? ?

0.0 0.1 0.1 44.2

– – – – – – – – – – – –

0.1 0.1 0.1 0.2 0.2 0.4 0.5 0.8 1.1 1.5 2.3 2.6 3.2 3.7 4.3 6.7 8.7 9.2 13.5

–

51.4

452.1

?

?

–

–

230.5

2294.7

?

?

–

–

501.5

8763.3

?

?

–

1.7 2.3 3.0 42.4 848.9 5506.6 [>3 h]

Bwd sec

[>450 MB]

– – – – – – – – – – – – – –

not generate formulas for larger instances than size 17 (a size 17 formula is 2.2 MB large). The oscillating timing data for the SAT-based tools reflects the heuristic nature of the underlying SAT-solver. The Swapper. N nodes, each capable of storing a single bit, are connected linearly: 1 — 2 — 3 — 4 — ··· — N At each clock-cycle (at most) one pair of adjacent nodes may swap their values. From this setting we ask whether the single final state in which exactly the first N/2 nodes are set to 1 is reachable from the single initial state in which exactly the last N/2 nodes are set to 1. Table 3 shows the result of verifying this property. Both VIS and SMV handle the example easily. F IX I T can handle sizes up to 14, but does not scale up as well as VIS and SMV, as the representations get too large. This illustrates the importance of maintaining a compact representation during deep reachability problems; something that is currently not done


423

Table 3. Experimental results for the swapper N 3 4 5 6 7 8 9 10 11 12 13 14 15 ... 20 ... 25 ... 30 ... 35 ... 40

F IX I T

Fwd sec

0.2 0.3 0.6 0.9 1.7 3.8 9.7 27.7 74.1 238.8 726.8 2685.7

F IX I T

Bwd sec

0.2 0.3 0.5 1.5 3.7 10.4 58.9 187.1 779.2 4643.2

F IX I T

Unroll sec

BMC sec

VIS sec

SMV sec

0.2 0.2 0.3 1.8 131.2

0.0 0.0 0.1 7.2 989.5

[>2 h]

[>2 h]

– – – – – – –

0.3 0.3 0.3 0.4 0.4 0.4 0.4 0.4 0.5 0.6 0.7 0.7 0.7

0.0 0.0 0.0 0.1 0.1 0.1 0.1 0.1 0.2 0.2 0.3 0.4 0.6

[>2 h]

– –

– – – – – – –

–

–

–

–

1.6

7.9

–

–

–

–

3.3

53.0

–

–

–

–

15.1

263.0

–

–

–

–

39.1

929.6

–

–

–

–

89.9

2944.3

[>2 h]

by F IX I T. However, BMC does even worse, even though the problem is a strict search for an existing counterexample—something BMC is generally good at. This shows that fixpoint methods can be superior both for proving unreachability and detecting counterexamples for certain classes of systems.

8


We have described an alternative approach to standard BDD-based symbolic model checking which we think can serve as a useful complement to existing techniques. We view our main contribution as showing that with relatively simple means it is possible to modify traditional algorithms for symbolic reachability analysis so that they work with SAT-procedures instead of BDDs. The resulting method gives surprisingly good results on some known hard problems. SAT-solvers have several properties which make us believe that SAT-based model checking will become an interesting complement to BDD-based techniques. For example, in a proof system like St˚ almarck’s method, formula size does not play a decisive role in the hardness of satisfiability checking. This is particularly interesting since industrial applications often give rise to formulas which are extremely large in size, but not necessarily hard to prove.

424


There are several directions for future work. We are currently surveying simplification methods that can be used to maintain compact representations. One promising approach [AH97] is to improve the local reduction rules to span over multiple levels of the RBC graphs. We are also interested in exploiting the structure of big conjunctions and disjunctions, and in simplifying formulas using algorithms based on St˚ almarck’s notion of formula saturation [Bje99]. As for the representation itself, we are considering adding if-then-else and substitution nodes [HWA97]. Other ongoing work includes experiments with heuristics for choosing good quantification orderings. In the longer term, we will continue to work on conversions of BDD-based algorithms. For example, we have already implemented a prototype model checker for general (fair) CTL formulas. Also, employing traditional BDD-based model checking techniques such as front simplification and approximate analysis are very likely to improve the efficiency of SAT-based model checking significantly. Many important questions related to SAT-based model checking remain to be answered. For example, how should the user choose between bounded and fixpoint-based model checking? How can SAT-based approaches be combined with standard approaches to model checking?

Acknowledgements The implementation of F IX I T was done as a Master’s thesis at Prover Technology, Stockholm. Thanks to Purushothaman Iyer, Bengt Jonsson, Gordon Pace, Mary Sheeran and Gunnar St˚ almarck for giving valuable feedback on earlier drafts. This research was partially supported by TFR, the ASTEC competence center for advanced software technology, and the ARTES network for real-time research and graduate education in Sweden.

References AH97. BCC+ 99.

BCCZ99.

BCMD92.

BCRZ99.

H. R. Andersen and H. Hulgaard. Boolean expression diagrams. In Proc. 12th IEEE Int. Symp. on Logic in Computer Science, pages 88–98, 1997. 413, 424 A. Biere, A. Cimatti, E. M. Clarke, M. Fujita, and Y. Zhu. Symbolic model checking using SAT procedures instead of BDDs. In Design Automation Conference (DAC’99), 1999. 412 A. Biere, A. Cimatti, E. M. Clarke, and Y. Zhu. Symbolic model checking without BDDs. In Proc. TACAS ’98, 8th Int. Conf. on Tools and Algorithms for the Construction and Analysis of Systems, 1999. 412 J.R. Burch, E.M. Clarke, K.L. McMillan, and D.L. Dill. Symbolic model checking: 1020 states and beyond. Information and Computation, 98:142– 170, 1992. 411 A. Biere, E. M. Clarke, R. Raimi, and Y. Zhu. Verifying safety properties of a PowerPC[tm] microprocessor using symbolic model checking without BDDs. In Proc. 11th Int. Conf. on Computer Aided Verification, 1999. 412

Symbolic Reachability Analysis Based on SAT-Solvers Bje99.

425

P. Bjesse. Symbolic model checking with sets of states represented as formulas. Technical Report CS-1999-100, Department of Computer Science, Chalmers technical university, March 1999. 412, 424 Bor97. A. Bor¨ alv. The industrial success of verification tools based on St˚ almarck’s method. In Proc. 9th Int. Conf. on Computer Aided Verification, volume 1254 of Lecture Notes in Computer Science, pages 7–10, 1997. 412 Bor98. A. Bor¨ alv. Case study: Formal verification of a computerized railway interlocking. Formal Aspects of Computing, 10(4):338–360, 1998. 412 Bry86. R.E. Bryant. Graph-based algorithms for boolean function manipulation. IEEE Trans. on Computers, C-35(8):677–691, Aug. 1986. 411 CES86. E.M. Clarke, E.A. Emerson, and A.P. Sistla. Automatic verification of finite-state concurrent systems using temporal logic specification. ACM Trans. on Programming Languages and Systems, 8(2):244–263, April 1986. 411 Eén99. N. Eén. Symbolic reachability analysis based on SAT-solvers. Master’s thesis, Dept. of Computer Systems, Uppsala university, 1999. 412, 420 GvVK95. J.F. Groote, S.F.M. van Vlijmen, and J.W.C. Koorn. The safety guaranteeing system at station Hoorn-Kersenboogerd. In COMPASS’95, 1995. 412 HWA97. H. Hulgaard, P.F. Williams, and H.R. Andersen. Combinational logic-level verification using boolean expression diagrams. In 3rd International Workshop on Applications of the Reed-Muller Expansion in Circuit Design, 1997. 413, 424 McM93. K.L. McMillan. Symbolic Model Checking. Kluwer Academic Publishers, 1993. 411 Pap94. C. Papadimitriou. Computational complexity. Addison-Wesley, 1994. 412 QS82. J.P. Queille and J. Sifakis. Specification and verification of concurrent systems in Cesar. In 5th International Symposium on Programming, Turin, volume 137 of Lecture Notes in Computer Science, pages 337–352. Springer Verlag, 1982. 411 SS90. G. St˚ almarck and M. S¨ aflund. Modelling and verifying systems and software in propositional logic. In SAFECOMP’90, pages 31–36. Pergamon Press, 1990. 412 SS00. M. Sheeran and G. St˚ almarck. A tutorial on St˚ almarck’s method of propositional proof. Formal Methods In System Design, 16(1), 2000. 412 St˚ a. G. St˚ almarck. A system for determining propositional logic theorems by applying values and rules to triplets that are generated from a formula. Swedish Patent No. 467 076 (approved 1992), US patent No. 5 276 897 (1994), European Patent No. 0403 454 (1995). 412 Zha97. H. Zhang. SATO: an efficient propositional prover. In Proc. Int. Conference om Automated Deduction (CADE’97), volume 1249 of LNAI, pages 272– 275. Springer Verlag, 1997. 412

Symbolic Representation of Upward-Closed Sets Giorgio Delzanno1 and Jean-Fran¸cois Raskin2,3 1

2

Max-Planck-Institut f¨ ur Informatik Im Stadtwald, 66123 Saarbr¨ ucken, Germany [email protected] Electrical Engineering and Computer Sciences, University of California at Berkeley Berkeley, CA 94720-1770 [email protected] 3 Département d’Informatique, Université Libre de Bruxelles Blvd Du Triomphe, 1050 Bruxelles, Belgium

Abstract. The control state reachability problem is decidable for wellstructured infinite-state systems like unbounded Petri Nets, Vector Addition Systems, Lossy Petri Nets, and Broadcast Protocols. An abstract ˇ algorithm that solves the problem is given in [ACJT96,FS99]. The algorithm computes the closure of the predecessor operator w.r.t. a given upward-closed set of target states. When applied to this class of verification problems, traditional (infinite-state) symbolic model checkers suffer from the state explosion problem even for very small examples. We provide BDD-like data structures to represent in a compact way collections of upwards closed sets over numerical domains. This way, we turn the abˇ stract algorithm of [ACJT96,FS99] into a practical method. Preliminary experimental results indicate the potential usefulness of our method.

1

Introduction

In the last years many efforts have been made to extend the theoretical results and practical methods developed for finite-state systems [BCB+ 90] to sysˇ tems with infinite state space (see e.g. [ACJT96,BM99,BW98,EFM99,FS99]). This class of systems comprises well-known examples like Vector Addition Systems [Min67], extensions of Petri Nets [Cia94,Ter94], Integral Relational Auˇ tomata [Cer94], and more recent examples like Broadcast Protocols [EN98] and Lossy Petri Nets [BM99]. The control state reachability problem is decidable ˇ for all previous systems [ACJT96,BM99,EFM99,Fin90,FS99]. The abstract algoˇ rithm of [ACJT96,FS99] computes the closure of the predecessor operator w.r.t. a given upward-closed set of states. The algorithm can be used to check, e.g., invariant properties like mutual exclusion [DEP99] and coverability for markings of Petri Nets [AJKP98]. As in the finite-state case, the success of symbolic model checking for this class of problems depends on the data structures used as implicit representation of sets of states. Over numerical domains, upward-closed sets can be represented ˇ via a sub-class of integer arithmetic constraints (see e.g. [ACJT96,DEP99]). In ˇ this setting, the state-space generated by the algorithm of [ACJT96,FS99] can S. Graf and M. Schwartzbach (Eds.): TACAS/ETAPS 2000, LNCS 1785, pp. 426–441, 2000. c Springer-Verlag Berlin Heidelberg 2000

Symbolic Representation of Upward-Closed Sets

427

be represented as a large disjunction of arithmetic constraints. In [DEP99], the authors tested constraint-based model checking methods over integers (based on a solver for Presburger arithmetic [BGP97]) and reals (based on polyhedra [HHW97]) on verification problems that can be expressed via upward-closed sets. Though the examples in [DEP99] would be considered of negligible size in finite-state model checking (e.g. 6 transitions and 10 variables, cf. [BCB+ 90]), the methods taken into consideration suffer from the state explosion problem1 . Some of the experiments required (when terminating) execution times in the order of days. Based on these observations, it seems natural to look for BDD-like data structures to represent ‘compactly’ the generalization of boolean formulas we are interested in. In this paper we propose a new symbolic representation for upward-closed sets based on the sharing trees of Zampuniéris and Le Charlier [ZL94]. Sharing trees are acyclic graphs used to represent large sets of tuples, e.g., of integer numbers. The intuition behind the choice of this data structure is the following. An upward-closed set U is determined by its finite set of generators (tuples of integers). Thus, we can represent the set U via a sharing tree whose paths correspond to its generators. This way, we managed to turn the abstract algorithm ˇ of [ACJT96,FS99] into a ‘practical method’ working on the examples studied in [DEP99,Ter94] in acceptable time cost. Technically, our contributions are as follows. We introduce a logic (the logic U) where collections of upward-closed sets can be represented as disjunctive formulas. U -formulas are used for verification problems of infinite-state systems as boolean formulas are used for the finite-state case. We show that sharing trees can be used to obtain compact representations of U-formulas (there exist a Uformula that can be represented using a sharing tree whose size is logarithmic in the size of the formula). We show how basic operations on U-formulas (e.g. conjunction and disjunction) can be implemented symbolically on the corresponding sharing trees. Sharing trees can be viewed as the BDDs for U -formulas. In practical cases (e.g., during the symbolic computation of the closure of the predecessor operator), sharing trees may still become very large. For this reason, we propose polynomial time algorithms that can be used to eliminate redundant paths. As we prove in the paper, the problem of removing all redundancies from a sharing tree representing a U-formula is co-NP hard (in the size of the sharing tree). The same techniques can be used to give sufficient conditions for the subsumption test of sharing trees representing U -formulas (i.e. for the ˇ termination test of the algorithm of [ACJT96]). The complete test is co-NP hard in the size of the sharing trees. As an application of our method, we have implemented the algorithm ˇ of [ACJT96] in the case of Vector Addition Systems. The implementation makes use of the sharing tree library of [Zam97]. First experimental results indicate the potential usefulness of our method. 1

One would say ‘symbolic state explosion problem’, in fact, the above cited methods operate on implicit representations of infinite sets of states.

428

Giorgio Delzanno and Jean-Fran¸cois Raskin

Plan of the Paper. In Section 2, we define the logic U . In Section 3, we introduce the symbolic representation of U-formulas via sharing trees. In Section 4, we define simulation relations for nodes of sharing trees and discuss their application in the operations for U-formulas. In Section 5, we define a symbolic model checking procedure for Vector Addition Systems. In Section 6, we present related work. In Section 7, we address some conclusions and future perspectives for our work. The extended version of the paper (containing all proofs) is available as technical report MPI-1999-2-07 of Max-Planck-Institut f¨ ur Informatik [DR99].

2

The Logic of Upward-Closed Sets

In this section we introduce the logic U that we use to define collections of upward-closed sets. Let V = {x1 , . . . , xk } be a finite set of variables. The set of U-formulas is defined by the following grammar. Φ ::= xi ≥ c | Φ ∧ Φ | Φ ∨ Φ | Φ[xi + c/xi ], where c ∈ Z ∪ {−∞}. U-formulas are interpreted over Zk . We use t to denote the valuation t1 , . . . , tk , where ti ∈ Z is the valuation for variable xi . We consider the following order over tuples: t t iff ti ≤ ti for i : 1, . . . , k (−∞ ≤ c for any c ∈ Z). When restricted to positive values, is a well-quasi ordering (see ˇ e.g. [ACJT96,FS99]). Given a tuple t, we define t↑ as the upward-closed set generated by t, namely, t↑ = { t | t t }. Satisfaction of a formula wrt. a valuation t is defined as follows: – – – –

t |= xi ≥ c iff ti ≥ c; t |= Φ1 ∧ Φ2 iff t |= Φ1 and t |= Φ2 ; t |= Φ1 ∨ Φ2 iff t |= Φ1 or t |= Φ2 ; t |= Φ[xi + c/xi ] iff t |= Φ and t is obtained from t replacing ti with ti + c.

The denotation of a formula Φ, namely [[Φ]], is defined as the set of all evaluations t such that t |= Φ. A formula Φ1 is subsumed by a formula Φ2 , written Φ1 |= Φ2 , if [[Φ1 ]] ⊆ [[Φ2 ]]. Two formulas are equivalent if their denotations coincide. Note that, whenever we restrict the domain of interpretation of our formulas to positive integers (say Z+ ), the class of U-formulas denotes all upward-closed sets, i.e., all sets I ⊆ Zk+ such that if t ∈ I then t↑ ⊆ I. All formulas can be reduced to disjunctive formulas, i.e., to formulas having the following form2 : (x1 ≥ ci,1 ∧ . . . ∧ xk ≥ ci,k ). i∈I

Notation. In the rest of the paper we use Φ, Ψ, etc. to denote arbitrary Uformulas, and φ, ψ, etc. to denote disjunctive formulas. The set of generators of a disjunctive formula ϕ are defined as 2

Adding formulas of the form xi ≥ −∞ when necessary.


429

gen(ϕ) = { c1 , . . . , ck | (x1 ≥ c1 ∧ . . . ∧ xk ≥ ck ) is a disjunct in ϕ }. Thus, disjunctive formulas are in one-to-one correspondence with their set of generators modulo logical equivalences. The minimal elements (wrt. ) of gen(ϕ) are denoted by min(ϕ). Note that [[ϕ]] = t∈min(ϕ) t↑ . We say that a disjunctive formula is in normal form whenever gen(ϕ) = min(ϕ). As an example, consider the formula ϕ = (x ≥ 1 ∧ y ≥ 2) ∨ (x ≥ 3 ∧ y ≥ 1) ∨ (x ≥ 2 ∧ y ≥ 0). Then, gen(ϕ) = { 1, 2 , 3, 1 , 2, 0 }, and min(ϕ) = { 1, 2 , 2, 0 }, i.e., ϕ is not in normal form.

2.1

Operations on Formulas in Disjunctive Form

Disjunction and Conjunction. Formulas in disjunctive form are closed under ∨. Furthermore, given the disjunctive formulas ϕ and ψ, the disjunctive formula for ϕ ∧ ψ is defined as follows: t∈gen(ϕ),t ∈gen(ψ) (x1 ≥ max(t1 , t1 ) ∧ . . . ∧ xk ≥ max(tk , tk )), i.e., gen(ϕ ∧ ψ) = {s | ∃t ∈ gen(ϕ), t ∈ gen(ψ) and si = max(ti , ti )}. Note that the resulting formula may not be in normal form. Substitution. The formula ϕ[xi + c/xi ] is equivalent to the formula ϕ obtained from ϕ by replacing every atom xi ≥ d with xi ≥ d − c (−∞ − c = −∞ for any c ∈ Z), i.e., gen(ϕ[xi + c/xi ]) = {t | ti + c = ti , tj = tj j = i, t ∈ gen(ϕ)}. Satisfaction wrt. a tuple. Given a valuation t, we first note that t |= ϕ iff there exists t ∈ gen(ϕ) such that t t. Thus, checking t |= ϕ can be done in time linear in the size of ϕ. Subsumption. Let ϕ and ψ be in disjunctive form. We can check ϕ |= ψ in time quadratic in the size of the formulas. In fact, ϕ |= ψ holds iff for all t ∈ gen(ϕ) there exists t ∈ gen(ψ) such that t t. It is important to remark that the subsumption test is much harder for arbitrary U-formulas, as stated in the following theorem. Theorem 1. Given two arbitrary U -formulas Φ and Ψ, checking that Φ |= Ψ is co-NP complete in the size of the formulas. Reduction in normal form. Given a disjunctive formula ϕ we can reduce it in normal form by eliminating all ‘redundant’ generators from gen(ϕ), i.e., all t ∈ gen(ϕ) such that there exists t ∈ gen(ϕ), t = t , t t. The reduction can be done in time quadratic in the size of ϕ. All previous operations depend on the set of ‘generators’ of disjunctive formulas. In the following section we introduce a special data structure, called sharing tree [ZL94], for handling large sets of generators. We show how to use this data structure to represent and manipulate symbolically formulas of the logic U.

430

3


Sharing Trees

In this paper we specialize the original definition of [ZL94] as follows. We call a k-sharing tree a rooted directed acyclic graph (N, V, root, end, val, succ) where N = {root} ∪ N1 . . . ∪ Nk ∪ {end} is the finite set of nodes, (Ni is the set of nodes of layer i and, by convention, N0 = {root} and Nk+1 = {end}), val : N ❀ Z ∪ {, ⊥} is a labeling function for the nodes, and succ : N ❀ 2N defines the successors of a node. Furthermore, 1. 2. 3. 4. 5. 6.

val(n) = if and only if n = root; val(n) = ⊥ if and only if n = end; succ(end)=∅; for i : 0, . . . , k, forall n ∈ Ni , succ(n) ⊆ Ni+1 and succ(n) = ∅; forall n ∈ N , forall n1 , n2 ∈ succ(n), if n1 = n2 then val(n1 ) = val(n2 ). for i : 0, . . . , k, forall n1 , n2 ∈ Ni s.t. n1 = n2 , if val(n1 ) = val(n2 ) then succ(n1 ) = succ(n2 ).

In other words, a k-sharing tree is an acyclic graph with root and terminal node such that: all nodes of layer i have successors in the layer i + 1 (cond. 4); a node cannot have two successors with the same label (cond. 5); finally, two nodes with the same label in the same layer do not have the same set of successors (cond. 6). We say that S is a pre-sharing tree if it respects conditions (1)-(4) but possibly not (5) and (6). Notation. In the rest of the paper we use rootS , N S , succS etc. to refer to the root, set of nodes, successor relation etc. of the sharing-tree S. A path of a k-sharing tree is a sequence of nodes n1 , . . . , nm such that ni+1 ∈ succ(ni ) i : 1, . . . , m-1. Paths will represent tuples of size k of integer numbers. Formally, we use elem(S) to denote the set of elements represented by the ksharing tree S: elem(S) = { val(n1 ), . . . , val(nk ) | , n1 , . . . , nk , ⊥ is a path of S }. Condition 5 and 6 ensure the maximal sharing of prefixes and suffixes among the paths (elements) of the sharing tree. We define the ‘size’ of a sharing tree as the number of its nodes and edges. Note that the number of tuples in elem(S) can be exponentially larger than the size of S. Given a node n of the i-th layer of a k-sharing tree S, the sub-(sharing)tree Sn rooted at n is the k − i + 1sharing tree obtained as follows. We first isolate the graph rooted at n and consisting of all nodes reachable from n (this subgraph has k − i + 1 layers and a terminal node). Then, we add a layer with the single node root and we set succ(root) = {n}. From the previous definition, elem(Sn ) consists of all tuples val(n), mi+1 , . . . , mk obtained from tuples m1 , . . . , val(n), mi+1 , . . . , mk of elem(S). As shown in [ZL94], given a set of tuples F of size k, there exists a unique (modulo isomorphisms of graphs) sharing tree such that elem(S) = F . In the same paper the authors give algorithms for the basic set-operations on the set of elements represented by the sharing trees. The table in Fig. 1 gives the specifi-

Symbolic Representation of Upward-Closed Sets Operation elem(union(S , T )) = elem(S ) ∪ elem(T ) elem(intersection(S , T )) = elem(S ) ∩ elem(T ) member (t, S ) iff t ∈ elem(S ) contained (S , T ) iff elem(S ) ⊆ elem(T ) is empty(S ) iff elem(S ) = ∅

431

Complexity O(max(edges(S), edges(T )) + Red) O(min(edges(S), edges(T )) + Red) O(size(t)) O(edges(S)) O(const)

Fig. 1. Operations on the sharing trees S and T : edges(S)=No.edges of S cation and the complexity in terms of the size of sharing trees, for the operation we will consider in the rest of the paper: union, intersection, emptiness, containment, and equality test. In [ZL94], the authors show that the operations in Fig. 1 can be safely applied to pre-sharing trees that satisfy condition 5 only. The cost for intersection and union depends also on the cost Red in Fig. 1, of re-arranging condition 6. This task can be achieved using the algorithm presented in [ZL94] with cost quadratic in the number of nodes of the resulting sharing trees. 3.1

Symbolic Representation of U -Formulas

We first show how to represent U -formulas in disjunctive form, and then show how to define disjunction, conjunction, subsumption and reduction in normal form over the resulting data structure. Let ϕ be a U -formula in disjunctive form over x1 , . . . , xk . We define Sϕ as the k-sharing tree such that elem(S ϕ ) = gen(ϕ). The denotation of a k-sharing tree S is then defined as [[S]] = t∈elem(S) t↑ . Clearly, [[ϕ]] = [[Sϕ ]]. We say that Sϕ is irredundant if ϕ is in normal form, i.e., there exists no t ∈ elem(Sϕ ) such that t t for t ∈ elem(Sϕ ) distinct from t. The following proposition explains the advantages of using sharing trees for representing U-formulas. Proposition 1. There exist a disjunctive formula in normal form ϕ such that the corresponding sharing tree Sϕ has size (no. of nodes and arcs) logarithmic in the size of ϕ. As an example, consider the U -formula Φ = m i=1 (vi ≥ 1 ∧ wi ≥ 0) ∨ (vi ≥ 0 ∧ wi ≥ 1). The corresponding disjunctive formulas ϕ (obtained by distributing m m ∧) is c+d≥1 i=1 vi ≥ ci ∧ wi ≥ di ) for c, d ∈ Zm + . This formula has O(2 ) disjuncts. Also note that ϕ is in normal form. In contrast, the sharing tree Sϕ shown in Fig. 2 has size logarithmic in ϕ and polynomial in Φ (each layer has two nodes and at most four arcs). 3.2

Symbolic Operations for U -Formulas

In this section we show how operations on the disjunctive formulas ϕ and ψ can be defined symbolically on their representations Sϕ and Sψ . We use the term symbolically because the algorithms that we propose work directly on the graphs Sϕ and Sψ and not by enumerating the elements that they represent.

432

Giorgio Delzanno and Jean-Fran¸cois Raskin 0

1

0

1

0

1

0

1 end

root

1

v1

0

1

0

1

0

w1

v2

w2

v3

w3

any(p1 )

any(p2 )

any(p3 )

1

0

vn

wn

any(pn )

Fig. 2. Sharing tree for an exponential formula in DNF Disjunction. Let Sϕ and Sψ be the k-sharing trees representing the formulas (in disjunctive form) ϕ and ψ. To build a sharing tree with elem(Sϕ∨ψ ) = gen(ϕ) ∪ gen (ψ), we define Sϕ∨ψ as union(Sϕ , Sψ ), where union is the operation in Fig. 1. In [ZL94], it has been show that the size of the sharing-tree Sϕ∨ψ is at most quadratic in the size of Sϕ and Sψ , and can be computed in time quadratic in the size of the input sharing-trees. Conjunction. Given Sϕ and Sψ , we build Sϕ∧ψ as follows. We first define a presharing tree P with the following components: (i) N P = {root} ∪ N1 ∪ . . . ∪ Nk ∪ S S {end} with Ni = {(n, m) | n ∈ Ni ϕ , m ∈ Ni ψ } (i.e. a node in P correspond to a pair consisting of a node of Sϕ and a node of Sψ (at the same layer); (ii) valP ((n, m)) = max(valSϕ (n), valSψ (m)), and (iii) for all (n, m) ∈ N1 ∪ . . . ∪ Nn , we set succP ((n, m)) = {(n , m ) | n ∈ succSϕ (n), m ∈ succSψ (m)}, succP (root) = N1 , and for all (n, m) ∈ Nk we set succP ((n, m)) = {end}. We obtain the sharing-tree Sϕ∧ψ from P by enforcing conditions (5-6) of Section 3 with the algorithms proposed in [ZL94]. Substitution. Given the sharing tree Sϕ we build a new sharing tree Sϕ[xi +c/xi ] such that elem(Sϕ[xi+c/xi ] ) = gen(ϕ[xi + c/xi ]) as follows. Sϕ[xi +c/xi ] has the same components as Sϕ except from the valuation function: for every node n ∈ Sϕ[x

Sϕ[x

i i Ni i valSϕ[xi +c/xi ] (n) = valSϕ (n) − c, and for every node n ∈ Nj i , Sϕ[xi +c/xi ] Sϕ with j = i, val (n) = val (n). This way, we obtain a well-formed sharing tree. The complexity of the construction is linear in the number of nodes of Sϕ , i.e., potentially logarithmic in the number of its elements. +c/x ]

+c/x ]

Satisfaction wrt. a tuple. Checking that t |= ϕ on the sharing tree Sϕ has cost linear in the size of ϕ, i.e., following from Remark 1, possibly logarithmic in the size of ϕ. In fact, the following theorem holds. Theorem 2. Let S be a k-sharing tree and t be a vector of length k. We can check if t is subsumed by S in time linear in the number of edges of S. Subsumption. The subsumption problem is harder: the best possible algorithm for subsumption is exponential in the size of the trees, as shown by the following theorem.


433

Theorem 3. The subsumption problem for two (irredundant) k-sharing trees is co-NP complete in the size of the sharing trees. Following from the previous result, the cost of checking subsumption may be exponential in the number of edges of the input sharing trees. The result follows from the fact that U-formulas in disjunctive form can be represented compactly via sharing-tress. Reduction in normal form. Let Sϕ be the sharing tree associated to a disjunctive formula ϕ. We consider now the following problem: what is the complexity of computing the sharing-tree for the normal form of ϕ (i.e. the sharing-tree S such that elem(S) = min(ϕ))? The following theorem shows that it is as hard as checking subsumption. Theorem 4. Given a k-sharing tree S, computing the irredundant k-sharing tree S such that [[S]] = [[S ]] is co-NP hard. Let S1 and S2 be two k-sharing trees. Note that, if elem(S1 ) ⊆ elem(S2 ) then [[S1 ]] ⊆ [[S2 ]]. Besides giving a sufficient condition for checking subsumption, the previous fact suggests a possible strategy to reduce the cost of the ‘complete’ test. We first compute T = minus(S1 , S2 ) (polynomial in the size of S1 , S2 ) and then test T |= S2 on the (possibly) smaller sharing tree T . In the next section we give more interesting polynomial-time sufficient conditions for the subsumption test, based on a notion of simulation between nodes of k-sharing trees. We will see that this notion of simulation is also useful to reduce sharing-trees and ”approximate” the reduction in normal form.

4

Simulations for Nodes of a k-Sharing Tree

In the previous section we have proved that the subsumption problem for two U-formulas represented as sharing-trees and the computations of generators of the normal form of a U-formula represented as a sharing-tree, are co-NP hard. In this section we will introduce ‘approximations’ of the subsumption relation that can be tested more efficiently. More precisely, given two nodes n and m of a sharing tree S we are looking for a relation F such that: nF m ‘implies’ [[Sn ]] ⊆ [[Sm ]]. Definition 1 (Forward Simulation). Given two sharing tree S and T , let n be a node of the i-th layer of S, and m be a node of the i-th layer of T . We say that n is simulated by m, written nF m, if valS (n) ≥ valT (m) and for all s ∈ succS (n) there exists t ∈ succT (m) such that sF t. Note that, if S = T then the simulation relation is reflexive and transitive. Let f ather(n) be the set of fathers of a node n at layer i (f athers(n) ⊆ Ni−1 ). We define the backward simulation as follows: Definition 2 (Backward simulation). Given two sharing tree S and T , let n be a node of the i-th layer of S, and m be a node of the i-th layer of T . We say that n is backwards simulated by m, written nB m, if valS (n) ≥ valT (m) and for all s ∈ f athersS (n) there exists t ∈ f athersT (m) such that sB t.

434


The following result (taken from [HHK95]) shows that the previous simulations can be computed efficiently. Theorem 5 (From [HHK95]). The forward and backward simulation relations between the nodes of the sharing tree S and the nodes of the sharing tree T can be computed in O(m · n) where m is the sum of the number of nodes in S and in T , and n is the sum of the number of edges in S and in T . In the rest of this section we will focus on properties and algorithms for the forward simulation. The results and algorithms can be reformulated for the backward simulations by replacing the successor relation with the father relation. 4.1

Properties of the Simulation

The following propositions relate subsumption and the simulation

F

.

Lemma 1. Given the sharing trees S and T , let Sn and Tm be the sub-sharing trees rooted at nodes n and m, respectively. If nF m then [[Sn ]] ⊆ [[Sm ]]. The converse does not hold (in accord with the co-NP hardness result for subsumption). As a counterexample, take the two trees in Fig. 3. The curly arrows represent the simulation relation between nodes of S and T . Note that none of the nodes of layer 2 in T simulates the single node of S at the same layer. However, the denotation of S are contained in that of T . In fact, 1, 1, 2, 0 1, 2, 2, 1 and 1, 0, 0, 2 1, 2, 1, 2 . The following theorem follows from Lemma 1.

rootT

rootS 1

1

S

0

2

1

2

1

0

2

1

2

2

0

endS

T

endT

Fig. 3. The forward simulation is incomplete wrt. subsumption

Theorem 6. Let rootS , endS and rootT , endT be the root and terminal nodes of S and T , respectively. If rootS F rootT then [[S]] ⊆ [[T ]]. Symmetrically, if endS B endT then [[S]] ⊆ [[T ]]. The previous theorem gives us sufficient conditions for testing subsumption.


4.2

435

Use of Simulations to Remove Redundancies

As for the subsumption test, the simulations we introduced in Section 4 can be used to ‘approximate’ the exact normalization procedure. For this purpose, we introduce a rule that allows us to exploit the information given from (one of) the simulation relation(s) in order to ‘locally’ remove edges of a sharing tree. Definition 3 (Edge Removal). Given a sharing tree S with node N and successors succ, let us assume that for n ∈ N there exist s, t ∈ succ(n) (s = t) such that sF t. Then, we define remove(S, n) as the pre-sharing tree with successor relation succ obtained from S by setting succ (n) = succ(n)\{s}. The following proposition states the ‘correctness’ of the previous rule. Proposition 2. (1) S and remove(S, n) have the same denotations, i.e., [[S]] ≡ [[remove(S, n)]]; (2) the simulation relation F for S and remove(S, n) coincides. A possible strategy to apply Def. 3 consists of the ‘on-the-fly’ removal of edges during the computation of the simulation relation. Specifically, during a bottomup traversal of the sharing tree, we first apply Rule 3 to every node of a layer, then compute the simulation relation for the nodes of the same layer, move to the next layer, and so on. The rule to remove edges is applied exhaustively at each step. In fact, given s ∈ succ(n), let us assume that there exists u, t ∈ succ(n) such that uF s, and sF t. By transitivity, uF t holds, as well, i.e., we can still remove u after having removed s. The pre-sharing tree remove(S, n) may violate the condition 6 of the definition of sharing trees (Section 3). However, as already mentioned in the course of the paper, condition 6 can be restored using an algorithm proposed in [ZL94]. Similar algorithms can be defined for the backward simulation. It is important to note that, though an application of Rule 3 does not change the forward simulation (Fact (2) of Prop. 2), it may change the backward simulation (and, vice versa, the removal of edges according to the backward relation may change the forward simulation). As a consequence, we get better and better results iterating the application of the algorithm for removing edges for the backward-forward simulations. A simplified version of Rule 3 that requires only a local test for every node of a sharing tree is given as follows. Definition 4 (Local Edge Removal). Given a sharing S tree with node N and successors succ, let assume that for n ∈ N there exist s, t ∈ succ(n) (s = t) such that val(s) ≥ val(t) and succ(s) ⊆ succ(t). Then, we define local remove(S, n) as the pre-sharing tree with successor relation succ obtained from S by setting succ (n) = succ(n) \ {s}. Though less effective than Rule 3, Rule 4 can be paired with it in order to simplify the computation of the simulation. In the following section we show how to incorporate the previous ideas in a model checking procedure for an example of integer system.

436

5


Invariant Checking for Vector Addition Systems

A Vector Addition System (VAS) consists of n variables x1 , . . . , xn ranging over positive integers, and m transition rules given as guarded command over the data variables. For every j, transition i contains a guard xj ≥ ci,j and an assignment xj := xj + di,j ; if di,j < 0 then ci,j ≥ di,j . States are tuples of positive numbers and executions are sequences of tuples t0 t1 . . . ti . . . where ti+1 is obtained from ti by applying (non-deterministically) one of the transition rules. The predecessor operator pre takes as input a set of states (tuples) F and returns the set of predecessors of F . Properties like mutual exclusion and coverabilˇ ity can be represented through upward-closed sets [ACJT96,DEP99]. Checking safety properties expressed as upward-closed set for Petri Nets is decidable using ˇ the following algorithm taken from [ACJT96]. Let F be an upward-closed set (denoting unsafe states). To test the safety property ‘always ¬(F )’ we compute symbolically the closure of the relation pre, say pre∗ (F ), and then we check that ˇ the initial configuration is not part of the resulting set. From [ACJT96], pre∗ (F ) is still an upward-closed set. The termination test is based on thecontainment n relation, namely we stop the computation whenever pren+1 (F ) ⊆ i=0 prei (F ). U-Logic based Model Checking. Let ϕU a U-formula representing a collection of upward-closed set U . The predecessor relation for VAS can be represented as the following U-formula: (ϕi ∧ ϕU [x1 + di,1 /x1 ] . . . [xk + di,k /xk ]) pre(ϕU ) = i=1,...,m

where ϕi = x1 ≥ ci,1 ∧ . . . ∧ xn ≥ ci,n . In other words, by using the results in the previous sections, starting from SϕU we can compute the sharing tree Sprei i that represents k=0 prek (U ). The termination test is implemented by the subsumption test for sharing trees. The algorithms based on the simulations that we described in this paper can be used for a weaker termination test and for removing redundancies from the intermediate results. We have define a prototype implementation for the algorithm using the library of [Zam97]. We discuss next some preliminary experimental results. 5.1

A Case-Study: The Table Manufacturing System

The table manufacturing system of Teruel [Ter94] is a production system modeled via a weighted Petri Net with 7 places and 6 transitions. The values of the weights on the transitions vary from 2 to 4. This Petri Net can be modeled using a VAS with 13 variables, 7 for the places and 6 extra variables, say T1 , . . . , T6 , to keep track of the number of firings of each transition. As shown in [Ter94], all deadlock-free initial markings are exactly the predecessors of the set of states where the first transition is fired atleast 3 times, and all the others are fired at least twice (i.e. U = T1 ≥ 3 ∧ j>1 Tj ≥ 2). In [DEP99], different general purpose constraint-based checkers have been used to compute the set of predecessors via backward reachability. While other tools fail from terminate within


437

Example NV NR NS LR FSR ET NE Nodes Ratio Man. Sys. 13 6 24 no 39s 7563 4420 4% Man. Sys. 13 6 24 yes 5 68s 727 1772 12%

Fig. 4. Flags: NV=No. Variable; NR=No. Rules; ET=Execution Time; LR=Use of local reduction; FSR=Frequency in the use of sim. reduction ( =not used); NS=No Steps; NE=No. of Elem. of the result sharing tree; Ratio=Nodes/(NV*NE)

1 day of execution, the tool based on the Omega library of Bultan, Gerber and Pugh’s [BGP97] terminates after 19 hours and 50 minutes on a Sun Ultra Sparc, and the ‘specialized’ checker proposed in [DEP99] (see Sect. 6) terminates after 1090 seconds. Sharing trees allows us to dramatically speed up the computation. Our prototype implementation (based on the library of [Zam97]) terminates after 39 seconds on a Sun Ultra Sparc (see Fig. 4). In a first experiment we have not removed the redundancies from Sprei , whereas in a second experiment we have applied the reduction based on the forward simulation (every 5 steps) (see Fig 4). Simulation-based reduction (every 5 steps) allows us to reduce the set of states of a factor of ten (note: removing all redundancies yields 450 elements). Other examples are considered in the extended version of this paper [DR99].

6

Related Work

ˇ In [ACJT96], the authors introduce a symbolic representation (constraint system) for collections of upward-closed sets. Their representation corresponds to disjunctive U-formulas. Traditional symbolic methods for handling linear constraints (e.g. polyhedra or Presburger arithmetics) suffer however from the stateexplosion problem when applied to this type of ‘constraints’. In [DEP99], a more efficient representation based on sequences of pairs bitvector-constant is proposed for representing the state-space of broadcast protocols, and, as special case, of VAS. In this paper we have shown how to obtain more compact and efficient representations via sharing trees. In [Zam97,GGZ95], the authors apply sharing trees to represent the statespace of concurrent systems: a state is a tuple of values and a set of states is represented as a sharing tree. Note the difference with our approach. We represent a set of states via a tuple, and collections of sets of states via a sharing tree. The complexity issues are different when lifting the denotation to collections of sets of states (see Section 3). In [Zam97], Zampuniéris makes an accurate comparison between sharing trees and binary decision diagrams (BDDs) [Bry86]. When the aim is to represent tuples of (unbounded) integers (as in our case), the layered structure of sharing trees allows optimizations that seem more difficult using BDDs (or extensions like multi-valued DDs [SKM+ 90] or multi-terminal DDs [CFZ96]).

438


Our approach shares some similarities with recent works on interval decision diagrams (IDDs) [ST99] and clock decision diagrams (CDDs) for timed automata [BLP+ 99]: all approaches make use of acyclic graphs to represent disjunctions of interval constraints. However, the use of simulations as abstractions for handling efficiently large disjunctions has not been considered in the other approaches. More experimentations are needed for a better comparison of all those methods. Finally, the PEP tool [Gra97] provides a BDD-based model checking method for Petri Nets (with a fixed-a-priori number of tokens) [Wim97]. We are not aware of BDDs-based representations for the ‘constraints’ we are interested in, e.g., for verification problems of Petri Nets with a possibly unbounded number of tokens.

7


We have proposed a new symbolic representation for ‘constraints’, we called Uformulas, that can be used in verification problems for infinite-state integer systems (e.g., coverability of Petri Nets). The representation is based on the sharing trees of Zampuniéris and Le Charlier. For our purposes, we lift the denotation of a sharing tree to the upward-closed set ‘generated’ by the tuples contained in the sharing tree. We have studied the theoretical complexity of the operations for sharing trees wrt. this denotation. Furthermore, we have given sufficient conditions for testing subsumption (co-NP hard for U -formulas) we discover thanks to the view of U -formulas as acyclic graphs. In fact, the conditions are based on simulations relations for nodes of sharing trees. ˇ Though the termination test for the algorithm of [ACJT96] applied to collections of upward-closed sets (∼ U-formulas ∼ sharing trees) may be very costly3 , testing for membership of the initial configuration (when it can be expressed with a conjunctive formula) can be done efficiently (Theorem 2). This gives us an effienct method to detect violations of safety properties. The implementation is currently being optimized, but the preliminary experimental results are already promising. The type of optimizations we are interested in are: heuristics for finding ‘good’ orderings of variables; symbolic representation of the transition system (e.g. PADs [ST99]); partial order reductions (see e.g. [AJKP98] for an application to the coverability problem of Petri Nets). Finally, it would be interesting to extend our techniques to more general classes of constraints. Acknowledgments. The authors would like to thank Jean-Marc Talbot, Andreas Podelski, and Witold Charatonik for fruitful discussions, and Denis Zampuniéris for having made the sharing tree library available for our experiments. 3

Quadratic for disjunctive formulas, but disjunctive formulas suffers from the state explosion; exponential for sharing trees or arbitrary U -formulas.


439

References ˇ ACJT96.

AJKP98.

BLP+ 99.

BW98.

BM99.

Bry86. BGP97.

BCB+ 90.

ˇ Cer94.

Cia94.

CFZ96.

DEP99.

DP99.

ˇ ans, B. Jonsson, and Y.-K. Tsay. General Decidability P. A. Abdulla, K. Cer¯ Theorems for Infinite-state Systems. In Proceedings of the 11th Annual Symposium on Logic in Computer Science (LICS’96), pages 313–321. IEEE Computer Society Press, 1996. 426, 427, 428, 436, 437, 438 P. A. Abdulla, B. Jonsson, M. Kindahl, and D. Peled. A General Approach to Partial Order Reductions in Symbolic Verification. In Proceedings of the 10th Conference on Computer Aided Verification (CAV’98), volume 1427 of LNCS, pages 379–390. Springer, 1998. 426, 438 G. Behrmann, K. G. Larsen, J. Pearson, C. Weise, and W. Yi. Efficient Timed Reachability Analysis Using Clock Difference Diagrams. In Proceedings of the 11th Conference on Computer Aided Verification (CAV’99), volume 1633 of LNCS, pages 341–353. Springer 1999. 438 B. Boigelot, P. Wolper. Verifying systems with infinite but regular state space. In Proceedings of the 10th International Conference on Computer Aided Verification (CAV’98), volume 1427 of LNCS, pages 88–97. Springer, 1998. 426 A. Bouajjani and R. Mayr. Model Checking Lossy Vector Addition Systems. In Proceedings of the 16th Annual Symposium on Theoretical Aspects of Computer Science (STACS’99), volume 1563 of LNCS, pages 323–333. Springer, 1999. 426 R. E. Bryant. Graph-based Algorithms for Boolean Function Manipulation. IEEE Transaction on Computers, C-35(8):667-691, August, 1986. 437 T. Bultan, R. Gerber, and W. Pugh. Symbolic Model Checking of Infinitestate Systems using Presburger Arithmetics. In Proc. 9th Conf. on Computer Aided Verification (CAV’97), LNCS 1254, pages 400–411. SpringerVerlag, 1997. 427, 437 J. R. Burch, E. M. Clarke, K. L. McMillan, D. L. Dill, and J. Hwang. Symbolic Model Checking: 1020 States and Beyond. In Proceedings of the 5th IEEE Symposium on Logic in Computer Science, pages 428-439. IEEE Computer Society Press, 1990. 426, 427 ˇ ans. Deciding Properties of Integral Relational Automata. In ProK. Cer¯ ceedings of the International Conferences on Automata and Languages for Programming (ICALP 94), volume 820 of LNCS, pages 35-46. Springer, 1994. 426 G. Ciardo. Petri nets with marking-dependent arc multiplicity: properties and analysis. In Proceedings of the 15th Int. Conf. on Application and Theory of Petri Nets 1994, LNCS 815, pages 179–198. Springer-Verlag, 1994. 426 E. Clarke, M. Fujita, and X. Zhao. Multi-terminal Binary Decision Diagrams and Hybrid Decision Diagrams. In Representations of Discrete Functions, pages 93-108. Kluwer Academic Publishers, 1996. 437 G. Delzanno, J. Esparza, and A. Podelski. Constraint-based Analysis of Broadcast Protocols. In Proceedings of the Annual Conference of the European Association for Computer Science Logic (CSL’99), volume 1683 of LNCS, pag. 50–66. Springer, 1999. 426, 427, 436, 437 G. Delzanno and A. Podelski, Model Checking in CLP. In W. R. Cleaveland, editor, Proc. 5th Int. Con. on Tools and Algorithms for the Construction and Analysis of Systems (TACAS’99)., LNCS 1579, pages 223–239. Springer-Verlag, 1999.

440 DR99.


G. Delzanno and J. F. Raskin. Symbolic Representation of UpwardClosed Sets. Technical report MPI-I-1999-2-007, Max-Planck-Institut f¨ ur Informatik, November 1999. Available on the web at http://www.mpisb.mpg.de/units/ag2/. 428, 437 EN98. E. A. Emerson and K. S. Namjoshi. On Model Checking for Nondeterministic Infinite-state Systems. In Proceedings of the 13th Annual Symposium on Logic in Computer Science (LICS ’98), pages 70–80. IEEE Computer Society Press, 1998. 426 EFM99. J. Esparza, A. Finkel, and R. Mayr. On the Verification of Broadcast Protocols. In Proceedings of the 14th Annual Symposium on Logic in Computer Science (LICS’99), pages 352–359. IEEE Computer Society Press, 1999. 426 Fin90. A. Finkel. Reduction and Covering of Infinite Reachability Trees. Information and Computation 89(2), pages 144–179. Academic Press, 1990. 426 FS99. A. Finkel and P. Schnoebelen. Well-structured Transition Systems Everywhere! Theoretical Computer Science, 1999. To appear. 426, 427, 428 GGZ95. F. Gagnon, J.-Ch. Grégoire, and D. Zampuniéris. Sharing Trees for ‘Onthe-fly’ Verification. In Proceedings of the International Conference on Formal Description Techniques for Distributed Systems and Communication Protocols (FORTE’95), 1995. 437 Gra97. B. Grahlmann. The PEP Tool. In Proceedings of the 9th Conference on Computer Aided Verification (CAV’97), volume 1254 of LNCS, pages 440– 443. Springer, 1997. 438 HHK95. M. R. Henzinger, T. A. Henzinger, P. K. Kopke. Computing Simulations on Finite and Infinite Graphs. In Proceedings of the 36th Annual IEEE Symposium on Foundations of Computer Science (FOCS’95), pages 453– 462. IEEE Society Press, 1995. 434 HHW97. T. A. Henzinger, P.-H. Ho, and H. Wong-Toi. HyTech: a Model Checker for Hybrid Systems. In Proceedings of the 9th Conference on Computer Aided Verification (CAV’97), volume 1254 of LNCS, pages 460–463. Springer, 1997. 427 McM93. K. L. McMillan. Symbolic Model Checking: An Approach to the State Explosion Problem. Kluwer Academic, 1993. Min67. N. M. Minsky. Finite and Infinite Machines. Prentice Hall, Englewood Cliffs, N.Y., 1967. 426 SKM+ 90. A. Srinivasan, T. Kam, S. Malik, and R. K. Brayton. Algorithms for Discrete Functions Manipulation. In Proceedings of the IEEE International Conference on Computer-Aided Design (ICCAD’90), 1990. 437 ST99. K. Strehl, L. Thiele. Interval Diagram Techniques For Symbolic Model Checking of Petri Nets. In Proceedings of the Design, Automation and Test in Europe Conference (DATE’99), pages 756–757, 1999. 438 Ter94. E. Teruel. Structure Theory of Weighted Place/Transition Net Systems: The Equal Conflict Hiatus. Ph.D. Thesis, University of Zaragoza, 1994. 426, 427, 436 Wim97. G. Wimmel. A BDD-based Model Checker for the PEP Tool. Technical Report, University of Newcastle Upon Tyne, 1997. 438 Zam97. D. Zampuniéris. The Sharing Tree Data Structure: Theory and Applications in Formal Verification. PhD Thesis. Facultés Universitaires NotreDame de la Paix, Namur, Belgium, May 1997. 427, 436, 437

Symbolic Representation of Upward-Closed Sets ZL94.

441

D. Zampuniéris, and B. Le Charlier. Efficient Handling of Large Sets of Tuples with Sharing Trees. In Proceedings of the Data Compressions Conference (DCC’95), 1995. 427, 429, 430, 431, 432, 435

BDD vs. Constraint-Based Model Checking: An Experimental Evaluation for Asynchronous Concurrent Systems Tevfik Bultan Department of Computer Science, University of California Santa Barbara, CA 93106, USA [email protected]

Abstract. BDD-based symbolic model checking has been successful in verification of a wide range of systems. Recently, constraint-based approaches, which use arithmetic constraints as a symbolic representation, have been used in symbolic model checking of infinite-state systems. We argue that use of constraint-based model checking is not limited to infinite-state systems. It can also be used as an alternative to BDDbased model checking for systems with integer variables which have finite but large domains. In this paper we investigate the trade-offs between these two approaches experimentally. We compare the performance of BDD-based model checker SMV to the performance of our constraintbased model checker on verification of several asynchronous concurrent systems. The results indicate that constraint-based model checking is a viable option for verification of asynchronous concurrent systems with large integer domains.

1

Introduction

Model checking has been used in verification of diverse applications ranging from hardware protocols [McM93] to software specifications [CAB+ 98]. The success of model checking has been partially due to use of efficient data structures like Binary Decision Diagrams (BDDs) which can encode boolean functions in a highly compact format [Bry86]. The main idea in BDD-based symbolic model checking is to represent sets of system states and transitions as boolean logic formulas, and manipulate them efficiently using the BDD data structure [BCM+ 90]. An important property of the BDD data structure is that it supports operations such as intersection, union, complement, equivalence checking and existential quantifier elimination (used to implement relational image computations)— which also happen to be the main operations required for model checking. However, an efficient encoding for boolean domains may not be efficient for all variable types. For example, BDD-based model checkers can be very inefficient in representing arithmetic constraints [CAB+ 98].

This work was supported in part by NSF grant CCR-9970976 and a University of California Regents’ Junior Faculty Fellowship.


442

Tevfik Bultan

Another shortcoming of the BDD representation is its inability to encode infinite domains. Without abstraction, BDDs cannot be used for analyzing infinitestate systems—even those with just one unbounded integer. BDDs encode all underlying datatypes as boolean variables; hence all BDD-based model checkers inherently require the underlying types to be bounded. Recently, arithmetic constraints have been used as a symbolic representation in model checking [AHH96,BGP97]. For example, HyTech, a symbolic model checker for hybrid systems, encodes real domains using linear constraints on real variables [AHH96]. We developed a model checker for integer based systems which uses Presburger arithmetic (integer arithmetic without multiplication) constraints as its underlying state representation [BGP97,BGP99]. Our model checker uses the Omega library [KMP+ 95] to manipulate Presburger arithmetic constraints. In [DP99] model checking queries are converted into constraint logic programs, and a CLP(R) library is used to verify concurrent systems by mapping integer variables to real domains. Constraint representations allow verification of infinite-state systems since they can represent variables with infinite domains. There are algorithms for intersection, union, complement, equivalence checking and existential quantifier elimination for both real and integer constraint representations mentioned above. However model checking becomes undecidable for infinite-state systems. Hence the fixpoint computations are not guaranteed to converge. This problem is addressed using conservative approximation techniques [BGP99] which guarantee convergence but do not guarantee a definite answer, i.e., the model checker 1) may report that the property is verified, 2) provide a counter-example demonstrating violation of the property, or 3) report that the analysis is inconclusive. Using arithmetic constraints one can also represent variables with finite domains. We just have to add additional constraints which show the range of values that an integer variable can take. An interesting issue is, then, comparing the performance of BDD-based model checking to constraint-based model checking for finite-state systems with integer variables. In this paper we compare the performance of a BDD-based model checker (SMV [McM93]) and a constraint-based model checker (our model checker based on Omega library [BGP97,BGP99]) in verification of asynchronous concurrent systems with integer variables. On the extreme case where integer variables can take only two values, they can be treated as boolean variables and represented using BDDs. Using a constraint-representation would be very inefficient in such a case. On the other hand, although BDD-based model checkers are not capable of handling systems with unbounded integers, if the variables are restricted to a finite set of values, they can be represented using a set of boolean variables using a binary encoding. Our goal in this paper is to investigate the middle ground between these two extremes where the integer variables are neither unbounded nor have only two possible valuations. We perceive efforts in constraint-based model checking as not only a way to solve infinite-state verification problems, but also as a way to deal with problems with large variable domains using formalisms that are more expressive than

BDD vs. Constraint-Based Model Checking

443

boolean logic formulas. However, because of the added expressive power, manipulation algorithms for these formalisms have higher complexity than corresponding algorithms for BDDs. These powerful algorithms may not be worthwhile to use for small domains because of their high complexity. On the other hand, for large domains their complexity maybe justified. The question is, when is the use of integer constraint representations justified instead of BDD encodings? In this paper we investigate this issue experimentally on verification of asynchronous concurrent systems. The rest of the paper is organized as follows. We first discuss other related approaches to symbolic model checking in Sect. 2. In Sect. 3, we give a brief overview of symbolic model checking. After presenting the example concurrent systems in Sect. 4, we discuss the experimental results we obtained using BDD and constraint-based model checkers in Sect. 5. Finally, we present our conclusions and future directions.

2

Related Work

Another approach to infinite-state model checking is to use automata-based representations. Automata can be used to represent arithmetic constraints on unbounded integer variables [WB95,BKR96,KSA98]. An arithmetic constraint on k integer variables is represented by a k-track automata that accepts a string if it corresponds to a k-dimensional integer vector (in binary representation) that satisfies the corresponding arithmetic constraint. Again, since the automata representation supports the necessary operations, it can be used in symbolic model checking. The constraint and automata-based representations provide two different ways of implementing model checking computations for systems with unbounded integer variables. In [SKR98] these two approaches are compared experimentally for reachability analysis of several concurrent systems. The results show no clear winner. On some problem instances the constraint representation is superior, on some others automata representation is. In automata-based representations, restricting variables to fixed finite domains ends up converting the automata representation to a model isomorphic to BDDs [KSA98]. Hence, for the experiments we conduct in this paper the automata-based representation is equivalent to BDD-based model checking. Using a BDD-based model checker such as SMV [McM93] for checking systems with integer variables can easily result in inefficient encodings of arithmetic constraints [CAB+ 98]. It is pointed out both in [YMW97] and [CAB+ 98] that SMV can be very inefficient in constructing BDDs for integer variables. This inefficiency can be resolved for linear arithmetic constraints by using a better variable ordering as explained in [CAB+ 98]. For non-linear constraints, however, there is no efficient BDD representation [Bry86]. In [CABN97] SMV is augmented with a constraint solver for non-linear constraints. This technique is not applicable to the systems we analyze in this paper because of the restrictions put on the types of systems that can be analyzed.

444

Tevfik Bultan

Another approach to dealing with integer variables in BDD-based model checking is to use abstractions. In [CGL92], a conservative abstraction method is presented for model-checking infinite-state programs. The main idea is to produce a finite model of the program using a suitable abstraction technique (e.g., congruence modulo an integer, single-bit abstraction, symbolic abstraction), and then to check the property of interest on the abstraction. For systems such as the ones we analyze in this paper, finding a good abstraction maybe as difficult as proving the invariants of the system. On the other hand, automated abstractions such as the ones presented in [HKL+ 98] are not strong enough to eliminate the integer variables in the systems we analyze in this paper.

3

Symbolic Model Checking

In model checking, the system to be analyzed is represented as a transition system T S = (S, I, R) with a set of states S, a set of initial states I ⊆ S, and a transition relation R ⊆ S × S. The transition system model is never explicitly generated in symbolic model checking. For example, BDD-based model checkers represent transition relation R as a set of boolean logic formulas. A popular temporal logic for specifying temporal properties of transition systems is Computation Tree Logic (CTL) [CES86] which consists of a set of temporal operators (the next-state operators EX and AX, the until operators EU and AU, the invariant operators EG and AG, and the eventuality operators EF and AF) for specifying temporal properties. Our goal in model checking a system T S = (S, I, R) and a temporal property p is (we use p to denote its truth set) : 1) either to prove that the system T S satisfies the property p by showing that I ⊆ p, or 2) to demonstrate a bug by finding a state s ∈ I ∩ ¬p, and generating a counter-example path starting from s. Assume that there exists a representation for sets of states which supports tests for equivalence and membership. Then, if we can represent the truth set of the temporal property p, and the set of initial states I using this representation, we can check the two conditions listed above. If the state space is finite, explicit state enumeration would be one such representation. Note that as the state space of a concurrent system grows, explicit state enumeration will become more expensive since the size of this representation is linearly related to the number of states in the set it represents. Unfortunately, state space of a concurrent system increases exponentially with the number of variables and concurrent components. This state space explosion problem makes a simple implementation of the explicit state enumeration infeasible. Another approach is to use a symbolic representation for encoding sets of states. For example, a logic formula which is semantically interpreted as a set of states, can be used as a symbolic representation. Boolean logic formulas (stored using the BDD data structure) are the most common symbolic representation used in model checking [BCM+ 90]. Recently, we used Presburger


445

arithmetic (integer arithmetic without multiplication) formulas for the same purpose [BGP97,BGP99]. Model checking procedures use state space exploration to compute the set of states which satisfy a temporal property. Fixpoints corresponding to truth sets of temporal formulas can be computed by iteratively aggregating states using pre-condition computations (which correspond to the next state operator EX). Temporal properties which require more than one fixpoint computation can be computed recursively starting from the inner fixpoints and propagating the partial results to the outer fixpoints. All temporal properties in CTL can be expressed using boolean connectives, next state operator EX, and least fixpoints. For example, EFp ≡ µx . p ∨ EX x. The least fixpoint of a monotonic functional can be computed by starting from the bottom element (i.e., false ≡ ∅) and by iteratively applying the functional until a fixpoint is reached. Assume that Symbolic is the data type used for encoding sets of states. In order to implement a symbolic model checker based on Symbolic data type we need the following procedures: Symbolic Not(Symbolic) : Given an argument that represents a set p ⊆ S, it returns a representation for S − p. Symbolic And(Symbolic,Symbolic) : Given two arguments representing two sets p, q ⊆ S, it returns a representation for p ∩ q. Symbolic Or(Symbolic,Symbolic) : Given two arguments representing two sets p, q ⊆ S, it returns a representation for p ∪ q. Symbolic EX(Symbolic) : Given an argument that represents a set p ⊆ S, it returns a representation for the set {s | ∃s . s ∈ p ∧ (s, s ) ∈ R}. Boolean Equivalent(Symbolic, Symbolic) : Given two arguments representing two sets p, q ⊆ S, it returns true if p ≡ q, returns false otherwise. Using the procedures described above, given a temporal formula, we can compute its truth set by computing the fixpoint that corresponds to that temporal formula. The computation of the procedure EX involves computing a relational image. Given a set p ⊆ S and a relation X ⊆ S × S we use X p to denote relational image of p under X, i.e., X p is defined as restricting the domain of X to set p, and returning the range of the result. Note that we can think of relation X as a functional X : 2S → 2S . Then, X p denotes the application of the functional X to set p. Let R−1 denote the inverse of the transition relation R. Then EX p ≡ R−1 p, i.e., functional EX corresponds to the inverse of the transition relation R. Hence, we can compute the procedure EX using a relational image computation. Most model checkers represent transition relation R in a partitioned form to make the relational image computation more efficient [BCL91]. Any representation which is able to encode the set of initial states I and the set of atomic properties AP , and supports the above functionality can be used as a symbolic representation in a model checker. We call such a representation

446

Tevfik Bultan

an adequate language for model checking [KMM+ 97]. For example, for finitestate systems, boolean logic would be one such representation. It is possible to implement procedures for negation, conjunction, disjunction and equivalence checking of boolean logic formulas. If we can represent the transition relation R as a boolean logic formula, then relational image computation R−1 p can be computed by conjuncting the formula representing R−1 and the formula representing p, and then eliminating the variables in the domain of the resulting relation using existential quantifier elimination. BDDs are an efficient data structure for representing boolean logic formulas, and they support all the functionality mentioned above [Bry86]. They have been successfully used for model checking [BCM+ 90,McM93]. However, they can not encode infinite variable domains. Recently, we developed a model checker for systems with unbounded integer variables using Presburger arithmetic formulas as a symbolic representation [BGP97]. There are effective procedures for manipulating Presburger formulas which support the above functionality—for example Omega Library implements a set of such procedures [KMP+ 95]. We implemented a model checker using Omega Library as our symbolic manipulator. However, model checking computations become undecidable for infinite domains, i.e., the fixpoint computations corresponding to temporal properties may not always converge for infinite domains. We addressed this issue in [BGP99] using conservative approximations.

4

Example Concurrent Systems

The examples we use in this paper have the following characteristics: 1) they are all asynchronous concurrent systems, and 2) they all use shared integer variables to control their synchronization. We think this type of systems are especially suitable for constraint-based representations. Most of our examples are from [And91]. We represent each concurrent system with a set of events, where each event is considered atomic (Fig. 1). The state of a program is determined by the values of its data and control variables. If a variable v is used in an event, then the symbol v denotes the new value of v after the action is taken. If v is not mentioned in an event, then we assume that its value is not altered by that event. Each event specification defines a transition relation over the Cartesian product of the domains of the variables in the system. The transition relation of the overall concurrent system is defined as the union of the transition relations of all events in the system. Bakery algorithm, shown in Fig. 1 for two processes, is a mutual exclusion algorithm. The algorithm we present above is the coarse grain solution [And91] which can be further refined to implement without fetch-and-add instructions. In Fig. 1 we show a solution to sleeping barber problem [And91]. The barber allows a new customer into the shop with the event enext1 . The customer gets a chair by calling the event ehaircut1 (as long as their is an available chair). Then the barber starts the haircut with event enext2 . When the haircut is finished the


447

Program: Bakery Data Variables: a, b: positive integer Control Variables: pc1 : {T1 , W1 , C1 }, pc2 : {T2 , W2 , C2 } Initial Condition: a = b = 0 ∧ pc1 = T1 ∧ pc2 = T2 Events: eT1 : pc1 = T1 ∧ pc1 = W1 ∧ a = b + 1 eW1 : pc1 = W1 ∧ (a < b ∨ b = 0) ∧ pc1 = C1 eC1 : pc1 = C1 ∧ pc1 = T1 ∧ a = 0 eT2 : pc2 = T2 ∧ pc2 = W2 ∧ b = a + 1 eW2 : pc2 = W2 ∧ (b < a ∨ a = 0) ∧ pc2 = C2 eC2 : pc2 = C2 ∧ pc2 = T2 ∧ b = 0 Program: Barber Data Variables: cinchair, cleave, bavail, bbusy, bdone: positive integer Control Variables: pc1 : {1, 2}, pc2 : {1, 2} pc3 : {1, 2} Initial Condition: cinchair = cleave = bavail = bbusy = bdone = 0 ∧pc1 = pc2 = pc3 = 1 Events: ehaircut1 : pc1 = 1 ∧ pc1 = 2 ∧ cinchair < bavail ∧ cinchair = cinchair + 1 ehaircut2 : pc1 = 2 ∧ pc1 = 1 ∧ cleave < bdone ∧ cleave = cleave + 1 : pc2 = 1 ∧ pc2 = 2 ∧ bavail = bavail + 1 enext1 : pc2 = 2 ∧ pc2 = 1 ∧ bbusy < cinchair ∧ bbusy = bbusy + 1 enext2 ef inish1 : pc3 = 1 ∧ pc3 = 2 ∧ bdone < bbusy ∧ bdone = bdone + 1 ef inish2 : pc3 = 2 ∧ pc3 = 1 ∧ bdone = cleave Program: Readers-Writers Data Variables: nr, nw: positive integer Initial Condition: nr = nw = 0 Events: ereader−enter : nw = 0 ∧ nr = nr + 1 ereader−exit : nr > 0 ∧ nr = nr − 1 ewriter−enter : nr = 0 ∧ nw = 0 ∧ nw = nw + 1 ewriter−exit : nw > 0 ∧ nw = nw − 1 Program: Bounded-Buffer Parameterized Constant: size : positive integer Data Variables: available, produced, consumed: positive integer Initial Condition: produced = consumed = 0 ∧ available = size Events: eproduce : 0 < available ∧ produced = produced + 1 ∧ available = available − 1 econsume : available < size ∧ consumed = consumed + 1 ∧available = available + 1 Program: Circular-Queue Parameterized Constant: size : positive integer Data Variables: occupied, head, tail, produced, consumed: positive integer Initial Condition: occupied = head = tail = produced = consumed = 0 Events: eproduce : occupied < size ∧ occupied = occupied + 1 ∧ produced = produced + 1 ∧(tail = size ∧ tail = 0 ∨ tail < size ∧ tail = tail + 1) econsume : occupied > 0 ∧ occupied = occupied − 1 ∧ consumed = consumed + 1 ∧(head = size ∧ head = 0 ∨ head < size ∧ head = head + 1)

Fig. 1. Example concurrent systems used in the experiments

448

Tevfik Bultan

barber executes edone1 , and waits (edone2 ) till the customer leaves by executing the event ehaircut2 . A well-known algorithm for readers-writers problem is also presented in Fig. 1. The invariant of the readers-writers problem states that at any time there would be either no writers accessing the database or no readers, and the number of writers should never be more than one. Two algorithms given in Fig. 1 present bounded-buffer implementations. Both these systems have a parameterized constant size which specifies the size of the buffer. Since size is parameterized the systems given above should be correct for any value of size. In Table 1 we list the invariants the systems presented above have to satisfy. Table 1. List of problem instances used in the experiments Problem Instance bakery barber barber-1 barber-2 barber-3 readers-writers bounded-buffer bounded-buffer-1 bounded-buffer-2 bounded-buffer-3 circular-queue circular-queue-1 circular-queue-2

5

Property AG(¬(pc1 = C1 ∧ pc2 = C2 )) AG(cinchair ≥ cleave ∧ bavail ≥ bbusy ≥ bdone ∧ cinchair ≤ bavail ∧ bbusy ≤ cinchair ∧ cleave ≤ bdone) AG(cinchair ≥ cleave ∧ bavail ≥ bbusy ≥ bdone) AG(cinchair ≤ bavail ∧ bbusy ≤ cinchair) AG(cleave ≤ bdone) AG((nr = 0 ∨ nw = 0) ∧ nw ≤ 1) AG(produced − consumed = size − available ∧ 0 ≤ available ≤ size) AG(produced − consumed = size − available) AG(0 ≤ available ≤ size) AG(0 ≤ produced − consumed ≤ size) AG(0 ≤ produced − consumed ≤ size ∧ produced − consumed = occupied) AG(0 ≤ produced − consumed ≤ size) AG(produced − consumed = occupied)

Experimental Evaluation

We translated the examples given in Fig. 1 to the SMV input language. For each concurrent process we used the process declaration in SMV which supports asynchronous composition. SMV converts all integer variables to a binary representation since it is a BDD-based model checker. We used an uninitialized variable that always preserves its value to represent the parameterized constant size in the bounded-buffer and circular-queue systems. Our omega library based model checker accepts a Presburger arithmetic formula for each event in the input system. It forms the global transition relation by combining these formulas disjunctively. It uses asynchronous composition to combine two concurrent components. It is not efficient to map variables with small domains (such as program counters) to integer variables. So, for the exam-


449

ples with control variables we used control point partitioning to eliminate the control variables [BGP99]. To compare the performances of SMV and OMC (Omega library Model Checker) we assigned a finite domain to each integer variable. We generated 16 different instances for each concurrent system by restricting the integer variables to different ranges. We started with a range of 0 ≤ i < 23 for each integer variable i (which makes it possible to represent each variable i with 3 boolean variables in SMV) and increased it until 0 ≤ i < 226 (which requires 26 boolean variables for each integer variable). In Figs. 2 and 3 we show the performances of both SMV and OMC in terms of execution time and memory usage. We ran all our experiments on an Intel Pentium III PC (500MHz, 128 MByte main memory) running Solaris. Each graph shows experiments on one concurrent system. Data points in each individual graph is generated by only changing the range of values that integer variables are allowed to take. The x axis in these graphs show the number of boolean variables required for the binary encoding of each integer variable (which ranged from 3 to 26 in our experiments). So, for each point in the graph, the range of each integer variable i in the concurrent system verified in that particular experiment is 0 ≤ i < 2x . In our initial experiments we observed that the execution time and the memory usage of SMV increases exponentially with the number of boolean variables required for the binary encoding of each integer variable (which corresponds to a linear increase in the size of the domains of the integer variables). This exponential increase can be observed in Figs. 2 and 3. The worst-case complexity of the BDD representation is exponential in the number of boolean variables it represents. The exponential increase in execution time and memory usage of SMV is a realization of this worst-case complexity. However, as observed by Chan et al. [CAB+ 98] and Yang et al. [YMW97] this is because of the inefficient representation of integer variables in SMV and can be improved using a better variable ordering. BDD representation is very sensitive to variable ordering [Bry86]. In SMV, given two integer variables i and j, all the boolean variables representing variable i either precede all the boolean variables representing j or vice versa. With such an ordering the BDD representing a constraint such as i = j has exponential size in the number of boolean variables. However, if the order of boolean variables representing i and j are interleaved the same constraint has a linear BDD representation [CAB+ 98]. William Chan developed macros which generate such an interleaved order for SMV. Using his macros, we tested the SMV system again for the examples given in Fig. 1. As seen in Figs. 2 and 3, with this variable ordering the execution time and the memory usage of SMV increases linearly with the number of boolean variables required for the binary encoding of each integer variable (which corresponds to a logarithmic increase in the size of the domains of the integer variables). For the examples shown in Figs. 2 and 3 the performance of OMC stays constant with respect to increasing variable domains. This is because of the fact

450

Tevfik Bultan

that, for these examples, the size of the fixpoint iterates and the number of fixpoint iterations stay constant with respect to increasing variable domains for the constraint-based model checker OMC. Note that, changing the maximum value that an integer variable can take from one integer constant to another integer constant does not increase the size of the constraint representation. Also, for the examples shown in Figures 2 and 3, the model checking procedure converges in a constant number of fixpoint iterations which is independent of the size of the domains of the variables. However, this may not always be the case. For example, for properties bounded-buffer-3 and circular-queue-1 (Table 1) the number of fixpoint iterations depends on the size of the domain of the parameterized constant size. Figure 2 shows the performances of SMV and OMC on verification of both two and three process implementations of the bakery algorithm with respect to the property bakery shown in Table 1. The performance of both SMV and OMC deteriorate significantly if the number of processes is increased. However, the cost of constraint-based model checking seems to increase more significantly compared to BDD-based model checking. Based on Figs. 2 and 3 OMC outperforms SMV without interleaved variable ordering if the integer variables require more than 6 boolean variables to encode. If interleaved variable ordering [CAB+ 98] is used, for bakery with two processes and barber, the execution time of OMC is better than SMV if 18 and 14 boolean variables are used, respectively. The memory usage of OMC is always better than SMV in these cases. For the bakery with three processes SMV with interleaved variable ordering always outperforms OMC both in execution time and memory usage. For readers-writers, bounded-buffer and circular-queue, OMC always outperforms SMV with interleaved variable ordering both in terms of execution time and memory usage. Note that both bakery and barber algorithms given in Fig. 1 use variables with finite domains (pc1 , pc2 , pc3 ). Presence of such variables increases the cost of the constraint based representation since OMC partitions the state space to eliminate them. We believe that this is why the relative performance of OMC is not as good for these examples as it is for readers-writers, bounded-buffer and circular-queue. A composite approach which combines the BDD and constraintbased representations can be used in such cases [BGL98]. In Table 2 we show the performance of SMV (with interleaved variable ordering) and OMC for the problem instances given in Table 1 where each integer variable i is restricted to the range 0 ≤ i < 1024 (we also restricted the parameterized constant size to 0 ≤ size < 16). For most of these instances SMV and OMC have comparable performances. However for the bakery the increase in execution time and memory usage of OMC with respect to increasing number of processes is significantly higher compared to SMV. For 4 processes OMC did not converge in one hour (we indicate this with ↑ in Table 2). Another shortcoming of OMC is demonstrated in the verification of properties bounded-buffer-3 and circular-queue-1 shown in Table 1. None of the fixpoint computations for these properties converged (in an hour) when we


451

Table 2. Experiments where each integer variable i is restricted to 0 ≤ i < 1024. In bounded-buffer and circular-queue instances the parameterized constant size is restricted to 0 ≤ size < 16 (↑ denotes that the fixpoint computations did not converge) SMV (with Chan’s OMC variable ordering) Problem Instance Execution Memory Execution Memory Time Usage Time Usage (seconds) (Kbytes) (seconds) (Kbytes) bakery (2 processes) 0.12 1507 0.29 655 bakery (3 processes) 0.82 2228 7.32 12165 bakery (4 processes) 19.15 9110 ↑ ↑ barber 0.40 2425 0.55 1458 barber-1 0.53 2490 15.37 23101 barber-2 0.35 2228 0.29 926 barber-3 0.35 2228 0.15 655 readers-writers 0.03 1245 0.05 295 bounded-buffer 0.28 2163 0.08 238 bounded-buffer-1 0.27 2228 0.05 188 bounded-buffer-2 0.26 2163 0.04 147 bounded-buffer-3 163.30 3080 ↑ ↑ circular-queue 1.08 3408 0.10 377 circular-queue-1 1228.45 6357 ↑ ↑ circular-queue-2 1.04 3342 0.07 328

tried to verify them using OMC. This is the price we pay for using an expressive representation such as constraints which have higher worst case complexity than BDD manipulation. For the properties bounded-buffer-3 and circularqueue-1, the number of fixpoint iterations depend on the size of the domain of the parameterized constant size. For these properties OMC does not converge even for the small domain 0 ≤ size < 16. Note that, for these cases BDD based model checking is not very efficient either (even with interleaved variable ordering). We think that for such cases using conservative approximation techniques would be helpful [BGP99].

6

Conclusions

The experimental results we obtained in this work suggests that constraintbased model checking can be more efficient than BDD-based model checking for verification of asynchronous concurrent systems with finite but large integer domains. This supports our view that constraint-based model checking is not limited to infinite-state systems but can also be useful for verification of systems with large integer domains.

452

Tevfik Bultan

Execution Times: Bakery (2 Processes)

Memory Usage: Bakery (2 Processes) 3e+06

omc smv smv+co

1.4 1.2 1 0.8 0.6 0.4

Memory usage (bytes)

Execution time (seconds)

1.6

omc smv smv+co

2.5e+06 2e+06 1.5e+06 1e+06

0.2 0

500000 4

8

12 16 20 24 Size of boolean encoding

4

Execution Times: Bakery (3 Processes) 1.4e+07

6

omc smv smv+co

5 4 3 2


7

1.2e+07 1e+07

omc smv smv+co

8e+06 6e+06 4e+06 2e+06

1 0

0 4

8


4

8

Execution Times: Barber

7 6 5 4 3 2


Execution time (seconds)

omc smv smv+co

8

1 0 4

8

12 16 20 24 Size of boolean encoding Memory Usage: Barber

9

6e+06 5.5e+06 5e+06 4.5e+06 4e+06 3.5e+06 3e+06 2.5e+06 2e+06 1.5e+06 1e+06


omc smv smv+co

4

Execution Times: Readers-Writers

8


Memory Usage: Readers-Writers 2.5e+06

omc smv smv+co

0.8 0.7 0.6 0.5 0.4 0.3 0.2


0.9 Execution time (seconds)


Memory Usage: Bakery (3 Processes)

8 Execution time (seconds)

8

2e+06

omc smv smv+co

1.5e+06 1e+06 500000

0.1 0

0 4

8


4

8


Fig. 2. Execution times and memory usage for OMC, SMV, and SMV with Chan’s variable ordering (smv+co) in verification of bakery, barber and readers-writers


Execution Times: Bounded-Buffer (size

Tools and Algorithms for the Construction and Analysis of Systems, 6 conf., TACAS 2000

Tools and Algorithms for the Construction and Analysis of Systems, 7 conf., TACAS 2001

Tools and Algorithms for the Construction and Analysis of Systems, 4 conf., TACAS '98

Tools and Algorithms for the Construction and Analysis of Systems, 11 conf., TACAS 2005

Tools and Algorithms for the Construction and Analysis of Systems, 15 conf., TACAS 2009

Tools and Algorithms for the Construction and Analysis of Systems, 2 conf., TACAS '96

Tools and Algorithms for the Construction and Analysis of Systems, 5 conf., TACAS '99

Tools and Algorithms for the Construction and Analysis of Systems, 9 conf., TACAS 2003

Tools and Algorithms for the Construction and Analysis of Systems, 14 conf., TACAS 2008

Tools and Algorithms for the Construction and Analysis of Systems, 1 conf., TACAS '95

Tools and Algorithms for the Construction and Analysis of Systems, 13 conf., TACAS 2007

Tools and Algorithms for the Construction and Analysis of Systems, 3 conf., TACAS '97

Tools and Algorithms for the Construction and Analysis of Systems, 12 conf., TACAS 2006

Tools and Algorithms for the Construction and Analysis of Systems, 8 conf., TACAS 2002

Tools and Algorithms for the Construction and Analysis of Systems - TACAS 2011

Software Tools and Algorithms for Biological Systems

Compiler Construction 6 conf

Tools and Algorithms for the Construction and Analysis of Systems: 16th International Conference, TACAS 2010, Held as Part of the Joint European ... Computer Science and General Issues)

Tools and Algorithms for the Construction and Analysis of Systems: 16th International Conference, TACAS 2010, Held as Part of the Joint European ... Computer Science and General Issues)

Algorithms and Complexity, 4 conf., CIAC 2000

Algorithms and Computation, 11 conf., ISAAC 2000

Tools and Algorithms for the Construction and Analysis of Systems: 10th International Conference, TACAS 2004, Held as Part of the Joint European Conferences ... (Lecture Notes in Computer Science)

Anaphora.. Analysis, Algorithms and Applications, 6 conf., DAARC 2007

Computing and Combinatorics, 6 conf., COCOON 2000

Algorithms and Complexity, 6 conf., CIAC 2006

Algorithms - ESA 2000, 8 conf

Algorithms - ESA '98, 6 conf

Efficient Software Tools for Control and Analysis of Hybrid Systems

Matrices and Matroids for Systems Analysis (Algorithms and Combinatorics, 20)

Matrices and Matroids for Systems Analysis (Algorithms and Combinatorics, 20)

Principles and Practice of Constraint Programming - CP 2000, 6 conf

Tools and Algorithms for the Construction and Analysis of Systems, 6 conf., TACAS 2000

Tools and Algorithms for the Construction and Analysis of Systems, 7 conf., TACAS 2001

Tools and Algorithms for the Construction and Analysis of Systems, 4 conf., TACAS '98

Tools and Algorithms for the Construction and Analysis of Systems, 11 conf., TACAS 2005

Tools and Algorithms for the Construction and Analysis of Systems, 15 conf., TACAS 2009

Tools and Algorithms for the Construction and Analysis of Systems, 2 conf., TACAS '96

Tools and Algorithms for the Construction and Analysis of Systems, 5 conf., TACAS '99

Tools and Algorithms for the Construction and Analysis of Systems, 9 conf., TACAS 2003

Tools and Algorithms for the Construction and Analysis of Systems, 14 conf., TACAS 2008

Tools and Algorithms for the Construction and Analysis of Systems, 1 conf., TACAS '95

Tools and Algorithms for the Construction and Analysis of Systems, 13 conf., TACAS 2007

Tools and Algorithms for the Construction and Analysis of Systems, 3 conf., TACAS '97

Tools and Algorithms for the Construction and Analysis of Systems, 12 conf., TACAS 2006

Tools and Algorithms for the Construction and Analysis of Systems, 8 conf., TACAS 2002

Tools and Algorithms for the Construction and Analysis of Systems - TACAS 2011

Software Tools and Algorithms for Biological Systems

Compiler Construction 6 conf

Tools and Algorithms for the Construction and Analysis of Systems: 16th International Conference, TACAS 2010, Held as Part of the Joint European ... Computer Science and General Issues)

Tools and Algorithms for the Construction and Analysis of Systems: 16th International Conference, TACAS 2010, Held as Part of the Joint European ... Computer Science and General Issues)

Algorithms and Complexity, 4 conf., CIAC 2000

Algorithms and Computation, 11 conf., ISAAC 2000

Tools and Algorithms for the Construction and Analysis of Systems: 10th International Conference, TACAS 2004, Held as Part of the Joint European Conferences ... (Lecture Notes in Computer Science)

Anaphora.. Analysis, Algorithms and Applications, 6 conf., DAARC 2007

Computing and Combinatorics, 6 conf., COCOON 2000

Algorithms and Complexity, 6 conf., CIAC 2006

Algorithms - ESA 2000, 8 conf

Algorithms - ESA '98, 6 conf

Efficient Software Tools for Control and Analysis of Hybrid Systems

Matrices and Matroids for Systems Analysis (Algorithms and Combinatorics, 20)

Matrices and Matroids for Systems Analysis (Algorithms and Combinatorics, 20)

Principles and Practice of Constraint Programming - CP 2000, 6 conf

Recommend Documents