A Logic of Events

There is a well-established theory and practice for creating correct-by-construction functional programs by extracting them from constructive proofs of assertions of the form 8x : A:9y : B:R(x;y): There have been several efforts to extend this methodology to concurrent programs, say by using linear logic, but there is no practice and the results are limited. In this paper we define a logic of events that justifies the extraction of correct distributed processes from constructive proofs that system specifications are achievable, and we describe an implementation of an extraction processin the context of constructive type theory. We show that a class of message automata,similar to IO automata and to active objects, are realizers for this logic. We provide a relative consistency result for the logic. We show an example of protocol derivation in this logic, and show how to embed temporal logics such as TLA+ in the event logic.

[1]  Moshe Y. Vardi An Automata-Theoretic Approach to Fair Realizability and Synthesis , 1995, CAV.

[2]  R. Milner Calculi for interaction , 1996, Acta Informatica.

[3]  Ronald Fagin,et al.  Modelling knowledge and action in distributed systems , 2005, Distributed Computing.

[4]  Pierre Wolper,et al.  Synthesis of Communicating Processes from Temporal Logic Specifications , 1981, TOPL.

[5]  Willem P. de Roever,et al.  Compositionality and Concurrent Networks: Soundness and Completeness of a Proofsystem , 1985, ICALP.

[6]  Seif Haridi,et al.  Distributed Algorithms , 1992, Lecture Notes in Computer Science.

[7]  Elvinia Riccobene,et al.  Proving Invariants of I/O Automata with TAME , 2004, Automated Software Engineering.

[8]  Constance L. Heitmeyer,et al.  Program Synthesis from Formal Requirements Specifications Using APTS , 2003, High. Order Symb. Comput..

[9]  Robert L. Constable,et al.  Constructive Mathematics and Automatic Program Writers , 1970, IFIP Congress.

[10]  Douglas C. Schmidt,et al.  Application of the QuO quality-of-service framework to a distributed video application , 2001, Proceedings 3rd International Symposium on Distributed Objects and Applications.

[11]  Uri Abraham,et al.  Models for Concurrency , 1999 .

[12]  Nancy A. Lynch,et al.  An introduction to input/output automata , 1989 .

[13]  Leslie Lamport,et al.  Specifying Systems: The TLA+ Language and Tools for Hardware and Software Engineers [Book Review] , 2002, Computer.

[14]  Uri Abraham,et al.  On Interprocess Communication and the Implementation of Multi-Writer Atomic Registers , 1995, Theor. Comput. Sci..

[15]  Gérard Berry,et al.  The chemical abstract machine , 1989, POPL '90.

[16]  Samson Abramsky,et al.  Proofs as Processes , 1992, Theor. Comput. Sci..

[17]  W. Vogels,et al.  The Horus and Ensemble projects: accomplishments and limitations , 2000, Proceedings DARPA Information Survivability Conference and Exposition. DISCEX'00.

[18]  K. Mani Chandy,et al.  Parallel program design - a foundation , 1988 .

[19]  David A. Basin,et al.  An Environment For Automated Reasoning About Partial Functions , 1988, CADE.

[20]  R. Constable,et al.  Nuprl ’ s Class Theory and its Applications , 2000 .

[21]  F. Javier Thayer Fábrega,et al.  Strand spaces: proving security protocols correct , 1999 .

[22]  Christoph Kreitz,et al.  A Proof Environment for the Development of Group Communication Systems , 1998, CADE.

[23]  Zohar Manna,et al.  Temporal verification of reactive systems - safety , 1995 .

[24]  Christoph Kreitz Automated Fast-Track Reconfiguration of Group Communication Systems , 1999, TACAS.

[25]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[26]  Glynn Winskel,et al.  Events in computation , 1980 .

[27]  Randal E. Bryant,et al.  Concurrent programming , 1980, Operating Systems Engineering.

[28]  Leslie Lamport,et al.  Time, clocks, and the ordering of events in a distributed system , 1978, CACM.

[29]  Mark Bickford,et al.  Predicate Transformers for Infinite-State Automata in NuPRL Type Theory , 1999, IWFM.

[30]  Christoph Kreitz,et al.  Building reliable, high-performance communication systems from components , 2000, OPSR.

[31]  Yoram Moses,et al.  A Refinement Theory that Supports Reasoning About Knowledge and Time , 2001, LPAR.

[32]  Zohar Manna,et al.  The Temporal Logic of Reactive and Concurrent Systems , 1991, Springer New York.

[33]  Chetan R. Murthy An evaluation semantics for classical proofs , 1991, [1991] Proceedings Sixth Annual IEEE Symposium on Logic in Computer Science.

[34]  Mark Bickford,et al.  Proving Hybrid Protocols Correct , 2001, TPHOLs.

[35]  Laurent Théry,et al.  A Machine-Checked Implementation of Buchberger's Algorithm , 2001, Journal of Automated Reasoning.

[36]  Shlomi Dolev,et al.  Self-stabilizing l-exclusion , 2001, Theor. Comput. Sci..

[37]  Joseph Y. Halpern A note on knowledge-based programs and specifications , 2000, Distributed Computing.

[38]  Joseph Y. Halpern,et al.  Reasoning about common knowledge with infinitely many agents , 2004, Inf. Comput..

[39]  Nancy A. Lynch,et al.  Specifications and Proofs for Ensemble Layers , 1999, TACAS.

[40]  Bengt Nordström,et al.  Programming in Martin-Löf's Type Theory , 1990 .

[41]  Per Martin-Löf,et al.  Constructive mathematics and computer programming , 1984 .

[42]  K. Mani Chandy,et al.  CC++: A Declarative Concurrent Object Oriented Programming Notation , 1993 .

[43]  Mark Garland Hayden,et al.  The Ensemble System , 1998 .

[44]  Douglas J. Howe Semantic Foundations for Embedding HOL in Nuprl , 1996, AMAST.

[45]  Glynn Winskel,et al.  An Introduction to Event Structures , 1989 .

[46]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[47]  Anna Philippou,et al.  Tools and Algorithms for the Construction and Analysis of Systems , 2018, Lecture Notes in Computer Science.

[48]  Edmund M. Clarke,et al.  Using Branching Time Temporal Logic to Synthesize Synchronization Skeletons , 1982, Sci. Comput. Program..

[49]  Philippa Gardner,et al.  From Action Calculi to Linear Logic , 1997, CSL.

[50]  Lawrence C. Paulson,et al.  Mechanized proofs for a recursive authentication protocol , 1997, Proceedings 10th Computer Security Foundations Workshop.

[51]  Ronald Fagin,et al.  Reasoning about knowledge , 1995 .

[52]  Joshua D. Guttman,et al.  Strand Spaces: Proving Security Protocols Correct , 1999, J. Comput. Secur..

[53]  Samson Abramsky,et al.  Process Realizability , 2015, Realizability Semantics and Applications@FLoC.

[54]  Ronald Fagin,et al.  Knowledge-based programs , 1995, PODC '95.

[55]  Thierry Coquand,et al.  The Calculus of Constructions , 1988, Inf. Comput..

[56]  Robbert van Renesse,et al.  Building adaptive systems using ensemble , 1998 .