Formal analysis of concurrent programs

In this thesis, extensions of Kleene algebras are used to develop algebras for rely-guarantee style reasoning about concurrent programs. In addition to these algebras, detailed denotational models are implemented in the interactive theorem prover Isabelle/HOL. Formal soundness proofs link the algebras to their models. This follows a general algebraic approach for developing correct by construction verification tools within Isabelle. In this approach, algebras provide inference rules and abstract principles for reasoning about the control flow of programs, while the concrete models provide laws for reasoning about data flow. This yields a rapid, lightweight approach for the construction of verification and refinement tools. These tools are used to construct a popular example from the literature, via refinement, within the context of a general-purpose interactive theorem proving environment.

[1]  Lukas Bulwahn,et al.  The New Quickcheck for Isabelle - Random, Exhaustive and Symbolic Testing under One Roof , 2012, CPP.

[2]  Georg Struth,et al.  Kleene Algebra with Tests and Demonic Refinement Algebras , 2014, Arch. Formal Proofs.

[3]  Damien Pous,et al.  Kleene Algebra with Tests and Coq Tools for while Programs , 2013, ITP.

[4]  Damien Pous,et al.  Deciding Kleene Algebras in Coq , 2011, Log. Methods Comput. Sci..

[5]  Stephen Brookes.  A semantics for concurrent separation logic , 2007, Theor. Comput. Sci..

[6]  P ? ? ? ? ? ? ? % ? ? ? ? , 1991 .

[7]  Tobias Nipkow,et al.  Winskel is (almost) Right: Towards a Mechanized Semantics Textbook , 1996, Formal Aspects of Computing.

[8]  Peter W. O'Hearn,et al.  Local Action and Abstract Separation Logic , 2007, 22nd Annual IEEE Symposium on Logic in Computer Science (LICS 2007).

[9]  Jozef Hooman,et al.  Concurrency Verification: Introduction to Compositional and Noncompositional Methods , 2001, Cambridge Tracts in Theoretical Computer Science.

[10]  Georg Struth,et al.  Hybrid process algebra , 2005, J. Log. Algebraic Methods Program..

[11]  Joseph E. Stoy,et al.  Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory , 1981 .

[12]  Carroll Morgan,et al.  The specification statement , 1988, TOPL.

[13]  D. Kozen,et al.  Kleene Algebra with Tests and Program Schematology , 2001 .

[14]  Makarius Wenzel.  Isabelle/Isar — a Generic Framework for Human-Readable Proof Documents , 2007 .

[15]  Georg Struth,et al.  Algebraic notions of nontermination: Omega and divergence in idempotent semirings , 2010, J. Log. Algebraic Methods Program..

[16]  Vaughan R. Pratt,et al.  Action Logic and Pure Induction , 1990, JELIA.

[17]  Zohar Manna,et al.  Mathematical Theory of Computation , 2003 .

[18]  Joakim von Wright,et al.  Towards a refinement algebra , 2004, Sci. Comput. Program..

[19]  Maarten M. Fokkinga,et al.  Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire , 1991, FPCA.

[20]  Tobias Nipkow,et al.  Automatic Proof and Disproof in Isabelle/HOL , 2011, FroCoS.

[21]  Rafal Kolanski,et al.  Mechanised Separation Algebra , 2012, ITP.

[22]  Georg Struth,et al.  Algebraic Notions of Termination , 2010, Log. Methods Comput. Sci..

[23]  Georg Struth,et al.  A Program Construction and Verification Tool for Separation Logic , 2015, MPC.

[24]  Krzysztof R. Apt,et al.  Recursive assertions and parallel programs , 1981, Acta Informatica.

[25]  Georg Struth,et al.  Automated Reasoning in Kleene Algebra , 2007, CADE.

[26]  Susan Owicki,et al.  An axiomatic proof technique for parallel programs I , 1976, Acta Informatica.

[27]  Hans Leiß,et al.  Kleene modules and linear languages , 2006, J. Log. Algebraic Methods Program..

[28]  Georg Struth,et al.  Kleene algebra with domain , 2003, TOCL.

[29]  Georg Struth,et al.  Automated Reasoning in Higher-Order Regular Algebra , 2012, RAMiCS.

[30]  Mark Harman,et al.  Formal Aspects of Computing: Guest Editorial , 2006 .

[31]  Markus Wenzel,et al.  Local Theory Specifications in Isabelle/Isar , 2009, TYPES.

[32]  Peter W. O'Hearn,et al.  Local Reasoning about Programs that Alter Data Structures , 2001, CSL.

[33]  Markus Wenzel,et al.  An Isabelle Proof Method Language , 2014, ITP.

[34]  Tobias Nipkow,et al.  Regular Sets and Expressions , 2010, Arch. Formal Proofs.

[35]  Georg Struth,et al.  Omega Algebras and Regular Equations , 2011, RAMiCS.

[36]  Viktor Vafeiadis,et al.  Modular fine-grained concurrency verification , 2008 .

[37]  Georg Struth,et al.  Automating Algebraic Methods in Isabelle , 2011, ICFEM.

[38]  Stephen D. Brookes.  Full Abstraction for a Shared-Variable Parallel Language , 1996, Inf. Comput..

[39]  Georg Struth,et al.  Kleene Algebra , 2013, Arch. Formal Proofs.

[40]  Susan S. Owicki,et al.  Axiomatic Proof Techniques for Parallel Programs , 1975, Outstanding Dissertations in the Computer Sciences.

