diff --git a/web/entries/Algebraic_Numbers.shtml b/web/entries/Algebraic_Numbers.shtml --- a/web/entries/Algebraic_Numbers.shtml +++ b/web/entries/Algebraic_Numbers.shtml @@ -1,129 +1,129 @@ Archive of Formal Proofs

 

Algebraic Numbers in Isabelle/HOL

- +
Title: Algebraic Numbers in Isabelle/HOL
Author: René Thiemann (rene /dot/ thiemann /at/ uibk /dot/ ac /dot/ at) and Akihisa Yamada (akihisa /dot/ yamada /at/ uibk /dot/ ac /dot/ at)
Submission date: 2015-12-22
Abstract: Based on existing libraries for matrices, factorization of rational polynomials, and Sturm's theorem, we formalized algebraic numbers in Isabelle/HOL. Our development serves as an implementation for real and complex numbers, and it admits to compute roots and completely factorize real and complex polynomials, provided that all coefficients are rational numbers. Moreover, we provide two implementations to display algebraic numbers, an injective and expensive one, or a faster but approximative version.

To this end, we mechanized several results on resultants, which also required us to prove that polynomials over a unique factorization domain form again a unique factorization domain.

Change history: [2016-01-29]: Split off Polynomial Interpolation and Polynomial Factorization
BibTeX:
@article{Algebraic_Numbers-AFP,
   author  = {René Thiemann and Akihisa Yamada},
   title   = {Algebraic Numbers in Isabelle/HOL},
   journal = {Archive of Formal Proofs},
   month   = dec,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/Algebraic_Numbers.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Sturm_Sequences, Show, Deriving, Polynomial_Interpolation, Abstract-Rewriting, Jordan_Normal_Form, Polynomial_Factorization, Containers
Abstract-Rewriting, Containers, Deriving, Jordan_Normal_Form, Polynomial_Factorization, Polynomial_Interpolation, Show, Sturm_Sequences

diff --git a/web/entries/Amortized_Complexity.shtml b/web/entries/Amortized_Complexity.shtml --- a/web/entries/Amortized_Complexity.shtml +++ b/web/entries/Amortized_Complexity.shtml @@ -1,135 +1,135 @@ Archive of Formal Proofs

 

Amortized Complexity Verified

- +
Title: Amortized Complexity Verified
Author: Tobias Nipkow
Submission date: 2014-07-07
Abstract: A framework for the analysis of the amortized complexity of (functional) data structures is formalized in Isabelle/HOL and applied to a number of standard examples and to the folowing non-trivial ones: skew heaps, splay trees, splay heaps and pairing heaps. This work is described in a paper published in the proceedings of the conference on Interactive Theorem Proving ITP 2015.
Change history: [2015-03-17]: Added pairing heaps by Hauke Brinkop.
BibTeX:
@article{Amortized_Complexity-AFP,
   author  = {Tobias Nipkow},
   title   = {Amortized Complexity Verified},
   journal = {Archive of Formal Proofs},
   month   = jul,
   year    = 2014,
   note    = {\url{http://afp.sf.net/entries/Amortized_Complexity.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Splay_Tree, Skew_Heap, List-Index
List-Index, Skew_Heap, Splay_Tree

diff --git a/web/entries/CAVA_LTL_Modelchecker.shtml b/web/entries/CAVA_LTL_Modelchecker.shtml --- a/web/entries/CAVA_LTL_Modelchecker.shtml +++ b/web/entries/CAVA_LTL_Modelchecker.shtml @@ -1,142 +1,142 @@ Archive of Formal Proofs

 

A Fully Verified Executable LTL Model Checker

- +
Title: A Fully Verified Executable LTL Model Checker
Author: Javier Esparza, Peter Lammich, René Neumann (rene /dot/ neumann /at/ in /dot/ tum /dot/ de), Tobias Nipkow, Alexander Schimpf (schimpfa /at/ informatik /dot/ uni-freiburg /dot/ de) and Jan-Georg Smaus
Submission date: 2014-05-28
Abstract: We present an LTL model checker whose code has been completely verified using the Isabelle theorem prover. The checker consists of over 4000 lines of ML code. The code is produced using the Isabelle Refinement Framework, which allows us to split its correctness proof into (1) the proof of an abstract version of the checker, consisting of a few hundred lines of ``formalized pseudocode'', and (2) a verified refinement step in which mathematical sets and other abstract structures are replaced by implementations of efficient structures like red-black trees and functional arrays. This leads to a checker that, while still slower than unverified checkers, can already be used as a trusted reference implementation against which advanced implementations can be tested.

An early version of this model checker is described in the CAV 2013 paper with the same title.

BibTeX:
@article{CAVA_LTL_Modelchecker-AFP,
   author  = {Javier Esparza and Peter Lammich and René Neumann and Tobias Nipkow and Alexander Schimpf and Jan-Georg Smaus},
   title   = {A Fully Verified Executable LTL Model Checker},
   journal = {Archive of Formal Proofs},
   month   = may,
   year    = 2014,
   note    = {\url{http://afp.sf.net/entries/CAVA_LTL_Modelchecker.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:CAVA_Automata, Gabow_SCC, Promela, LTL_to_GBA
CAVA_Automata, Gabow_SCC, LTL_to_GBA, Promela

diff --git a/web/entries/Collections.shtml b/web/entries/Collections.shtml --- a/web/entries/Collections.shtml +++ b/web/entries/Collections.shtml @@ -1,155 +1,155 @@ Archive of Formal Proofs

 

Collections Framework

- +
Title: Collections Framework
Author: Peter Lammich
Contributors: Andreas Lochbihler and Thomas Tuerk
Submission date: 2009-11-25
Abstract: This development provides an efficient, extensible, machine checked collections framework. The library adopts the concepts of interface, implementation and generic algorithm from object-oriented programming and implements them in Isabelle/HOL. The framework features the use of data refinement techniques to refine an abstract specification (using high-level concepts like sets) to a more concrete implementation (using collection datastructures, like red-black-trees). The code-generator of Isabelle/HOL can be used to generate efficient code.
Change history: [2010-10-08]: New Interfaces: OrderedSet, OrderedMap, List. Fifo now implements list-interface: Function names changed: put/get --> enqueue/dequeue. New Implementations: ArrayList, ArrayHashMap, ArrayHashSet, TrieMap, TrieSet. Invariant-free datastructures: Invariant implicitely hidden in typedef. Record-interfaces: All operations of an interface encapsulated as record. Examples moved to examples subdirectory.
[2010-12-01]: New Interfaces: Priority Queues, Annotated Lists. Implemented by finger trees, (skew) binomial queues.
[2011-10-10]: SetSpec: Added operations: sng, isSng, bexists, size_abort, diff, filter, iterate_rule_insertP MapSpec: Added operations: sng, isSng, iterate_rule_insertP, bexists, size, size_abort, restrict, map_image_filter, map_value_image_filter Some maintenance changes
[2012-04-25]: New iterator foundation by Tuerk. Various maintenance changes.
[2012-08]: Collections V2. New features: Polymorphic iterators. Generic algorithm instantiation where required. Naming scheme changed from xx_opname to xx.opname. A compatibility file CollectionsV1 tries to simplify porting of existing theories, by providing old naming scheme and the old monomorphic iterator locales.
[2013-09]: Added Generic Collection Framework based on Autoref. The GenCF provides: Arbitrary nesting, full integration with Autoref.
[2014-06]: Maintenace changes to GenCF: Optimized inj_image on list_set. op_set_cart (Cartesian product). big-Union operation. atLeastLessThan - operation ({a..<b})
BibTeX:
@article{Collections-AFP,
   author  = {Peter Lammich},
   title   = {Collections Framework},
   journal = {Archive of Formal Proofs},
   month   = nov,
   year    = 2009,
   note    = {\url{http://afp.sf.net/entries/Collections.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Finger-Trees, Native_Word, Trie, Automatic_Refinement, Refine_Monadic, Binomial-Heaps
Automatic_Refinement, Binomial-Heaps, Finger-Trees, Native_Word, Refine_Monadic, Trie

diff --git a/web/entries/Containers.shtml b/web/entries/Containers.shtml --- a/web/entries/Containers.shtml +++ b/web/entries/Containers.shtml @@ -1,142 +1,142 @@ Archive of Formal Proofs

 

Light-weight Containers

- +
Title: Light-weight Containers
Author: Andreas Lochbihler
Contributors: René Thiemann (rene /dot/ thiemann /at/ uibk /dot/ ac /dot/ at)
Submission date: 2013-04-15
Abstract: This development provides a framework for container types like sets and maps such that generated code implements these containers with different (efficient) data structures. Thanks to type classes and refinement during code generation, this light-weight approach can seamlessly replace Isabelle's default setup for code generation. Heuristics automatically pick one of the available data structures depending on the type of elements to be stored, but users can also choose on their own. The extensible design permits to add more implementations at any time.

To support arbitrary nesting of sets, we define a linear order on sets based on a linear order of the elements and provide efficient implementations. It even allows to compare complements with non-complements.

Change history: [2013-07-11]: add pretty printing for sets (revision 7f3f52c5f5fa)
[2013-09-20]: provide generators for canonical type class instantiations (revision 159f4401f4a8 by René Thiemann)
[2014-07-08]: add support for going from partial functions to mappings (revision 7a6fc957e8ed)
BibTeX:
@article{Containers-AFP,
   author  = {Andreas Lochbihler},
   title   = {Light-weight Containers},
   journal = {Archive of Formal Proofs},
   month   = apr,
   year    = 2013,
   note    = {\url{http://afp.sf.net/entries/Containers.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Deriving, Collections, Regular-Sets
Collections, Deriving, Regular-Sets

diff --git a/web/entries/Datatype_Order_Generator.shtml b/web/entries/Datatype_Order_Generator.shtml --- a/web/entries/Datatype_Order_Generator.shtml +++ b/web/entries/Datatype_Order_Generator.shtml @@ -1,140 +1,140 @@ Archive of Formal Proofs

 

Generating linear orders for datatypes

- +
Title: Generating linear orders for datatypes
Author: René Thiemann (rene /dot/ thiemann /at/ uibk /dot/ ac /dot/ at)
Submission date: 2012-08-07
Abstract: We provide a framework for registering automatic methods to derive class instances of datatypes, as it is possible using Haskell's ``deriving Ord, Show, ...'' feature.

We further implemented such automatic methods to derive (linear) orders or hash-functions which are required in the Isabelle Collection Framework. Moreover, for the tactic of Huffman and Krauss to show that a datatype is countable, we implemented a wrapper so that this tactic becomes accessible in our framework.

Our formalization was performed as part of the IsaFoR/CeTA project. With our new tactic we could completely remove tedious proofs for linear orders of two datatypes.

This development is aimed at datatypes generated by the "old_datatype" command.

BibTeX:
@article{Datatype_Order_Generator-AFP,
   author  = {René Thiemann},
   title   = {Generating linear orders for datatypes},
   journal = {Archive of Formal Proofs},
   month   = aug,
   year    = 2012,
   note    = {\url{http://afp.sf.net/entries/Datatype_Order_Generator.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Deriving, Collections
Collections, Deriving

diff --git a/web/entries/Decreasing-Diagrams-II.shtml b/web/entries/Decreasing-Diagrams-II.shtml --- a/web/entries/Decreasing-Diagrams-II.shtml +++ b/web/entries/Decreasing-Diagrams-II.shtml @@ -1,119 +1,119 @@ Archive of Formal Proofs

 

Decreasing Diagrams II

- +
Title: Decreasing Diagrams II
Author: Bertram Felgenhauer (bertram /dot/ felgenhauer /at/ uibk /dot/ ac /dot/ at)
Submission date: 2015-08-20
Abstract: This theory formalizes the commutation version of decreasing diagrams for Church-Rosser modulo. The proof follows Felgenhauer and van Oostrom (RTA 2013). The theory also provides important specializations, in particular van Oostrom’s conversion version (TCS 2008) of decreasing diagrams.
BibTeX:
@article{Decreasing-Diagrams-II-AFP,
   author  = {Bertram Felgenhauer},
   title   = {Decreasing Diagrams II},
   journal = {Archive of Formal Proofs},
   month   = aug,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/Decreasing-Diagrams-II.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: GNU Lesser General Public License (LGPL)
Depends on:Well_Quasi_Orders, Abstract-Rewriting
Abstract-Rewriting, Well_Quasi_Orders

diff --git a/web/entries/Echelon_Form.shtml b/web/entries/Echelon_Form.shtml --- a/web/entries/Echelon_Form.shtml +++ b/web/entries/Echelon_Form.shtml @@ -1,119 +1,119 @@ Archive of Formal Proofs

 

Echelon Form

- +
Title: Echelon Form
Author: Jose Divasón and Jesús Aransay
Submission date: 2015-02-12
Abstract: We formalize an algorithm to compute the Echelon Form of a matrix. We have proved its existence over Bézout domains and made it executable over Euclidean domains, such as the integer ring and the univariate polynomials over a field. This allows us to compute determinants, inverses and characteristic polynomials of matrices. The work is based on the HOL-Multivariate Analysis library, and on both the Gauss-Jordan and Cayley-Hamilton AFP entries. As a by-product, some algebraic structures have been implemented (principal ideal domains, Bézout domains...). The algorithm has been refined to immutable arrays and code can be generated to functional languages as well.
BibTeX:
@article{Echelon_Form-AFP,
   author  = {Jose Divasón and Jesús Aransay},
   title   = {Echelon Form},
   journal = {Archive of Formal Proofs},
   month   = feb,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/Echelon_Form.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Gauss_Jordan, Cayley_Hamilton
Cayley_Hamilton, Gauss_Jordan

diff --git a/web/entries/Finite_Automata_HF.shtml b/web/entries/Finite_Automata_HF.shtml --- a/web/entries/Finite_Automata_HF.shtml +++ b/web/entries/Finite_Automata_HF.shtml @@ -1,128 +1,128 @@ Archive of Formal Proofs

 

Finite Automata in Hereditarily Finite Set Theory

- +
Title: Finite Automata in Hereditarily Finite Set Theory
Author: Lawrence C. Paulson
Submission date: 2015-02-05
Abstract: Finite Automata, both deterministic and non-deterministic, for regular languages. The Myhill-Nerode Theorem. Closure under intersection, concatenation, etc. Regular expressions define regular languages. Closure under reversal; the powerset construction mapping NFAs to DFAs. Left and right languages; minimal DFAs. Brzozowski's minimization algorithm. Uniqueness up to isomorphism of minimal DFAs.
BibTeX:
@article{Finite_Automata_HF-AFP,
   author  = {Lawrence C. Paulson},
   title   = {Finite Automata in Hereditarily Finite Set Theory},
   journal = {Archive of Formal Proofs},
   month   = feb,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/Finite_Automata_HF.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Regular-Sets, HereditarilyFinite
HereditarilyFinite, Regular-Sets

diff --git a/web/entries/Formal_SSA.shtml b/web/entries/Formal_SSA.shtml --- a/web/entries/Formal_SSA.shtml +++ b/web/entries/Formal_SSA.shtml @@ -1,139 +1,139 @@ Archive of Formal Proofs

 

Verified Construction of Static Single Assignment Form

- +
Title: Verified Construction of Static Single Assignment Form
Author: Sebastian Ullrich (sebasti /at/ nullri /dot/ ch) and Denis Lohner
Submission date: 2016-02-05
Abstract: We define a functional variant of the static single assignment (SSA) form construction algorithm described by Braun et al., which combines simplicity and efficiency. The definition is based on a general, abstract control flow graph representation using Isabelle locales.

We prove that the algorithm's output is semantically equivalent to the input according to a small-step semantics, and that it is in minimal SSA form for the common special case of reducible inputs. We then show the satisfiability of the locale assumptions by giving instantiations for a simple While language.

Furthermore, we use a generic instantiation based on typedefs in order to extract OCaml code and replace the unverified SSA construction algorithm of the CompCertSSA project with it.

BibTeX:
@article{Formal_SSA-AFP,
   author  = {Sebastian Ullrich and Denis Lohner},
   title   = {Verified Construction of Static Single Assignment Form},
   journal = {Archive of Formal Proofs},
   month   = feb,
   year    = 2016,
   note    = {\url{http://afp.sf.net/entries/Formal_SSA.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Slicing, Collections, Dijkstra_Shortest_Path
Collections, Dijkstra_Shortest_Path, Slicing

diff --git a/web/entries/Formula_Derivatives.shtml b/web/entries/Formula_Derivatives.shtml --- a/web/entries/Formula_Derivatives.shtml +++ b/web/entries/Formula_Derivatives.shtml @@ -1,135 +1,135 @@ Archive of Formal Proofs

 

Derivatives of Logical Formulas

- +
Title: Derivatives of Logical Formulas
Author: Dmitriy Traytel
Submission date: 2015-05-28
Abstract: We formalize new decision procedures for WS1S, M2L(Str), and Presburger Arithmetics. Formulas of these logics denote regular languages. Unlike traditional decision procedures, we do not translate formulas into automata (nor into regular expressions), at least not explicitly. Instead we devise notions of derivatives (inspired by Brzozowski derivatives for regular expressions) that operate on formulas directly and compute a syntactic bisimulation using these derivatives. The treatment of Boolean connectives and quantifiers is uniform for all mentioned logics and is abstracted into a locale. This locale is then instantiated by different atomic formulas and their derivatives (which may differ even for the same logic under different encodings of interpretations as formal words).

The WS1S instance is described in the draft paper A Coalgebraic Decision Procedure for WS1S by the author.

BibTeX:
@article{Formula_Derivatives-AFP,
   author  = {Dmitriy Traytel},
   title   = {Derivatives of Logical Formulas},
   journal = {Archive of Formal Proofs},
   month   = may,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/Formula_Derivatives.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Deriving, Coinductive_Languages, List-Index, Show
Coinductive_Languages, Deriving, List-Index, Show

diff --git a/web/entries/Jordan_Normal_Form.shtml b/web/entries/Jordan_Normal_Form.shtml --- a/web/entries/Jordan_Normal_Form.shtml +++ b/web/entries/Jordan_Normal_Form.shtml @@ -1,139 +1,139 @@ Archive of Formal Proofs

 

Matrices, Jordan Normal Forms, and Spectral Radius Theory

- +
Title: Matrices, Jordan Normal Forms, and Spectral Radius Theory
Author: René Thiemann (rene /dot/ thiemann /at/ uibk /dot/ ac /dot/ at) and Akihisa Yamada (akihisa /dot/ yamada /at/ uibk /dot/ ac /dot/ at)
Submission date: 2015-08-21
Abstract:

Matrix interpretations are useful as measure functions in termination proving. In order to use these interpretations also for complexity analysis, the growth rate of matrix powers has to examined. Here, we formalized a central result of spectral radius theory, namely that the growth rate is polynomially bounded if and only if the spectral radius of a matrix is at most one.

To formally prove this result we first studied the growth rates of matrices in Jordan normal form, and partially prove the result that every complex matrix has a Jordan normal form: we are restricted to upper-triangular matrices since we did not yet formalize the Schur decomposition.

The whole development is based on a new abstract type for matrices, which is also executable by a suitable setup of the code generator. It completely subsumes our former AFP-entry on executable matrices, and its main advantage is its close connection to the HMA-representation which allowed us to easily adapt existing proofs on determinants.

All the results have been applied to improve CeTA, our certifier to validate termination and complexity proof certificates.

Change history: [2016-01-07]: Added Schur-decomposition, Gram-Schmidt orthogonalization, uniqueness of Jordan normal forms
BibTeX:
@article{Jordan_Normal_Form-AFP,
   author  = {René Thiemann and Akihisa Yamada},
   title   = {Matrices, Jordan Normal Forms, and Spectral Radius Theory},
   journal = {Archive of Formal Proofs},
   month   = aug,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/Jordan_Normal_Form.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Matrix, Show, Gauss_Jordan, Polynomial_Interpolation, VectorSpace, Containers, Abstract-Rewriting
Abstract-Rewriting, Containers, Gauss_Jordan, Matrix, Polynomial_Interpolation, Show, VectorSpace

diff --git a/web/entries/KBPs.shtml b/web/entries/KBPs.shtml --- a/web/entries/KBPs.shtml +++ b/web/entries/KBPs.shtml @@ -1,132 +1,132 @@ Archive of Formal Proofs

 

Knowledge-based programs

- +
Title: Knowledge-based programs
Author: Peter Gammie
Submission date: 2011-05-17
Abstract: Knowledge-based programs (KBPs) are a formalism for directly relating agents' knowledge and behaviour. Here we present a general scheme for compiling KBPs to executable automata with a proof of correctness in Isabelle/HOL. We develop the algorithm top-down, using Isabelle's locale mechanism to structure these proofs, and show that two classic examples can be synthesised using Isabelle's code generator.
Change history: [2012-03-06]: Add some more views and revive the code generation.
BibTeX:
@article{KBPs-AFP,
   author  = {Peter Gammie},
   title   = {Knowledge-based programs},
   journal = {Archive of Formal Proofs},
   month   = may,
   year    = 2011,
   note    = {\url{http://afp.sf.net/entries/KBPs.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Trie, Transitive-Closure
Transitive-Closure, Trie

diff --git a/web/entries/LTL_to_DRA.shtml b/web/entries/LTL_to_DRA.shtml --- a/web/entries/LTL_to_DRA.shtml +++ b/web/entries/LTL_to_DRA.shtml @@ -1,131 +1,131 @@ Archive of Formal Proofs

 

Converting Linear Temporal Logic to Deterministic (Generalized) Rabin Automata

- +
Title: Converting Linear Temporal Logic to Deterministic (Generalized) Rabin Automata
Author: Salomon Sickert (sickert /at/ in /dot/ tum /dot/ de)
Submission date: 2015-09-04
Abstract: Recently, Javier Esparza and Jan Kretinsky proposed a new method directly translating linear temporal logic (LTL) formulas to deterministic (generalized) Rabin automata. Compared to the existing approaches of constructing a non-deterministic Buechi-automaton in the first step and then applying a determinization procedure (e.g. some variant of Safra's construction) in a second step, this new approach preservers a relation between the formula and the states of the resulting automaton. While the old approach produced a monolithic structure, the new method is compositional. Furthermore, in some cases the resulting automata are much smaller than the automata generated by existing approaches. In order to ensure the correctness of the construction, this entry contains a complete formalisation and verification of the translation. Furthermore from this basis executable code is generated.
Change history: [2015-09-23]: Enable code export for the eager unfolding optimisation and reduce running time of the generated tool. Moreover, add support for the mlton SML compiler.
BibTeX:
@article{LTL_to_DRA-AFP,
   author  = {Salomon Sickert},
   title   = {Converting Linear Temporal Logic to Deterministic (Generalized) Rabin Automata},
   journal = {Archive of Formal Proofs},
   month   = sep,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/LTL_to_DRA.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:KBPs, List-Index, Boolean_Expression_Checkers
Boolean_Expression_Checkers, KBPs, List-Index

diff --git a/web/entries/LTL_to_GBA.shtml b/web/entries/LTL_to_GBA.shtml --- a/web/entries/LTL_to_GBA.shtml +++ b/web/entries/LTL_to_GBA.shtml @@ -1,137 +1,137 @@ Archive of Formal Proofs

 

Converting Linear-Time Temporal Logic to Generalized Büchi Automata

- +
Title: Converting Linear-Time Temporal Logic to Generalized Büchi Automata
Author: Alexander Schimpf (schimpfa /at/ informatik /dot/ uni-freiburg /dot/ de) and Peter Lammich
Submission date: 2014-05-28
Abstract: We formalize linear-time temporal logic (LTL) and the algorithm by Gerth et al. to convert LTL formulas to generalized Büchi automata. We also formalize some syntactic rewrite rules that can be applied to optimize the LTL formula before conversion. Moreover, we integrate the Stuttering Equivalence AFP-Entry by Stefan Merz, adapting the lemma that next-free LTL formula cannot distinguish between stuttering equivalent runs to our setting.

We use the Isabelle Refinement and Collection framework, as well as the Autoref tool, to obtain a refined version of our algorithm, from which efficiently executable code can be extracted.

BibTeX:
@article{LTL_to_GBA-AFP,
   author  = {Alexander Schimpf and Peter Lammich},
   title   = {Converting Linear-Time Temporal Logic to Generalized Büchi Automata},
   journal = {Archive of Formal Proofs},
   month   = may,
   year    = 2014,
   note    = {\url{http://afp.sf.net/entries/LTL_to_GBA.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Deriving, CAVA_Automata, Stuttering_Equivalence
CAVA_Automata, Deriving, Stuttering_Equivalence

diff --git a/web/entries/Myhill-Nerode.shtml b/web/entries/Myhill-Nerode.shtml --- a/web/entries/Myhill-Nerode.shtml +++ b/web/entries/Myhill-Nerode.shtml @@ -1,130 +1,130 @@ Archive of Formal Proofs

 

The Myhill-Nerode Theorem Based on Regular Expressions

- +
Title: The Myhill-Nerode Theorem Based on Regular Expressions
Author: Chunhan Wu, Xingyuan Zhang and Christian Urban
Submission date: 2011-08-26
Abstract: There are many proofs of the Myhill-Nerode theorem using automata. In this library we give a proof entirely based on regular expressions, since regularity of languages can be conveniently defined using regular expressions (it is more painful in HOL to define regularity in terms of automata). We prove the first direction of the Myhill-Nerode theorem by solving equational systems that involve regular expressions. For the second direction we give two proofs: one using tagging-functions and another using partial derivatives. We also establish various closure properties of regular languages. Most details of the theories are described in our ITP 2011 paper.
BibTeX:
@article{Myhill-Nerode-AFP,
   author  = {Chunhan Wu and Xingyuan Zhang and Christian Urban},
   title   = {The Myhill-Nerode Theorem Based on Regular Expressions},
   journal = {Archive of Formal Proofs},
   month   = aug,
   year    = 2011,
   note    = {\url{http://afp.sf.net/entries/Myhill-Nerode.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Well_Quasi_Orders, Regular-Sets
Regular-Sets, Well_Quasi_Orders

diff --git a/web/entries/Network_Security_Policy_Verification.shtml b/web/entries/Network_Security_Policy_Verification.shtml --- a/web/entries/Network_Security_Policy_Verification.shtml +++ b/web/entries/Network_Security_Policy_Verification.shtml @@ -1,164 +1,164 @@ Archive of Formal Proofs

 

Network Security Policy Verification

- +
Title: Network Security Policy Verification
Author: Cornelius Diekmann
Submission date: 2014-07-04
Abstract: We present a unified theory for verifying network security policies. A security policy is represented as directed graph. To check high-level security goals, security invariants over the policy are expressed. We cover monotonic security invariants, i.e. prohibiting more does not harm security. We provide the following contributions for the security invariant theory.
  • Secure auto-completion of scenario-specific knowledge, which eases usability.
  • Security violations can be repaired by tightening the policy iff the security invariants hold for the deny-all policy.
  • An algorithm to compute a security policy.
  • A formalization of stateful connection semantics in network security mechanisms.
  • An algorithm to compute a secure stateful implementation of a policy.
  • An executable implementation of all the theory.
  • Examples, ranging from an aircraft cabin data network to the analysis of a large real-world firewall.
  • More examples: A fully automated translation of high-level security goals to both firewall and SDN configurations (see Examples/Distributed_WebApp.thy).
For a detailed description, see
Change history: [2015-04-14]: Added Distributed WebApp example and improved graphviz visualization (revision 4dde08ca2ab8)
BibTeX:
@article{Network_Security_Policy_Verification-AFP,
   author  = {Cornelius Diekmann},
   title   = {Network Security Policy Verification},
   journal = {Archive of Formal Proofs},
   month   = jul,
   year    = 2014,
   note    = {\url{http://afp.sf.net/entries/Network_Security_Policy_Verification.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Transitive-Closure, Collections, Automatic_Refinement
Automatic_Refinement, Collections, Transitive-Closure

diff --git a/web/entries/Noninterference_Ipurge_Unwinding.shtml b/web/entries/Noninterference_Ipurge_Unwinding.shtml --- a/web/entries/Noninterference_Ipurge_Unwinding.shtml +++ b/web/entries/Noninterference_Ipurge_Unwinding.shtml @@ -1,155 +1,155 @@ Archive of Formal Proofs

 

The Ipurge Unwinding Theorem for CSP Noninterference Security

- +
Title: The Ipurge Unwinding Theorem for CSP Noninterference Security
Author: Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
Submission date: 2015-06-11
Abstract:

The definition of noninterference security for Communicating Sequential Processes requires to consider any possible future, i.e. any indefinitely long sequence of subsequent events and any indefinitely large set of refused events associated to that sequence, for each process trace. In order to render the verification of the security of a process more straightforward, there is a need of some sufficient condition for security such that just individual accepted and refused events, rather than unbounded sequences and sets of events, have to be considered.

Of course, if such a sufficient condition were necessary as well, it would be even more valuable, since it would permit to prove not only that a process is secure by verifying that the condition holds, but also that a process is not secure by verifying that the condition fails to hold.

This paper provides a necessary and sufficient condition for CSP noninterference security, which indeed requires to just consider individual accepted and refused events and applies to the general case of a possibly intransitive policy. This condition follows Rushby's output consistency for deterministic state machines with outputs, and has to be satisfied by a specific function mapping security domains into equivalence relations over process traces. The definition of this function makes use of an intransitive purge function following Rushby's one; hence the name given to the condition, Ipurge Unwinding Theorem.

Furthermore, in accordance with Hoare's formal definition of deterministic processes, it is shown that a process is deterministic just in case it is a trace set process, i.e. it may be identified by means of a trace set alone, matching the set of its traces, in place of a failures-divergences pair. Then, variants of the Ipurge Unwinding Theorem are proven for deterministic processes and trace set processes.

BibTeX:
@article{Noninterference_Ipurge_Unwinding-AFP,
   author  = {Pasquale Noce},
   title   = {The Ipurge Unwinding Theorem for CSP Noninterference Security},
   journal = {Archive of Formal Proofs},
   month   = jun,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/Noninterference_Ipurge_Unwinding.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Noninterference_CSP, List_Interleaving
List_Interleaving, Noninterference_CSP

diff --git a/web/entries/Planarity_Certificates.shtml b/web/entries/Planarity_Certificates.shtml --- a/web/entries/Planarity_Certificates.shtml +++ b/web/entries/Planarity_Certificates.shtml @@ -1,121 +1,121 @@ Archive of Formal Proofs

 

Planarity Certificates

- +
Title: Planarity Certificates
Author: Lars Noschinski
Submission date: 2015-11-11
Abstract: This development provides a formalization of planarity based on combinatorial maps and proves that Kuratowski's theorem implies combinatorial planarity. Moreover, it contains verified implementations of programs checking certificates for planarity (i.e., a combinatorial map) or non-planarity (i.e., a Kuratowski subgraph).
BibTeX:
@article{Planarity_Certificates-AFP,
   author  = {Lars Noschinski},
   title   = {Planarity Certificates},
   journal = {Archive of Formal Proofs},
   month   = nov,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/Planarity_Certificates.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Case_Labeling, Transitive-Closure, Graph_Theory, Simpl, List-Index
Case_Labeling, Graph_Theory, List-Index, Simpl, Transitive-Closure

diff --git a/web/entries/Polynomial_Factorization.shtml b/web/entries/Polynomial_Factorization.shtml --- a/web/entries/Polynomial_Factorization.shtml +++ b/web/entries/Polynomial_Factorization.shtml @@ -1,129 +1,129 @@ Archive of Formal Proofs

 

Polynomial Factorization

- +
Title: Polynomial Factorization
Author: René Thiemann (rene /dot/ thiemann /at/ uibk /dot/ ac /dot/ at) and Akihisa Yamada (akihisa /dot/ yamada /at/ uibk /dot/ ac /dot/ at)
Submission date: 2016-01-29
Abstract: Based on existing libraries for polynomial interpolation and matrices, we formalized several factorization algorithms for polynomials, including Kronecker's algorithm for integer polynomials, Yun's square-free factorization algorithm for field polynomials, and Berlekamp's algorithm for polynomials over finite fields. By combining the last one with Hensel's lifting, we derive an efficient factorization algorithm for the integer polynomials, which is then lifted for rational polynomials by mechanizing Gauss' lemma. Finally, we assembled a combined factorization algorithm for rational polynomials, which combines all the mentioned algorithms and additionally uses the explicit formula for roots of quadratic polynomials and a rational root test.

As side products, we developed division algorithms for polynomials over integral domains, as well as primality-testing and prime-factorization algorithms for integers.

BibTeX:
@article{Polynomial_Factorization-AFP,
   author  = {René Thiemann and Akihisa Yamada},
   title   = {Polynomial Factorization},
   journal = {Archive of Formal Proofs},
   month   = jan,
   year    = 2016,
   note    = {\url{http://afp.sf.net/entries/Polynomial_Factorization.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Matrix, Show, Sqrt_Babylonian, Polynomial_Interpolation, Partial_Function_MR, Jordan_Normal_Form, Containers
Containers, Jordan_Normal_Form, Matrix, Partial_Function_MR, Polynomial_Interpolation, Show, Sqrt_Babylonian

diff --git a/web/entries/Promela.shtml b/web/entries/Promela.shtml --- a/web/entries/Promela.shtml +++ b/web/entries/Promela.shtml @@ -1,130 +1,130 @@ Archive of Formal Proofs

 

Promela Formalization

- +
Title: Promela Formalization
Author: René Neumann (rene /dot/ neumann /at/ in /dot/ tum /dot/ de)
Submission date: 2014-05-28
Abstract: We present an executable formalization of the language Promela, the description lasebastien.gouezel@univ-rennes1.frnguage for models of the model checker SPIN. This formalization is part of the work for a completely verified model checker (CAVA), but also serves as a useful (and executable!) description of the semantics of the language itself, something that is currently missing. The formalization uses three steps: It takes an abstract syntax tree generated from an SML parser, removes syntactic sugar and enriches it with type information. This further gets translated into a transition system, on which the semantic engine (read: successor function) operates.
BibTeX:
@article{Promela-AFP,
   author  = {René Neumann},
   title   = {Promela Formalization},
   journal = {Archive of Formal Proofs},
   month   = may,
   year    = 2014,
   note    = {\url{http://afp.sf.net/entries/Promela.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Deriving, CAVA_Automata, LTL_to_GBA
CAVA_Automata, Deriving, LTL_to_GBA

diff --git a/web/entries/QR_Decomposition.shtml b/web/entries/QR_Decomposition.shtml --- a/web/entries/QR_Decomposition.shtml +++ b/web/entries/QR_Decomposition.shtml @@ -1,125 +1,125 @@ Archive of Formal Proofs

 

QR Decomposition

- +
Title: QR Decomposition
Author: Jose Divasón and Jesús Aransay
Submission date: 2015-02-12
Abstract: QR decomposition is an algorithm to decompose a real matrix A into the product of two other matrices Q and R, where Q is orthogonal and R is invertible and upper triangular. The algorithm is useful for the least squares problem; i.e., the computation of the best approximation of an unsolvable system of linear equations. As a side-product, the Gram-Schmidt process has also been formalized. A refinement using immutable arrays is presented as well. The development relies, among others, on the AFP entry "Implementing field extensions of the form Q[sqrt(b)]" by René Thiemann, which allows execution of the algorithm using symbolic computations. Verified code can be generated and executed using floats as well.
Change history: [2015-06-18]: The second part of the Fundamental Theorem of Linear Algebra has been generalized to more general inner product spaces.
BibTeX:
@article{QR_Decomposition-AFP,
   author  = {Jose Divasón and Jesús Aransay},
   title   = {QR Decomposition},
   journal = {Archive of Formal Proofs},
   month   = feb,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/QR_Decomposition.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Real_Impl, Rank_Nullity_Theorem, Gauss_Jordan
Gauss_Jordan, Rank_Nullity_Theorem, Real_Impl

diff --git a/web/entries/Real_Impl.shtml b/web/entries/Real_Impl.shtml --- a/web/entries/Real_Impl.shtml +++ b/web/entries/Real_Impl.shtml @@ -1,140 +1,140 @@ Archive of Formal Proofs

 

Implementing field extensions of the form Q[sqrt(b)]

- +
Title: Implementing field extensions of the form Q[sqrt(b)]
Author: René Thiemann (rene /dot/ thiemann /at/ uibk /dot/ ac /dot/ at)
Submission date: 2014-02-06
Abstract: We apply data refinement to implement the real numbers, where we support all numbers in the field extension Q[sqrt(b)], i.e., all numbers of the form p + q * sqrt(b) for rational numbers p and q and some fixed natural number b. To this end, we also developed algorithms to precisely compute roots of a rational number, and to perform a factorization of natural numbers which eliminates duplicate prime factors.

Our results have been used to certify termination proofs which involve polynomial interpretations over the reals.

Change history: [2014-07-11]: Moved NthRoot_Impl to Sqrt-Babylonian.
BibTeX:
@article{Real_Impl-AFP,
   author  = {René Thiemann},
   title   = {Implementing field extensions of the form Q[sqrt(b)]},
   journal = {Archive of Formal Proofs},
   month   = feb,
   year    = 2014,
   note    = {\url{http://afp.sf.net/entries/Real_Impl.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: GNU Lesser General Public License (LGPL)
Depends on:Sqrt_Babylonian, Show
Show, Sqrt_Babylonian

diff --git a/web/entries/Residuated_Lattices.shtml b/web/entries/Residuated_Lattices.shtml --- a/web/entries/Residuated_Lattices.shtml +++ b/web/entries/Residuated_Lattices.shtml @@ -1,126 +1,126 @@ Archive of Formal Proofs

 

Residuated Lattices

- +
Title: Residuated Lattices
Author: Victor B. F. Gomes (vborgesferreiragomes1 /at/ sheffield /dot/ ac /dot/ uk) and Georg Struth (g /dot/ struth /at/ sheffield /dot/ ac /dot/ uk)
Submission date: 2015-04-15
Abstract: The theory of residuated lattices, first proposed by Ward and Dilworth, is formalised in Isabelle/HOL. This includes concepts of residuated functions; their adjoints and conjugates. It also contains necessary and sufficient conditions for the existence of these operations in an arbitrary lattice. The mathematical components for residuated lattices are linked to the AFP entry for relation algebra. In particular, we prove Jonsson and Tsinakis conditions for a residuated boolean algebra to form a relation algebra.
BibTeX:
@article{Residuated_Lattices-AFP,
   author  = {Victor B. F. Gomes and Georg Struth},
   title   = {Residuated Lattices},
   journal = {Archive of Formal Proofs},
   month   = apr,
   year    = 2015,
   note    = {\url{http://afp.sf.net/entries/Residuated_Lattices.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Relation_Algebra, Kleene_Algebra
Kleene_Algebra, Relation_Algebra

diff --git a/web/entries/Separation_Logic_Imperative_HOL.shtml b/web/entries/Separation_Logic_Imperative_HOL.shtml --- a/web/entries/Separation_Logic_Imperative_HOL.shtml +++ b/web/entries/Separation_Logic_Imperative_HOL.shtml @@ -1,141 +1,141 @@ Archive of Formal Proofs

 

A Separation Logic Framework for Imperative HOL

- +
Title: A Separation Logic Framework for Imperative HOL
Author: Peter Lammich and Rene Meis (rene /dot/ meis /at/ uni-due /dot/ de)
Submission date: 2012-11-14
Abstract: We provide a framework for separation-logic based correctness proofs of Imperative HOL programs. Our framework comes with a set of proof methods to automate canonical tasks such as verification condition generation and frame inference. Moreover, we provide a set of examples that show the applicability of our framework. The examples include algorithms on lists, hash-tables, and union-find trees. We also provide abstract interfaces for lists, maps, and sets, that allow to develop generic imperative algorithms and use data-refinement techniques.
As we target Imperative HOL, our programs can be translated to efficiently executable code in various target languages, including ML, OCaml, Haskell, and Scala.
BibTeX:
@article{Separation_Logic_Imperative_HOL-AFP,
   author  = {Peter Lammich and Rene Meis},
   title   = {A Separation Logic Framework for Imperative HOL},
   journal = {Archive of Formal Proofs},
   month   = nov,
   year    = 2012,
   note    = {\url{http://afp.sf.net/entries/Separation_Logic_Imperative_HOL.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Collections, Automatic_Refinement
Automatic_Refinement, Collections

diff --git a/web/entries/Show.shtml b/web/entries/Show.shtml --- a/web/entries/Show.shtml +++ b/web/entries/Show.shtml @@ -1,136 +1,136 @@ Archive of Formal Proofs

 

Haskell's Show Class in Isabelle/HOL

- +
Title: Haskell's Show Class in Isabelle/HOL
Author: Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com) and René Thiemann (rene /dot/ thiemann /at/ uibk /dot/ ac /dot/ at)
Submission date: 2014-07-29
Abstract: We implemented a type class for "to-string" functions, similar to Haskell's Show class. Moreover, we provide instantiations for Isabelle/HOL's standard types like bool, prod, sum, nats, ints, and rats. It is further possible, to automatically derive show functions for arbitrary user defined datatypes similar to Haskell's "deriving Show".
Change history: [2015-03-11]: Adapted development to new-style (BNF-based) datatypes.
[2015-04-10]: Moved development for old-style datatypes into subdirectory "Old_Datatype".
BibTeX:
@article{Show-AFP,
   author  = {Christian Sternagel and René Thiemann},
   title   = {Haskell's Show Class in Isabelle/HOL},
   journal = {Archive of Formal Proofs},
   month   = jul,
   year    = 2014,
   note    = {\url{http://afp.sf.net/entries/Show.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: GNU Lesser General Public License (LGPL)
Depends on:Deriving, Datatype_Order_Generator
Datatype_Order_Generator, Deriving

diff --git a/web/entries/Tree-Automata.shtml b/web/entries/Tree-Automata.shtml --- a/web/entries/Tree-Automata.shtml +++ b/web/entries/Tree-Automata.shtml @@ -1,132 +1,132 @@ Archive of Formal Proofs

 

Tree Automata

- +
Title: Tree Automata
Author: Peter Lammich
Submission date: 2009-11-25
Abstract: This work presents a machine-checked tree automata library for Standard-ML, OCaml and Haskell. The algorithms are efficient by using appropriate data structures like RB-trees. The available algorithms for non-deterministic automata include membership query, reduction, intersection, union, and emptiness check with computation of a witness for non-emptiness. The executable algorithms are derived from less-concrete, non-executable algorithms using data-refinement techniques. The concrete data structures are from the Isabelle Collections Framework. Moreover, this work contains a formalization of the class of tree-regular languages and its closure properties under set operations.
BibTeX:
@article{Tree-Automata-AFP,
   author  = {Peter Lammich},
   title   = {Tree Automata},
   journal = {Archive of Formal Proofs},
   month   = nov,
   year    = 2009,
   note    = {\url{http://afp.sf.net/entries/Tree-Automata.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Collections, Automatic_Refinement
Automatic_Refinement, Collections

diff --git a/web/entries/Well_Quasi_Orders.shtml b/web/entries/Well_Quasi_Orders.shtml --- a/web/entries/Well_Quasi_Orders.shtml +++ b/web/entries/Well_Quasi_Orders.shtml @@ -1,147 +1,147 @@ Archive of Formal Proofs

 

Well-Quasi-Orders

- +
Title: Well-Quasi-Orders
Author: Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com)
Submission date: 2012-04-13
Abstract: Based on Isabelle/HOL's type class for preorders, we introduce a type class for well-quasi-orders (wqo) which is characterized by the absence of "bad" sequences (our proofs are along the lines of the proof of Nash-Williams, from which we also borrow terminology). Our main results are instantiations for the product type, the list type, and a type of finite trees, which (almost) directly follow from our proofs of (1) Dickson's Lemma, (2) Higman's Lemma, and (3) Kruskal's Tree Theorem. More concretely:
  • If the sets A and B are wqo then their Cartesian product is wqo.
  • If the set A is wqo then the set of finite lists over A is wqo.
  • If the set A is wqo then the set of finite trees over A is wqo.
The research was funded by the Austrian Science Fund (FWF): J3202.
Change history: [2012-06-11]: Added Kruskal's Tree Theorem.
[2012-12-19]: New variant of Kruskal's tree theorem for terms (as opposed to variadic terms, i.e., trees), plus finite version of the tree theorem as corollary.
[2013-05-16]: Simplified construction of minimal bad sequences.
[2014-07-09]: Simplified proofs of Higman's lemma and Kruskal's tree theorem, based on homogeneous sequences.
BibTeX:
@article{Well_Quasi_Orders-AFP,
   author  = {Christian Sternagel},
   title   = {Well-Quasi-Orders},
   journal = {Archive of Formal Proofs},
   month   = apr,
   year    = 2012,
   note    = {\url{http://afp.sf.net/entries/Well_Quasi_Orders.shtml},
             Formal proof development},
   ISSN    = {2150-914x},
 }
License: BSD License
Depends on:Abstract-Rewriting, Regular-Sets, Open_Induction
Abstract-Rewriting, Open_Induction, Regular-Sets