[41]  Dexter Kozen,et al.  Automata and Computability , 1997, Undergraduate Texts in Computer Science.

[42]  Dexter Kozen.  On Hoare logic and Kleene algebra with tests , 2000, TOCL.

[43]  Georg Struth,et al.  On Automated Program Construction and Verification , 2010, MPC.

[44]  Peter W. O'Hearn,et al.  Resources, concurrency, and local reasoning , 2007 .

[45]  Georg Struth,et al.  Algebraic Principles for Rely-Guarantee Style Concurrency Verification Tools , 2013, FM.

[46]  Jules Desharnais,et al.  Describing data flow analysis techniques with Kleene algebra , 2007, Sci. Comput. Program..

[47]  Dexter Kozen.  A Completeness Theorem for Kleene Algebras and the Algebra of Regular Events , 1994, Inf. Comput..

[48]  Michael J. C. Gordon,et al.  Forward with Hoare , 2010, Reflections on the Work of C. A. R. Hoare.

[49]  Tobias Nipkow,et al.  Nitpick: A Counterexample Generator for Higher-Order Logic Based on a Relational Model Finder , 2010, ITP.

[50]  Andrzej Tarlecki,et al.  A Language of Specified Programs , 1985, Sci. Comput. Program..

[51]  Andrei Popescu,et al.  Truly Modular (Co)datatypes for Isabelle/HOL , 2014, ITP.

[52]  Leonor Prensa Nieto.  Verification of parallel programs with the Owicki-Gries and Rely-Guarantee methods in Isabelle, HOL , 2002 .

[53]  Jürgen Dingel,et al.  A Refinement Calculus for Shared-Variable Parallel and Distributed Programming , 2002, Formal Aspects of Computing.

[54]  Jay L. Gischer,et al.  The Equational Theory of Pomsets , 1988, Theor. Comput. Sci..

[55]  Ernie Cohen,et al.  Separation and Reduction , 2000, MPC.

[56]  Cezary Kaliszyk,et al.  Quotients revisited for Isabelle/HOL , 2011, SAC '11.

[57]  Walter Guttmann,et al.  Algebras for iteration and infinite computations , 2012, Acta Informatica.

[58]  C. B. Jones,et al.  Reasoning about concurrent programs: Refining rely-guarantee thinking , 2013 .

[59]  Leonor Prensa Nieto.  The Rely-Guarantee Method in Isabelle/HOL , 2003, ESOP.

[60]  Simon Foster,et al.  Automated Analysis of Regular Algebra , 2012, IJCAR.

[61]  Grzegorz Rozenberg,et al.  Shuffle-like Operations on omega-words , 1997, New Trends in Formal Languages.

[62]  Zoltán Ésik,et al.  Free Shuffle Algebras in Language Varieties , 1996, Theor. Comput. Sci..

[63]  Tobias Nipkow,et al.  A Proof Assistant for Higher-Order Logic , 2002 .

[64]  Colin Stirling,et al.  A Generalization of Owicki-Gries's Hoare Logic for a Concurrent while Language , 1988, Theor. Comput. Sci..

[65]  Han-Hing Dang,et al.  Algebraic separation logic , 2011, J. Log. Algebraic Methods Program..

[66]  Lars Birkedal,et al.  Ynot: dependent types for imperative programs , 2008, ICFP 2008.

[67]  Thomas Hillenbrand,et al.  WALDMEISTER: High Performance Equational Theorem Proving , 1996, DISCO.

[68]  Georg Struth,et al.  Program Analysis and Verification Based on Kleene Algebra in Isabelle/HOL , 2013, ITP.

[69]  Georg Struth,et al.  Algebras for Program Correctness in Isabelle/HOL , 2014, RAMiCS.

[70]  J. Conway.  Regular algebra and finite machines , 1971 .

[71]  Dexter Kozen,et al.  KAT-ML: an interactive theorem prover for Kleene algebra with tests , 2006, J. Appl. Non Class. Logics.

[72]  Cliff B. Jones,et al.  Specification and Design of (Parallel) Programs , 1983, IFIP Congress.

[73]  Norbert Schirmer,et al.  Verification of sequential imperative programs in Isabelle-HOL , 2006 .

[74]  Georg Struth,et al.  Programming and automating mathematics in the Tarski-Kleene hierarchy , 2014, J. Log. Algebraic Methods Program..

[75]  Georg Struth,et al.  Lightweight Program Construction and Verification Tools in Isabelle/HOL , 2014, SEFM.

[76]  John C. Reynolds,et al.  Separation logic: a logic for shared mutable data structures , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[77]  Cliff B. Jones,et al.  Developing methods for computer programs including a notion of interference , 1981 .

[78]  Frank S. de Boer,et al.  Formal Justification of the Rely-Guarantee Paradigm for Shared-Variable Concurrency: A Semantic Approach , 1999, World Congress on Formal Methods.

[79]  Georg Struth,et al.  Algebras of modal operators and partial correctness , 2006, Theor. Comput. Sci..

[80]  Brian Huffman,et al.  Lifting and Transfer: A Modular Design for Quotients in Isabelle/HOL , 2013, CPP.

[81]  Alasdair Armstrong,et al.  An Evaluation of Automated Theorem Proving in Regular Algebra ( Extended Abstract ) , 2012 .

[82]  Rafal Kolanski,et al.  Separation Algebra , 2012, Arch. Formal Proofs.

[83]  Clemens Ballarin.  Tutorial to locales and locale interpretation , 2005 .