No OneTemporary
Actions

Size

4 MB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/metadata/metadata b/metadata/metadata
	--- a/metadata/metadata
	+++ b/metadata/metadata
	@@ -1,8083 +1,8158 @@
	[Generic_Deriving]
	title = Deriving generic class instances for datatypes
	author = Jonas Rädle <mailto:jonas.raedle@gmail.com>, Lars Hupel <https://www21.in.tum.de/~hupel/>
	topic = Computer Science/Data Structures
	date = 2018-11-06
	notify = jonas.raedle@gmail.com
	abstract =
	<p>We provide a framework for automatically deriving instances for
	generic type classes. Our approach is inspired by Haskell's
	<i>generic-deriving</i> package and Scala's
	<i>shapeless</i> library. In addition to generating the
	code for type class functions, we also attempt to automatically prove
	type class laws for these instances. As of now, however, some manual
	proofs are still required for recursive datatypes.</p>
	<p>Note: There are already articles in the AFP that provide
	automatic instantiation for a number of classes. Concretely, <a href="https://www.isa-afp.org/entries/Deriving.html">Deriving</a> allows the automatic instantiation of comparators, linear orders, equality, and hashing. <a href="https://www.isa-afp.org/entries/Show.html">Show</a> instantiates a Haskell-style <i>show</i> class.</p><p>Our approach works for arbitrary classes (with some Isabelle/HOL overhead for each class), but a smaller set of datatypes.</p>


	[Partial_Order_Reduction]
	title = Partial Order Reduction
	author = Julian Brunner <http://www21.in.tum.de/~brunnerj/>
	topic = Computer Science/Automata and Formal Languages
	date = 2018-06-05
	notify = brunnerj@in.tum.de
	abstract =
	This entry provides a formalization of the abstract theory of ample
	set partial order reduction. The formalization includes transition
	systems with actions, trace theory, as well as basics on finite,
	infinite, and lazy sequences. We also provide a basic framework for
	static analysis on concurrent systems with respect to the ample set
	condition.

	[CakeML]
	title = CakeML
	author = Lars Hupel <https://www21.in.tum.de/~hupel/>, Yu Zhang <>
	contributors = Johannes Åman Pohjola <>
	topic = Computer Science/Programming Languages/Language Definitions
	date = 2018-03-12
	notify = hupel@in.tum.de
	abstract =
	CakeML is a functional programming language with a proven-correct
	compiler and runtime system. This entry contains an unofficial version
	of the CakeML semantics that has been exported from the Lem
	specifications to Isabelle. Additionally, there are some hand-written
	theory files that adapt the exported code to Isabelle and port proofs
	from the HOL4 formalization, e.g. termination and equivalence proofs.

	[DiscretePricing]
	title = Pricing in discrete financial models
	author = Mnacho Echenim <http://lig-membres.imag.fr/mechenim/>
	topic = Mathematics/Probability Theory, Mathematics/Economics
	date = 2018-07-16
	notify = mnacho.echenim@univ-grenoble-alpes.fr
	abstract =
	We have formalized the computation of fair prices for derivative
	products in discrete financial models. As an application, we derive a
	way to compute fair prices of derivative products in the
	Cox-Ross-Rubinstein model of a financial market, thus completing the
	work that was presented in this <a
	href="https://hal.archives-ouvertes.fr/hal-01562944">paper</a>.
	extra-history =
	Change history:
	[2019-05-12]:
	Renamed discr_mkt predicate to stk_strict_subs and got rid of predicate A for a more natural definition of the type discrete_market;
	renamed basic quantity processes for coherent notation;
	renamed value_process into val_process and closing_value_process to cls_val_process;
	relaxed hypothesis of lemma CRR_market_fair_price.
	Added functions to price some basic options.
	(revision 0b813a1a833f)<br>


	[Pell]
	title = Pell's Equation
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Number Theory
	date = 2018-06-23
	notify = eberlm@in.tum.de
	abstract =
	<p> This article gives the basic theory of Pell's equation
	<em>x</em><sup>2</sup> = 1 +
	<em>D</em> <em>y</em><sup>2</sup>,
	where
	<em>D</em> ∈ ℕ is
	a parameter and <em>x</em>, <em>y</em> are
	integer variables. </p> <p> The main result that is proven
	is the following: If <em>D</em> is not a perfect square,
	then there exists a <em>fundamental solution</em>
	(<em>x</em><sub>0</sub>,
	<em>y</em><sub>0</sub>) that is not the
	trivial solution (1, 0) and which generates all other solutions
	(<em>x</em>, <em>y</em>) in the sense that
	there exists some
	<em>n</em> ∈ ℕ
	such that \|<em>x</em>\| +
	\|<em>y</em>\| √<span
	style="text-decoration:
	overline"><em>D</em></span> =
	(<em>x</em><sub>0</sub> +
	<em>y</em><sub>0</sub> √<span
	style="text-decoration:
	overline"><em>D</em></span>)<sup><em>n</em></sup>.
	This also implies that the set of solutions is infinite, and it gives
	us an explicit and executable characterisation of all the solutions.
	</p> <p> Based on this, simple executable algorithms for
	computing the fundamental solution and the infinite sequence of all
	non-negative solutions are also provided. </p>

	[WebAssembly]
	title = WebAssembly
	author = Conrad Watt <http://www.cl.cam.ac.uk/~caw77/>
	topic = Computer Science/Programming Languages/Language Definitions
	date = 2018-04-29
	notify = caw77@cam.ac.uk
	abstract =
	This is a mechanised specification of the WebAssembly language, drawn
	mainly from the previously published paper formalisation of Haas et
	al. Also included is a full proof of soundness of the type system,
	together with a verified type checker and interpreter. We include only
	a partial procedure for the extraction of the type checker and
	interpreter here. For more details, please see our paper in CPP 2018.

	[Knuth_Morris_Pratt]
	title = The string search algorithm by Knuth, Morris and Pratt
	author = Fabian Hellauer <mailto:hellauer@in.tum.de>, Peter Lammich <http://www21.in.tum.de/~lammich>
	topic = Computer Science/Algorithms
	date = 2017-12-18
	notify = hellauer@in.tum.de, lammich@in.tum.de
	abstract =
	The Knuth-Morris-Pratt algorithm is often used to show that the
	problem of finding a string <i>s</i> in a text
	<i>t</i> can be solved deterministically in
	<i>O(\|s\| + \|t\|)</i> time. We use the Isabelle
	Refinement Framework to formulate and verify the algorithm. Via
	refinement, we apply some optimisations and finally use the
	<em>Sepref</em> tool to obtain executable code in
	<em>Imperative/HOL</em>.

	[Minkowskis_Theorem]
	title = Minkowski's Theorem
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Geometry, Mathematics/Number Theory
	date = 2017-07-13
	notify = eberlm@in.tum.de
	abstract =
	<p>Minkowski's theorem relates a subset of
	ℝ<sup>n</sup>, the Lebesgue measure, and the
	integer lattice ℤ<sup>n</sup>: It states that
	any convex subset of ℝ<sup>n</sup> with volume
	greater than 2<sup>n</sup> contains at least one lattice
	point from ℤ<sup>n</sup>\{0}, i. e. a
	non-zero point with integer coefficients.</p> <p>A
	related theorem which directly implies this is Blichfeldt's
	theorem, which states that any subset of
	ℝ<sup>n</sup> with a volume greater than 1
	contains two different points whose difference vector has integer
	components.</p> <p>The entry contains a proof of both
	theorems.</p>

	[Name_Carrying_Type_Inference]
	title = Verified Metatheory and Type Inference for a Name-Carrying Simply-Typed Lambda Calculus
	author = Michael Rawson <mailto:michaelrawson76@gmail.com>
	topic = Computer Science/Programming Languages/Type Systems
	date = 2017-07-09
	notify = mr644@cam.ac.uk, michaelrawson76@gmail.com
	abstract =
	I formalise a Church-style simply-typed
	$\lambda$-calculus, extended with pairs, a unit value, and
	projection functions, and show some metatheory of the calculus, such
	as the subject reduction property. Particular attention is paid to the
	treatment of names in the calculus. A nominal style of binding is
	used, but I use a manual approach over Nominal Isabelle in order to
	extract an executable type inference algorithm. More information can
	be found in my <a
	href="http://www.openthesis.org/documents/Verified-Metatheory-Type-Inference-Simply-603182.html">undergraduate
	dissertation</a>.

	[Propositional_Proof_Systems]
	title = Propositional Proof Systems
	author = Julius Michaelis <http://liftm.de>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	topic = Logic
	date = 2017-06-21
	notify = maintainafpppt@liftm.de
	abstract =
	We formalize a range of proof systems for classical propositional
	logic (sequent calculus, natural deduction, Hilbert systems,
	resolution) and prove the most important meta-theoretic results about
	semantics and proofs: compactness, soundness, completeness,
	translations between proof systems, cut-elimination, interpolation and
	model existence.

	[Optics]
	title = Optics
	author = Simon Foster <mailto:simon.foster@york.ac.uk>, Frank Zeyda <mailto:frank.zeyda@york.ac.uk>
	topic = Computer Science/Functional Programming, Mathematics/Algebra
	date = 2017-05-25
	notify = simon.foster@york.ac.uk
	abstract =
	Lenses provide an abstract interface for manipulating data types
	through spatially-separated views. They are defined abstractly in
	terms of two functions, <em>get</em>, the return a value
	from the source type, and <em>put</em> that updates the
	value. We mechanise the underlying theory of lenses, in terms of an
	algebraic hierarchy of lenses, including well-behaved and very
	well-behaved lenses, each lens class being characterised by a set of
	lens laws. We also mechanise a lens algebra in Isabelle that enables
	their composition and comparison, so as to allow construction of
	complex lenses. This is accompanied by a large library of algebraic
	laws. Moreover we also show how the lens classes can be applied by
	instantiating them with a number of Isabelle data types.

	[Game_Based_Crypto]
	title = Game-based cryptography in HOL
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>, S. Reza Sefidgar <>, Bhargav Bhatt <mailto:bhargav.bhatt@inf.ethz.ch>
	topic = Computer Science/Security/Cryptography
	date = 2017-05-05
	notify = mail@andreas-lochbihler.de
	abstract =
	<p>In this AFP entry, we show how to specify game-based cryptographic
	security notions and formally prove secure several cryptographic
	constructions from the literature using the CryptHOL framework. Among
	others, we formalise the notions of a random oracle, a pseudo-random
	function, an unpredictable function, and of encryption schemes that are
	indistinguishable under chosen plaintext and/or ciphertext attacks. We
	prove the random-permutation/random-function switching lemma, security
	of the Elgamal and hashed Elgamal public-key encryption scheme and
	correctness and security of several constructions with pseudo-random
	functions.
	</p><p>Our proofs follow the game-hopping style advocated by
	Shoup and Bellare and Rogaway, from which most of the examples have
	been taken. We generalise some of their results such that they can be
	reused in other proofs. Thanks to CryptHOL's integration with
	Isabelle's parametricity infrastructure, many simple hops are easily
	justified using the theory of representation independence.</p>
	extra-history =
	Change history:
	[2018-09-28]:
	added the CryptHOL tutorial for game-based cryptography
	(revision 489a395764ae)

	[Multi_Party_Computation]
	title = Multi-Party Computation
	author = David Aspinall <http://homepages.inf.ed.ac.uk/da/>, David Butler <mailto:dbutler@turing.ac.uk>
	topic = Computer Science/Security
	date = 2019-05-09
	notify = dbutler@turing.ac.uk
	abstract =
	We use CryptHOL to consider Multi-Party Computation (MPC) protocols.
	MPC was first considered by Yao in 1983 and recent advances in
	efficiency and an increased demand mean it is now deployed in the real
	world. Security is considered using the real/ideal world paradigm. We
	first define security in the semi-honest security setting where
	parties are assumed not to deviate from the protocol transcript. In
	this setting we prove multiple Oblivious Transfer (OT) protocols
	secure and then show security for the gates of the GMW protocol. We
	then define malicious security, this is a stronger notion of security
	where parties are assumed to be fully corrupted by an adversary. In
	this setting we again consider OT, as it is a fundamental building
	block of almost all MPC protocols.

	[CryptHOL]
	title = CryptHOL
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>
	topic = Computer Science/Security/Cryptography, Computer Science/Functional Programming, Mathematics/Probability Theory
	date = 2017-05-05
	notify = mail@andreas-lochbihler.de
	abstract =
	<p>CryptHOL provides a framework for formalising cryptographic arguments
	in Isabelle/HOL. It shallowly embeds a probabilistic functional
	programming language in higher order logic. The language features
	monadic sequencing, recursion, random sampling, failures and failure
	handling, and black-box access to oracles. Oracles are probabilistic
	functions which maintain hidden state between different invocations.
	All operators are defined in the new semantic domain of
	generative probabilistic values, a codatatype. We derive proof rules for
	the operators and establish a connection with the theory of relational
	parametricity. Thus, the resuting proofs are trustworthy and
	comprehensible, and the framework is extensible and widely applicable.
	</p><p>
	The framework is used in the accompanying AFP entry "Game-based
	Cryptography in HOL". There, we show-case our framework by formalizing
	different game-based proofs from the literature. This formalisation
	continues the work described in the author's ESOP 2016 paper.</p>

	[Constructive_Cryptography]
	title = Constructive Cryptography in HOL
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de/>, S. Reza Sefidgar<>
	topic = Computer Science/Security/Cryptography, Mathematics/Probability Theory
	date = 2018-12-17
	notify = mail@andreas-lochbihler.de, reza.sefidgar@inf.ethz.ch
	abstract =
	Inspired by Abstract Cryptography, we extend CryptHOL, a framework for
	formalizing game-based proofs, with an abstract model of Random
	Systems and provide proof rules about their composition and equality.
	This foundation facilitates the formalization of Constructive
	Cryptography proofs, where the security of a cryptographic scheme is
	realized as a special form of construction in which a complex random
	system is built from simpler ones. This is a first step towards a
	fully-featured compositional framework, similar to Universal
	Composability framework, that supports formalization of
	simulation-based proofs.

	[Probabilistic_While]
	title = Probabilistic while loop
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>
	topic = Computer Science/Functional Programming, Mathematics/Probability Theory, Computer Science/Algorithms
	date = 2017-05-05
	notify = mail@andreas-lochbihler.de
	abstract =
	This AFP entry defines a probabilistic while operator based on
	sub-probability mass functions and formalises zero-one laws and variant
	rules for probabilistic loop termination. As applications, we
	implement probabilistic algorithms for the Bernoulli, geometric and
	arbitrary uniform distributions that only use fair coin flips, and
	prove them correct and terminating with probability 1.
	extra-history =
	Change history:
	[2018-02-02]:
	Added a proof that probabilistic conditioning can be implemented by repeated sampling.
	(revision 305867c4e911)<br>


	[Monad_Normalisation]
	title = Monad normalisation
	author = Joshua Schneider <>, Manuel Eberl <https://www21.in.tum.de/~eberlm>, Andreas Lochbihler <http://www.andreas-lochbihler.de>
	topic = Tools, Computer Science/Functional Programming, Logic/Rewriting
	date = 2017-05-05
	notify = mail@andreas-lochbihler.de
	abstract =
	The usual monad laws can directly be used as rewrite rules for Isabelle’s
	simplifier to normalise monadic HOL terms and decide equivalences.
	In a commutative monad, however, the commutativity law is a
	higher-order permutative rewrite rule that makes the simplifier loop.
	This AFP entry implements a simproc that normalises monadic
	expressions in commutative monads using ordered rewriting. The
	simproc can also permute computations across control operators like if
	and case.

	[Monomorphic_Monad]
	title = Effect polymorphism in higher-order logic
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>
	topic = Computer Science/Functional Programming
	date = 2017-05-05
	notify = mail@andreas-lochbihler.de
	abstract =
	The notion of a monad cannot be expressed within higher-order logic
	(HOL) due to type system restrictions. We show that if a monad is used
	with values of only one type, this notion can be formalised in HOL.
	Based on this idea, we develop a library of effect specifications and
	implementations of monads and monad transformers. Hence, we can
	abstract over the concrete monad in HOL definitions and thus use the
	same definition for different (combinations of) effects. We illustrate
	the usefulness of effect polymorphism with a monadic interpreter for a
	simple language.
	extra-history =
	Change history:
	[2018-02-15]:
	added further specifications and implementations of non-determinism;
	more examples
	(revision bc5399eea78e)<br>


	[Constructor_Funs]
	title = Constructor Functions
	author = Lars Hupel <https://www21.in.tum.de/~hupel/>
	topic = Tools
	date = 2017-04-19
	notify = hupel@in.tum.de
	abstract =
	Isabelle's code generator performs various adaptations for target
	languages. Among others, constructor applications have to be fully
	saturated. That means that for constructor calls occuring as arguments
	to higher-order functions, synthetic lambdas have to be inserted. This
	entry provides tooling to avoid this construction altogether by
	introducing constructor functions.

	[Lazy_Case]
	title = Lazifying case constants
	author = Lars Hupel <https://www21.in.tum.de/~hupel/>
	topic = Tools
	date = 2017-04-18
	notify = hupel@in.tum.de
	abstract =
	Isabelle's code generator performs various adaptations for target
	languages. Among others, case statements are printed as match
	expressions. Internally, this is a sophisticated procedure, because in
	HOL, case statements are represented as nested calls to the case
	combinators as generated by the datatype package. Furthermore, the
	procedure relies on laziness of match expressions in the target
	language, i.e., that branches guarded by patterns that fail to match
	are not evaluated. Similarly, <tt>if-then-else</tt> is
	printed to the corresponding construct in the target language. This
	entry provides tooling to replace these special cases in the code
	generator by ignoring these target language features, instead printing
	case expressions and <tt>if-then-else</tt> as functions.

	[Dict_Construction]
	title = Dictionary Construction
	author = Lars Hupel <https://www21.in.tum.de/~hupel/>
	topic = Tools
	date = 2017-05-24
	notify = hupel@in.tum.de
	abstract =
	Isabelle's code generator natively supports type classes. For
	targets that do not have language support for classes and instances,
	it performs the well-known dictionary translation, as described by
	Haftmann and Nipkow. This translation happens outside the logic, i.e.,
	there is no guarantee that it is correct, besides the pen-and-paper
	proof. This work implements a certified dictionary translation that
	produces new class-free constants and derives equality theorems.

	[Higher_Order_Terms]
	title = An Algebra for Higher-Order Terms
	author = Lars Hupel <https://lars.hupel.info/>
	contributors = Yu Zhang <>
	topic = Computer Science/Programming Languages/Lambda Calculi
	date = 2019-01-15
	notify = lars@hupel.info
	abstract =
	In this formalization, I introduce a higher-order term algebra,
	generalizing the notions of free variables, matching, and
	substitution. The need arose from the work on a <a
	href="http://dx.doi.org/10.1007/978-3-319-89884-1_35">verified
	compiler from Isabelle to CakeML</a>. Terms can be thought of as
	consisting of a generic (free variables, constants, application) and
	a specific part. As example applications, this entry provides
	instantiations for de-Bruijn terms, terms with named variables, and
	<a
	href="https://www.isa-afp.org/entries/Lambda_Free_RPOs.html">Blanchette’s
	λ-free higher-order terms</a>. Furthermore, I
	implement translation functions between de-Bruijn terms and named
	terms and prove their correctness.

	[Subresultants]
	title = Subresultants
	author = Sebastiaan Joosten <mailto:sebastiaan.joosten@uibk.ac.at>, René Thiemann <mailto:rene.thiemann@uibk.ac.at>, Akihisa Yamada <mailto:akihisa.yamada@uibk.ac.at>
	topic = Mathematics/Algebra
	date = 2017-04-06
	notify = rene.thiemann@uibk.ac.at
	abstract =
	We formalize the theory of subresultants and the subresultant
	polynomial remainder sequence as described by Brown and Traub. As a
	result, we obtain efficient certified algorithms for computing the
	resultant and the greatest common divisor of polynomials.

	[Comparison_Sort_Lower_Bound]
	title = Lower bound on comparison-based sorting algorithms
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Computer Science/Algorithms
	date = 2017-03-15
	notify = eberlm@in.tum.de
	abstract =
	<p>This article contains a formal proof of the well-known fact
	that number of comparisons that a comparison-based sorting algorithm
	needs to perform to sort a list of length <em>n</em> is at
	least <em>log<sub>2</sub> (n!)</em>
	in the worst case, i. e. <em>Ω(n log
	n)</em>.</p> <p>For this purpose, a shallow
	embedding for comparison-based sorting algorithms is defined: a
	sorting algorithm is a recursive datatype containing either a HOL
	function or a query of a comparison oracle with a continuation
	containing the remaining computation. This makes it possible to force
	the algorithm to use only comparisons and to track the number of
	comparisons made.</p>

	[Quick_Sort_Cost]
	title = The number of comparisons in QuickSort
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Computer Science/Algorithms
	date = 2017-03-15
	notify = eberlm@in.tum.de
	abstract =
	<p>We give a formal proof of the well-known results about the
	number of comparisons performed by two variants of QuickSort: first,
	the expected number of comparisons of randomised QuickSort
	(i. e. QuickSort with random pivot choice) is
	<em>2 (n+1) H<sub>n</sub> -
	4 n</em>, which is asymptotically equivalent to
	<em>2 n ln n</em>; second, the number of
	comparisons performed by the classic non-randomised QuickSort has the
	same distribution in the average case as the randomised one.</p>

	[Random_BSTs]
	title = Expected Shape of Random Binary Search Trees
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Computer Science/Data Structures
	date = 2017-04-04
	notify = eberlm@in.tum.de
	abstract =
	<p>This entry contains proofs for the textbook results about the
	distributions of the height and internal path length of random binary
	search trees (BSTs), i. e. BSTs that are formed by taking
	an empty BST and inserting elements from a fixed set in random
	order.</p> <p>In particular, we prove a logarithmic upper
	bound on the expected height and the <em>Θ(n log n)</em>
	closed-form solution for the expected internal path length in terms of
	the harmonic numbers. We also show how the internal path length
	relates to the average-case cost of a lookup in a BST.</p>

	[Randomised_BSTs]
	title = Randomised Binary Search Trees
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Computer Science/Data Structures
	date = 2018-10-19
	notify = eberlm@in.tum.de
	abstract =
	<p>This work is a formalisation of the Randomised Binary Search
	Trees introduced by Martínez and Roura, including definitions and
	correctness proofs.</p> <p>Like randomised treaps, they
	are a probabilistic data structure that behaves exactly as if elements
	were inserted into a non-balancing BST in random order. However,
	unlike treaps, they only use discrete probability distributions, but
	their use of randomness is more complicated.</p>

	[E_Transcendental]
	title = The Transcendence of e
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Analysis, Mathematics/Number Theory
	date = 2017-01-12
	notify = eberlm@in.tum.de
	abstract =
	<p>This work contains a proof that Euler's number e is transcendental. The
	proof follows the standard approach of assuming that e is algebraic and
	then using a specific integer polynomial to derive two inconsistent bounds,
	leading to a contradiction.</p> <p>This kind of approach can be found in
	many different sources; this formalisation mostly follows a <a href="http://planetmath.org/proofoflindemannweierstrasstheoremandthateandpiaretranscendental">PlanetMath article</a> by Roger Lipsett.</p>

	[Pi_Transcendental]
	title = The Transcendence of π
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Number Theory
	date = 2018-09-28
	notify = eberlm@in.tum.de
	abstract =
	<p>This entry shows the transcendence of π based on the
	classic proof using the fundamental theorem of symmetric polynomials
	first given by von Lindemann in 1882, but the formalisation mostly
	follows the version by Niven. The proof reuses much of the machinery
	developed in the AFP entry on the transcendence of
	<em>e</em>.</p>

	[DFS_Framework]
	title = A Framework for Verifying Depth-First Search Algorithms
	author = Peter Lammich <http://www21.in.tum.de/~lammich>, René Neumann <mailto:neumannr@in.tum.de>
	notify = lammich@in.tum.de
	date = 2016-07-05
	topic = Computer Science/Algorithms
	abstract =
	<p>
	This entry presents a framework for the modular verification of
	DFS-based algorithms, which is described in our [CPP-2015] paper. It
	provides a generic DFS algorithm framework, that can be parameterized
	with user-defined actions on certain events (e.g. discovery of new
	node). It comes with an extensible library of invariants, which can
	be used to derive invariants of a specific parameterization. Using
	refinement techniques, efficient implementations of the algorithms can
	easily be derived. Here, the framework comes with templates for a
	recursive and a tail-recursive implementation, and also with several
	templates for implementing the data structures required by the DFS
	algorithm. Finally, this entry contains a set of re-usable DFS-based
	algorithms, which illustrate the application of the framework.
	</p><p>
	[CPP-2015] Peter Lammich, René Neumann: A Framework for Verifying
	Depth-First Search Algorithms. CPP 2015: 137-146</p>

	[Flow_Networks]
	title = Flow Networks and the Min-Cut-Max-Flow Theorem
	author = Peter Lammich <http://www21.in.tum.de/~lammich>, S. Reza Sefidgar <>
	topic = Mathematics/Graph Theory
	date = 2017-06-01
	notify = lammich@in.tum.de
	abstract =
	We present a formalization of flow networks and the Min-Cut-Max-Flow
	theorem. Our formal proof closely follows a standard textbook proof,
	and is accessible even without being an expert in Isabelle/HOL, the
	interactive theorem prover used for the formalization.

	[Prpu_Maxflow]
	title = Formalizing Push-Relabel Algorithms
	author = Peter Lammich <http://www21.in.tum.de/~lammich>, S. Reza Sefidgar <>
	topic = Computer Science/Algorithms, Mathematics/Graph Theory
	date = 2017-06-01
	notify = lammich@in.tum.de
	abstract =
	We present a formalization of push-relabel algorithms for computing
	the maximum flow in a network. We start with Goldberg's et
	al.~generic push-relabel algorithm, for which we show correctness and
	the time complexity bound of O(V^2E). We then derive the
	relabel-to-front and FIFO implementation. Using stepwise refinement
	techniques, we derive an efficient verified implementation. Our
	formal proof of the abstract algorithms closely follows a standard
	textbook proof. It is accessible even without being an expert in
	Isabelle/HOL, the interactive theorem prover used for the
	formalization.

	[Buildings]
	title = Chamber Complexes, Coxeter Systems, and Buildings
	author = Jeremy Sylvestre <http://ualberta.ca/~jsylvest/>
	notify = jeremy.sylvestre@ualberta.ca
	date = 2016-07-01
	topic = Mathematics/Algebra, Mathematics/Geometry
	abstract =
	We provide a basic formal framework for the theory of chamber
	complexes and Coxeter systems, and for buildings as thick chamber
	complexes endowed with a system of apartments. Along the way, we
	develop some of the general theory of abstract simplicial complexes
	and of groups (relying on the <i>group_add</i> class for the basics),
	including free groups and group presentations, and their universal
	properties. The main results verified are that the deletion condition
	is both necessary and sufficient for a group with a set of generators
	of order two to be a Coxeter system, and that the apartments in a
	(thick) building are all uniformly Coxeter.

	[Algebraic_VCs]
	title = Program Construction and Verification Components Based on Kleene Algebra
	author = Victor B. F. Gomes <mailto:victor.gomes@cl.cam.ac.uk>, Georg Struth <mailto:g.struth@sheffield.ac.uk>
	notify = victor.gomes@cl.cam.ac.uk, g.struth@sheffield.ac.uk
	date = 2016-06-18
	topic = Mathematics/Algebra
	abstract =
	Variants of Kleene algebra support program construction and
	verification by algebraic reasoning. This entry provides a
	verification component for Hoare logic based on Kleene algebra with
	tests, verification components for weakest preconditions and strongest
	postconditions based on Kleene algebra with domain and a component for
	step-wise refinement based on refinement Kleene algebra with tests. In
	addition to these components for the partial correctness of while
	programs, a verification component for total correctness based on
	divergence Kleene algebras and one for (partial correctness) of
	recursive programs based on domain quantales are provided. Finally we
	have integrated memory models for programs with pointers and a program
	trace semantics into the weakest precondition component.

	[Card_Equiv_Relations]
	title = Cardinality of Equivalence Relations
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	notify = lukas.bulwahn@gmail.com
	date = 2016-05-24
	topic = Mathematics/Combinatorics
	abstract =
	This entry provides formulae for counting the number of equivalence
	relations and partial equivalence relations over a finite carrier set
	with given cardinality. To count the number of equivalence relations,
	we provide bijections between equivalence relations and set
	partitions, and then transfer the main results of the two AFP entries,
	Cardinality of Set Partitions and Spivey's Generalized Recurrence for
	Bell Numbers, to theorems on equivalence relations. To count the
	number of partial equivalence relations, we observe that counting
	partial equivalence relations over a set A is equivalent to counting
	all equivalence relations over all subsets of the set A. From this
	observation and the results on equivalence relations, we show that the
	cardinality of partial equivalence relations over a finite set of
	cardinality n is equal to the n+1-th Bell number.

	[Twelvefold_Way]
	title = The Twelvefold Way
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	topic = Mathematics/Combinatorics
	date = 2016-12-29
	notify = lukas.bulwahn@gmail.com
	abstract =
	This entry provides all cardinality theorems of the Twelvefold Way.
	The Twelvefold Way systematically classifies twelve related
	combinatorial problems concerning two finite sets, which include
	counting permutations, combinations, multisets, set partitions and
	number partitions. This development builds upon the existing formal
	developments with cardinality theorems for those structures. It
	provides twelve bijections from the various structures to different
	equivalence classes on finite functions, and hence, proves cardinality
	formulae for these equivalence classes on finite functions.

	[Chord_Segments]
	title = Intersecting Chords Theorem
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	notify = lukas.bulwahn@gmail.com
	date = 2016-10-11
	topic = Mathematics/Geometry
	abstract =
	This entry provides a geometric proof of the intersecting chords
	theorem. The theorem states that when two chords intersect each other
	inside a circle, the products of their segments are equal. After a
	short review of existing proofs in the literature, I decided to use a
	proof approach that employs reasoning about lengths of line segments,
	the orthogonality of two lines and the Pythagoras Law. Hence, one can
	understand the formalized proof easily with the knowledge of a few
	general geometric facts that are commonly taught in high-school. This
	theorem is the 55th theorem of the Top 100 Theorems list.

	[Category3]
	title = Category Theory with Adjunctions and Limits
	author = Eugene W. Stark <mailto:stark@cs.stonybrook.edu>
	notify = stark@cs.stonybrook.edu
	date = 2016-06-26
	topic = Mathematics/Category Theory
	abstract =
	This article attempts to develop a usable framework for doing category
	theory in Isabelle/HOL. Our point of view, which to some extent
	differs from that of the previous AFP articles on the subject, is to
	try to explore how category theory can be done efficaciously within
	HOL, rather than trying to match exactly the way things are done using
	a traditional approach. To this end, we define the notion of category
	in an "object-free" style, in which a category is represented by a
	single partial composition operation on arrows. This way of defining
	categories provides some advantages in the context of HOL, including
	the ability to avoid the use of records and the possibility of
	defining functors and natural transformations simply as certain
	functions on arrows, rather than as composite objects. We define
	various constructions associated with the basic notions, including:
	dual category, product category, functor category, discrete category,
	free category, functor composition, and horizontal and vertical
	composite of natural transformations. A "set category" locale is
	defined that axiomatizes the notion "category of all sets at a type
	and all functions between them," and a fairly extensive set of
	properties of set categories is derived from the locale assumptions.
	The notion of a set category is used to prove the Yoneda Lemma in a
	general setting of a category equipped with a "hom embedding," which
	maps arrows of the category to the "universe" of the set category. We
	also give a treatment of adjunctions, defining adjunctions via left
	and right adjoint functors, natural bijections between hom-sets, and
	unit and counit natural transformations, and showing the equivalence
	of these definitions. We also develop the theory of limits, including
	representations of functors, diagrams and cones, and diagonal
	functors. We show that right adjoint functors preserve limits, and
	that limits can be constructed via products and equalizers. We
	characterize the conditions under which limits exist in a set
	category. We also examine the case of limits in a functor category,
	ultimately culminating in a proof that the Yoneda embedding preserves
	limits.
	extra-history =
	Change history:
	[2018-05-29]:
	Revised axioms for the category locale. Introduced notation for composition and "in hom".
	(revision 8318366d4575)<br>

	[MonoidalCategory]
	title = Monoidal Categories
	author = Eugene W. Stark <mailto:stark@cs.stonybrook.edu>
	topic = Mathematics/Category Theory
	date = 2017-05-04
	notify = stark@cs.stonybrook.edu
	abstract =
	Building on the formalization of basic category theory set out in the
	author's previous AFP article, the present article formalizes
	some basic aspects of the theory of monoidal categories. Among the
	notions defined here are monoidal category, monoidal functor, and
	equivalence of monoidal categories. The main theorems formalized are
	MacLane's coherence theorem and the constructions of the free
	monoidal category and free strict monoidal category generated by a
	given category. The coherence theorem is proved syntactically, using
	a structurally recursive approach to reduction of terms that might
	have some novel aspects. We also give proofs of some results given by
	Etingof et al, which may prove useful in a formal setting. In
	particular, we show that the left and right unitors need not be taken
	as given data in the definition of monoidal category, nor does the
	definition of monoidal functor need to take as given a specific
	isomorphism expressing the preservation of the unit object. Our
	definitions of monoidal category and monoidal functor are stated so as
	to take advantage of the economy afforded by these facts.
	extra-history =
	Change history:
	[2017-05-18]:
	Integrated material from MonoidalCategory/Category3Adapter into Category3/ and deleted adapter.
	(revision 015543cdd069)<br>
	[2018-05-29]:
	Modifications required due to 'Category3' changes. Introduced notation for "in hom".
	(revision 8318366d4575)<br>

	[Card_Multisets]
	title = Cardinality of Multisets
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	notify = lukas.bulwahn@gmail.com
	date = 2016-06-26
	topic = Mathematics/Combinatorics
	abstract =
	<p>This entry provides three lemmas to count the number of multisets
	of a given size and finite carrier set. The first lemma provides a
	cardinality formula assuming that the multiset's elements are chosen
	from the given carrier set. The latter two lemmas provide formulas
	assuming that the multiset's elements also cover the given carrier
	set, i.e., each element of the carrier set occurs in the multiset at
	least once.</p> <p>The proof of the first lemma uses the argument of
	the recurrence relation for counting multisets. The proof of the
	second lemma is straightforward, and the proof of the third lemma is
	easily obtained using the first cardinality lemma. A challenge for the
	formalization is the derivation of the required induction rule, which
	is a special combination of the induction rules for finite sets and
	natural numbers. The induction rule is derived by defining a suitable
	inductive predicate and transforming the predicate's induction
	rule.</p>

	[Posix-Lexing]
	title = POSIX Lexing with Derivatives of Regular Expressions
	author = Fahad Ausaf <http://kcl.academia.edu/FahadAusaf>, Roy Dyckhoff <https://rd.host.cs.st-andrews.ac.uk>, Christian Urban <http://www.inf.kcl.ac.uk/staff/urbanc/>
	notify = christian.urban@kcl.ac.uk
	date = 2016-05-24
	topic = Computer Science/Automata and Formal Languages
	abstract =
	Brzozowski introduced the notion of derivatives for regular
	expressions. They can be used for a very simple regular expression
	matching algorithm. Sulzmann and Lu cleverly extended this algorithm
	in order to deal with POSIX matching, which is the underlying
	disambiguation strategy for regular expressions needed in lexers. In
	this entry we give our inductive definition of what a POSIX value is
	and show (i) that such a value is unique (for given regular expression
	and string being matched) and (ii) that Sulzmann and Lu's algorithm
	always generates such a value (provided that the regular expression
	matches the string). We also prove the correctness of an optimised
	version of the POSIX matching algorithm.

	[LocalLexing]
	title = Local Lexing
	author = Steven Obua <mailto:steven@recursivemind.com>
	topic = Computer Science/Automata and Formal Languages
	date = 2017-04-28
	notify = steven@recursivemind.com
	abstract =
	This formalisation accompanies the paper <a
	href="https://arxiv.org/abs/1702.03277">Local
	Lexing</a> which introduces a novel parsing concept of the same
	name. The paper also gives a high-level algorithm for local lexing as
	an extension of Earley's algorithm. This formalisation proves the
	algorithm to be correct with respect to its local lexing semantics. As
	a special case, this formalisation thus also contains a proof of the
	correctness of Earley's algorithm. The paper contains a short
	outline of how this formalisation is organised.

	[MFMC_Countable]
	title = A Formal Proof of the Max-Flow Min-Cut Theorem for Countable Networks
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>
	date = 2016-05-09
	topic = Mathematics/Graph Theory
	abstract =
	This article formalises a proof of the maximum-flow minimal-cut
	theorem for networks with countably many edges. A network is a
	directed graph with non-negative real-valued edge labels and two
	dedicated vertices, the source and the sink. A flow in a network
	assigns non-negative real numbers to the edges such that for all
	vertices except for the source and the sink, the sum of values on
	incoming edges equals the sum of values on outgoing edges. A cut is a
	subset of the vertices which contains the source, but not the sink.
	Our theorem states that in every network, there is a flow and a cut
	such that the flow saturates all the edges going out of the cut and is
	zero on all the incoming edges. The proof is based on the paper
	<emph>The Max-Flow Min-Cut theorem for countable networks</emph> by
	Aharoni et al. Additionally, we prove a characterisation of the
	lifting operation for relations on discrete probability distributions,
	which leads to a concise proof of its distributivity over relation
	composition.
	notify = mail@andreas-lochbihler.de
	extra-history =
	Change history:
	[2017-09-06]:
	derive characterisation for the lifting operations on discrete distributions from finite version of the max-flow min-cut theorem
	(revision a7a198f5bab0)<br>


	[Liouville_Numbers]
	title = Liouville numbers
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	date = 2015-12-28
	topic = Mathematics/Analysis, Mathematics/Number Theory
	abstract =
	<p>
	Liouville numbers are a class of transcendental numbers that can be approximated
	particularly well with rational numbers. Historically, they were the first
	numbers whose transcendence was proven.
	</p><p>
	In this entry, we define the concept of Liouville numbers as well as the
	standard construction to obtain Liouville numbers (including Liouville's
	constant) and we prove their most important properties: irrationality and
	transcendence.
	</p><p>
	The proof is very elementary and requires only standard arithmetic, the Mean
	Value Theorem for polynomials, and the boundedness of polynomials on compact
	intervals.
	</p>
	notify = eberlm@in.tum.de

	[Triangle]
	title = Basic Geometric Properties of Triangles
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	date = 2015-12-28
	topic = Mathematics/Geometry
	abstract =
	<p>
	This entry contains a definition of angles between vectors and between three
	points. Building on this, we prove basic geometric properties of triangles, such
	as the Isosceles Triangle Theorem, the Law of Sines and the Law of Cosines, that
	the sum of the angles of a triangle is π, and the congruence theorems for
	triangles.
	</p><p>
	The definitions and proofs were developed following those by John Harrison in
	HOL Light. However, due to Isabelle's type class system, all definitions and
	theorems in the Isabelle formalisation hold for all real inner product spaces.
	</p>
	notify = eberlm@in.tum.de

	[Prime_Harmonic_Series]
	title = The Divergence of the Prime Harmonic Series
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	date = 2015-12-28
	topic = Mathematics/Number Theory
	abstract =
	<p>
	In this work, we prove the lower bound <span class="nobr">ln(H_n) -
	ln(5/3)</span> for the
	partial sum of the Prime Harmonic series and, based on this, the divergence of
	the Prime Harmonic Series
	<span class="nobr">∑[p prime] · 1/p.</span>
	</p><p>
	The proof relies on the unique squarefree decomposition of natural numbers. This
	is similar to Euler's original proof (which was highly informal and morally
	questionable). Its advantage over proofs by contradiction, like the famous one
	by Paul Erdős, is that it provides a relatively good lower bound for the partial
	sums.
	</p>
	notify = eberlm@in.tum.de

	[Descartes_Sign_Rule]
	title = Descartes' Rule of Signs
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	date = 2015-12-28
	topic = Mathematics/Analysis
	abstract =
	<p>
	Descartes' Rule of Signs relates the number of positive real roots of a
	polynomial with the number of sign changes in its coefficient sequence.
	</p><p>
	Our proof follows the simple inductive proof given by Rob Arthan, which was also
	used by John Harrison in his HOL Light formalisation. We proved most of the
	lemmas for arbitrary linearly-ordered integrity domains (e.g. integers,
	rationals, reals); the main result, however, requires the intermediate value
	theorem and was therefore only proven for real polynomials.
	</p>
	notify = eberlm@in.tum.de

	[Euler_MacLaurin]
	title = The Euler–MacLaurin Formula
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Analysis
	date = 2017-03-10
	notify = eberlm@in.tum.de
	abstract =
	<p>The Euler-MacLaurin formula relates the value of a
	discrete sum to that of the corresponding integral in terms of the
	derivatives at the borders of the summation and a remainder term.
	Since the remainder term is often very small as the summation bounds
	grow, this can be used to compute asymptotic expansions for
	sums.</p> <p>This entry contains a proof of this formula
	for functions from the reals to an arbitrary Banach space. Two
	variants of the formula are given: the standard textbook version and a
	variant outlined in <em>Concrete Mathematics</em> that is
	more useful for deriving asymptotic estimates.</p> <p>As
	example applications, we use that formula to derive the full
	asymptotic expansion of the harmonic numbers and the sum of inverse
	squares.</p>

	[Card_Partitions]
	title = Cardinality of Set Partitions
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	date = 2015-12-12
	topic = Mathematics/Combinatorics
	abstract =
	The theory's main theorem states that the cardinality of set partitions of
	size k on a carrier set of size n is expressed by Stirling numbers of the
	second kind. In Isabelle, Stirling numbers of the second kind are defined
	in the AFP entry `Discrete Summation` through their well-known recurrence
	relation. The main theorem relates them to the alternative definition as
	cardinality of set partitions. The proof follows the simple and short
	explanation in Richard P. Stanley's `Enumerative Combinatorics: Volume 1`
	and Wikipedia, and unravels the full details and implicit reasoning steps
	of these explanations.
	notify = lukas.bulwahn@gmail.com

	[Card_Number_Partitions]
	title = Cardinality of Number Partitions
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	date = 2016-01-14
	topic = Mathematics/Combinatorics
	abstract =
	This entry provides a basic library for number partitions, defines the
	two-argument partition function through its recurrence relation and relates
	this partition function to the cardinality of number partitions. The main
	proof shows that the recursively-defined partition function with arguments
	n and k equals the cardinality of number partitions of n with exactly k parts.
	The combinatorial proof follows the proof sketch of Theorem 2.4.1 in
	Mazur's textbook `Combinatorics: A Guided Tour`. This entry can serve as
	starting point for various more intrinsic properties about number partitions,
	the partition function and related recurrence relations.
	notify = lukas.bulwahn@gmail.com

	[Multirelations]
	title = Binary Multirelations
	author = Hitoshi Furusawa <http://www.sci.kagoshima-u.ac.jp/~furusawa/>, Georg Struth <http://www.dcs.shef.ac.uk/~georg>
	date = 2015-06-11
	topic = Mathematics/Algebra
	abstract =
	Binary multirelations associate elements of a set with its subsets; hence
	they are binary relations from a set to its power set. Applications include
	alternating automata, models and logics for games, program semantics with
	dual demonic and angelic nondeterministic choices and concurrent dynamic
	logics. This proof document supports an arXiv article that formalises the
	basic algebra of multirelations and proposes axiom systems for them,
	ranging from weak bi-monoids to weak bi-quantales.
	notify =

	[Noninterference_Generic_Unwinding]
	title = The Generic Unwinding Theorem for CSP Noninterference Security
	author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
	date = 2015-06-11
	topic = Computer Science/Security, Computer Science/Concurrency/Process Calculi
	abstract =
	<p>
	The classical definition of noninterference security for a deterministic state
	machine with outputs requires to consider the outputs produced by machine
	actions after any trace, i.e. any indefinitely long sequence of actions, of the
	machine. In order to render the verification of the security of such a machine
	more straightforward, there is a need of some sufficient condition for security
	such that just individual actions, rather than unbounded sequences of actions,
	have to be considered.
	</p><p>
	By extending previous results applying to transitive noninterference policies,
	Rushby has proven an unwinding theorem that provides a sufficient condition of
	this kind in the general case of a possibly intransitive policy. This condition
	has to be satisfied by a generic function mapping security domains into
	equivalence relations over machine states.
	</p><p>
	An analogous problem arises for CSP noninterference security, whose definition
	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.
	</p><p>
	This paper provides a 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 one for classical noninterference security, and has
	to be satisfied by a generic function mapping security domains into equivalence
	relations over process traces; hence its name, Generic Unwinding Theorem.
	Variants of this theorem applying to deterministic processes and trace set
	processes are also proven. Finally, the sufficient condition for security
	expressed by the theorem is shown not to be a necessary condition as well, viz.
	there exists a secure process such that no domain-relation map satisfying the
	condition exists.
	</p>
	notify =

	[Noninterference_Ipurge_Unwinding]
	title = The Ipurge Unwinding Theorem for CSP Noninterference Security
	author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
	date = 2015-06-11
	topic = Computer Science/Security
	abstract =
	<p>
	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.
	</p><p>
	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.
	</p><p>
	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.
	</p><p>
	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.
	</p>
	notify =

	[List_Interleaving]
	title = Reasoning about Lists via List Interleaving
	author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
	date = 2015-06-11
	topic = Computer Science/Data Structures
	abstract =
	<p>
	Among the various mathematical tools introduced in his outstanding work on
	Communicating Sequential Processes, Hoare has defined "interleaves" as the
	predicate satisfied by any three lists such that the first list may be
	split into sublists alternately extracted from the other two ones, whatever
	is the criterion for extracting an item from either one list or the other
	in each step.
	</p><p>
	This paper enriches Hoare's definition by identifying such criterion with
	the truth value of a predicate taking as inputs the head and the tail of
	the first list. This enhanced "interleaves" predicate turns out to permit
	the proof of equalities between lists without the need of an induction.
	Some rules that allow to infer "interleaves" statements without induction,
	particularly applying to the addition or removal of a prefix to the input
	lists, are also proven. Finally, a stronger version of the predicate, named
	"Interleaves", is shown to fulfil further rules applying to the addition or
	removal of a suffix to the input lists.
	</p>
	notify =

	[Residuated_Lattices]
	title = Residuated Lattices
	author = Victor B. F. Gomes <mailto:vborgesferreiragomes1@sheffield.ac.uk>, Georg Struth <mailto:g.struth@sheffield.ac.uk>
	date = 2015-04-15
	topic = Mathematics/Algebra
	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.
	notify = g.struth@sheffield.ac.uk

	[ConcurrentGC]
	title = Relaxing Safely: Verified On-the-Fly Garbage Collection for x86-TSO
	author = Peter Gammie <http://peteg.org>, Tony Hosking <https://www.cs.purdue.edu/homes/hosking/>, Kai Engelhardt <>
	date = 2015-04-13
	topic = Computer Science/Algorithms/Concurrent
	abstract =
	<p>
	We use ConcurrentIMP to model Schism, a state-of-the-art real-time
	garbage collection scheme for weak memory, and show that it is safe
	on x86-TSO.</p>
	<p>
	This development accompanies the PLDI 2015 paper of the same name.
	</p>
	notify = peteg42@gmail.com

	[List_Update]
	title = Analysis of List Update Algorithms
	author = Maximilian P.L. Haslbeck <http://in.tum.de/~haslbema/>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2016-02-17
	topic = Computer Science/Algorithms/Online
	abstract =
	<p>
	These theories formalize the quantitative analysis of a number of classical algorithms for the list update problem: 2-competitiveness of move-to-front, the lower bound of 2 for the competitiveness of deterministic list update algorithms and 1.6-competitiveness of the randomized COMB algorithm, the best randomized list update algorithm known to date.
	The material is based on the first two chapters of <i>Online Computation
	and Competitive Analysis</i> by Borodin and El-Yaniv.
	</p>
	<p>
	For an informal description see the FSTTCS 2016 publication
	<a href="http://www21.in.tum.de/~nipkow/pubs/fsttcs16.html">Verified Analysis of List Update Algorithms</a>
	by Haslbeck and Nipkow.
	</p>
	notify = nipkow@in.tum.de

	[ConcurrentIMP]
	title = Concurrent IMP
	author = Peter Gammie <http://peteg.org>
	date = 2015-04-13
	topic = Computer Science/Programming Languages/Logics
	abstract =
	ConcurrentIMP extends the small imperative language IMP with control
	non-determinism and constructs for synchronous message passing.
	notify = peteg42@gmail.com

	[TortoiseHare]
	title = The Tortoise and Hare Algorithm
	author = Peter Gammie <http://peteg.org>
	date = 2015-11-18
	topic = Computer Science/Algorithms
	abstract = We formalize the Tortoise and Hare cycle-finding algorithm ascribed to Floyd by Knuth, and an improved version due to Brent.
	notify = peteg42@gmail.com

	[UPF]
	title = The Unified Policy Framework (UPF)
	author = Achim D. Brucker <mailto:adbrucker@0x5f.org>, Lukas Brügger <mailto:lukas.a.bruegger@gmail.com>, Burkhart Wolff <mailto:wolff@lri.fr>
	date = 2014-11-28
	topic = Computer Science/Security
	abstract =
	We present the Unified Policy Framework (UPF), a generic framework
	for modelling security (access-control) policies. UPF emphasizes
	the view that a policy is a policy decision function that grants or
	denies access to resources, permissions, etc. In other words,
	instead of modelling the relations of permitted or prohibited
	requests directly, we model the concrete function that implements
	the policy decision point in a system. In more detail, UPF is
	based on the following four principles: 1) Functional representation
	of policies, 2) No conflicts are possible, 3) Three-valued decision
	type (allow, deny, undefined), 4) Output type not containing the
	decision only.
	notify = adbrucker@0x5f.org, wolff@lri.fr, lukas.a.bruegger@gmail.com

	[UPF_Firewall]
	title = Formal Network Models and Their Application to Firewall Policies
	author = Achim D. Brucker <https://www.brucker.ch>, Lukas Brügger<>, Burkhart Wolff <https://www.lri.fr/~wolff/>
	topic = Computer Science/Security, Computer Science/Networks
	date = 2017-01-08
	notify = adbrucker@0x5f.org
	abstract =
	We present a formal model of network protocols and their application
	to modeling firewall policies. The formalization is based on the
	Unified Policy Framework (UPF). The formalization was originally
	developed with for generating test cases for testing the security
	configuration actual firewall and router (middle-boxes) using
	HOL-TestGen. Our work focuses on modeling application level protocols
	on top of tcp/ip.

	[AODV]
	title = Loop freedom of the (untimed) AODV routing protocol
	author = Timothy Bourke <http://www.tbrk.org>, Peter Höfner <http://www.hoefner-online.de/>
	date = 2014-10-23
	topic = Computer Science/Concurrency/Process Calculi
	abstract =
	<p>
	The Ad hoc On-demand Distance Vector (AODV) routing protocol allows
	the nodes in a Mobile Ad hoc Network (MANET) or a Wireless Mesh
	Network (WMN) to know where to forward data packets. Such a protocol
	is ‘loop free’ if it never leads to routing decisions that forward
	packets in circles.
	<p>
	This development mechanises an existing pen-and-paper proof of loop
	freedom of AODV. The protocol is modelled in the Algebra of
	Wireless Networks (AWN), which is the subject of an earlier paper
	and AFP mechanization. The proof relies on a novel compositional
	approach for lifting invariants to networks of nodes.
	</p><p>
	We exploit the mechanization to analyse several variants of AODV and
	show that Isabelle/HOL can re-establish most proof obligations
	automatically and identify exactly the steps that are no longer valid.
	</p>
	notify = tim@tbrk.org

	[Show]
	title = Haskell's Show Class in Isabelle/HOL
	author = Christian Sternagel <mailto:c.sternagel@gmail.com>, René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	date = 2014-07-29
	topic = Computer Science/Functional Programming
	license = LGPL
	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".
	extra-history =
	Change history:
	[2015-03-11]: Adapted development to new-style (BNF-based) datatypes.<br>
	[2015-04-10]: Moved development for old-style datatypes into subdirectory
	"Old_Datatype".<br>
	notify = christian.sternagel@uibk.ac.at, rene.thiemann@uibk.ac.at

	[Certification_Monads]
	title = Certification Monads
	author = Christian Sternagel <mailto:c.sternagel@gmail.com>, René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	date = 2014-10-03
	topic = Computer Science/Functional Programming
	abstract = This entry provides several monads intended for the development of stand-alone certifiers via code generation from Isabelle/HOL. More specifically, there are three flavors of error monads (the sum type, for the case where all monadic functions are total; an instance of the former, the so called check monad, yielding either success without any further information or an error message; as well as a variant of the sum type that accommodates partial functions by providing an explicit bottom element) and a parser monad built on top. All of this monads are heavily used in the IsaFoR/CeTA project which thus provides many examples of their usage.
	notify = c.sternagel@gmail.com, rene.thiemann@uibk.ac.at

	[CISC-Kernel]
	title = Formal Specification of a Generic Separation Kernel
	author = Freek Verbeek <mailto:Freek.Verbeek@ou.nl>, Sergey Tverdyshev <mailto:stv@sysgo.com>, Oto Havle <mailto:oha@sysgo.com>, Holger Blasum <mailto:holger.blasum@sysgo.com>, Bruno Langenstein <mailto:langenstein@dfki.de>, Werner Stephan <mailto:stephan@dfki.de>, Yakoub Nemouchi <mailto:nemouchi@lri.fr>, Abderrahmane Feliachi <mailto:abderrahmane.feliachi@lri.fr>, Burkhart Wolff <mailto:wolff@lri.fr>, Julien Schmaltz <mailto:Julien.Schmaltz@ou.nl>
	date = 2014-07-18
	topic = Computer Science/Security
	abstract =
	<p>Intransitive noninterference has been a widely studied topic in the last
	few decades. Several well-established methodologies apply interactive
	theorem proving to formulate a noninterference theorem over abstract
	academic models. In joint work with several industrial and academic partners
	throughout Europe, we are helping in the certification process of PikeOS, an
	industrial separation kernel developed at SYSGO. In this process,
	established theories could not be applied. We present a new generic model of
	separation kernels and a new theory of intransitive noninterference. The
	model is rich in detail, making it suitable for formal verification of
	realistic and industrial systems such as PikeOS. Using a refinement-based
	theorem proving approach, we ensure that proofs remain manageable.</p>
	<p>
	This document corresponds to the deliverable D31.1 of the EURO-MILS
	Project <a href="http://www.euromils.eu">http://www.euromils.eu</a>.</p>
	notify =

	[pGCL]
	title = pGCL for Isabelle
	author = David Cock <mailto:david.cock@nicta.com.au>
	date = 2014-07-13
	topic = Computer Science/Programming Languages/Language Definitions
	abstract =
	<p>pGCL is both a programming language and a specification language that
	incorporates both probabilistic and nondeterministic choice, in a unified
	manner. Program verification is by refinement or annotation (or both), using
	either Hoare triples, or weakest-precondition entailment, in the style of
	GCL.</p>
	<p> This package provides both a shallow embedding of the language
	primitives, and an annotation and refinement framework. The generated
	document includes a brief tutorial.</p>
	notify =

	[Noninterference_CSP]
	title = Noninterference Security in Communicating Sequential Processes
	author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
	date = 2014-05-23
	topic = Computer Science/Security
	abstract =
	<p>
	An extension of classical noninterference security for deterministic
	state machines, as introduced by Goguen and Meseguer and elegantly
	formalized by Rushby, to nondeterministic systems should satisfy two
	fundamental requirements: it should be based on a mathematically precise
	theory of nondeterminism, and should be equivalent to (or at least not
	weaker than) the classical notion in the degenerate deterministic case.
	</p>
	<p>
	This paper proposes a definition of noninterference security applying
	to Hoare's Communicating Sequential Processes (CSP) in the general case of
	a possibly intransitive noninterference policy, and proves the
	equivalence of this security property to classical noninterference
	security for processes representing deterministic state machines.
	</p>
	<p>
	Furthermore, McCullough's generalized noninterference security is shown
	to be weaker than both the proposed notion of CSP noninterference security
	for a generic process, and classical noninterference security for processes
	representing deterministic state machines. This renders CSP noninterference
	security preferable as an extension of classical noninterference security
	to nondeterministic systems.
	</p>
	notify = pasquale.noce.lavoro@gmail.com

	[Floyd_Warshall]
	title = The Floyd-Warshall Algorithm for Shortest Paths
	author = Simon Wimmer <http://in.tum.de/~wimmers>, Peter Lammich <http://www21.in.tum.de/~lammich>
	topic = Computer Science/Algorithms
	date = 2017-05-08
	notify = wimmers@in.tum.de
	abstract =
	The Floyd-Warshall algorithm [Flo62, Roy59, War62] is a classic
	dynamic programming algorithm to compute the length of all shortest
	paths between any two vertices in a graph (i.e. to solve the all-pairs
	shortest path problem, or APSP for short). Given a representation of
	the graph as a matrix of weights M, it computes another matrix M'
	which represents a graph with the same path lengths and contains the
	length of the shortest path between any two vertices i and j. This is
	only possible if the graph does not contain any negative cycles.
	However, in this case the Floyd-Warshall algorithm will detect the
	situation by calculating a negative diagonal entry. This entry
	includes a formalization of the algorithm and of these key properties.
	The algorithm is refined to an efficient imperative version using the
	Imperative Refinement Framework.

	[Roy_Floyd_Warshall]
	title = Transitive closure according to Roy-Floyd-Warshall
	author = Makarius Wenzel <>
	date = 2014-05-23
	topic = Computer Science/Algorithms
	abstract = This formulation of the Roy-Floyd-Warshall algorithm for the
	transitive closure bypasses matrices and arrays, but uses a more direct
	mathematical model with adjacency functions for immediate predecessors and
	successors. This can be implemented efficiently in functional programming
	languages and is particularly adequate for sparse relations.
	notify =

	[GPU_Kernel_PL]
	title = Syntax and semantics of a GPU kernel programming language
	author = John Wickerson <http://www.doc.ic.ac.uk/~jpw48>
	date = 2014-04-03
	topic = Computer Science/Programming Languages/Language Definitions
	abstract =
	This document accompanies the article "The Design and
	Implementation of a Verification Technique for GPU Kernels"
	by Adam Betts, Nathan Chong, Alastair F. Donaldson, Jeroen
	Ketema, Shaz Qadeer, Paul Thomson and John Wickerson. It
	formalises all of the definitions provided in Sections 3
	and 4 of the article.
	notify =

	[AWN]
	title = Mechanization of the Algebra for Wireless Networks (AWN)
	author = Timothy Bourke <http://www.tbrk.org>
	date = 2014-03-08
	topic = Computer Science/Concurrency/Process Calculi
	abstract =
	<p>
	AWN is a process algebra developed for modelling and analysing
	protocols for Mobile Ad hoc Networks (MANETs) and Wireless Mesh
	Networks (WMNs). AWN models comprise five distinct layers:
	sequential processes, local parallel compositions, nodes, partial
	networks, and complete networks.</p>
	<p>
	This development mechanises the original operational semantics of
	AWN and introduces a variant 'open' operational semantics that
	enables the compositional statement and proof of invariants across
	distinct network nodes. It supports labels (for weakening
	invariants) and (abstract) data state manipulations. A framework for
	compositional invariant proofs is developed, including a tactic
	(inv_cterms) for inductive invariant proofs of sequential processes,
	lifting rules for the open versions of the higher layers, and a rule
	for transferring lifted properties back to the standard semantics. A
	notion of 'control terms' reduces proof obligations to the subset of
	subterms that act directly (in contrast to operators for combining
	terms and joining processes).</p>
	notify = tim@tbrk.org

	[Selection_Heap_Sort]
	title = Verification of Selection and Heap Sort Using Locales
	author = Danijela Petrovic <http://www.matf.bg.ac.rs/~danijela>
	date = 2014-02-11
	topic = Computer Science/Algorithms
	abstract =
	Stepwise program refinement techniques can be used to simplify
	program verification. Programs are better understood since their
	main properties are clearly stated, and verification of rather
	complex algorithms is reduced to proving simple statements
	connecting successive program specifications. Additionally, it is
	easy to analyze similar algorithms and to compare their properties
	within a single formalization. Usually, formal analysis is not done
	in educational setting due to complexity of verification and a lack
	of tools and procedures to make comparison easy. Verification of an
	algorithm should not only give correctness proof, but also better
	understanding of an algorithm. If the verification is based on small
	step program refinement, it can become simple enough to be
	demonstrated within the university-level computer science
	curriculum. In this paper we demonstrate this and give a formal
	analysis of two well known algorithms (Selection Sort and Heap Sort)
	using proof assistant Isabelle/HOL and program refinement
	techniques.
	notify =

	[Real_Impl]
	title = Implementing field extensions of the form Q[sqrt(b)]
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	date = 2014-02-06
	license = LGPL
	topic = Mathematics/Analysis
	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.
	<p>
	Our results have been used to certify termination proofs which involve
	polynomial interpretations over the reals.
	extra-history =
	Change history:
	[2014-07-11]: Moved NthRoot_Impl to Sqrt-Babylonian.
	notify = rene.thiemann@uibk.ac.at

	[ShortestPath]
	title = An Axiomatic Characterization of the Single-Source Shortest Path Problem
	author = Christine Rizkallah <https://www.mpi-inf.mpg.de/~crizkall/>
	date = 2013-05-22
	topic = Mathematics/Graph Theory
	abstract = This theory is split into two sections. In the first section, we give a formal proof that a well-known axiomatic characterization of the single-source shortest path problem is correct. Namely, we prove that in a directed graph with a non-negative cost function on the edges the single-source shortest path function is the only function that satisfies a set of four axioms. In the second section, we give a formal proof of the correctness of an axiomatic characterization of the single-source shortest path problem for directed graphs with general cost functions. The axioms here are more involved because we have to account for potential negative cycles in the graph. The axioms are summarized in three Isabelle locales.
	notify =

	[Launchbury]
	title = The Correctness of Launchbury's Natural Semantics for Lazy Evaluation
	author = Joachim Breitner <http://pp.ipd.kit.edu/~breitner>
	date = 2013-01-31
	topic = Computer Science/Programming Languages/Lambda Calculi, Computer Science/Semantics
	abstract = In his seminal paper "Natural Semantics for Lazy Evaluation", John Launchbury proves his semantics correct with respect to a denotational semantics, and outlines an adequacy proof. We have formalized both semantics and machine-checked the correctness proof, clarifying some details. Furthermore, we provide a new and more direct adequacy proof that does not require intermediate operational semantics.
	extra-history =
	Change history:
	[2014-05-24]: Added the proof of adequacy, as well as simplified and improved the existing proofs. Adjusted abstract accordingly.
	[2015-03-16]: Booleans and if-then-else added to syntax and semantics, making this entry suitable to be used by the entry "Call_Arity".
	notify =

	[Call_Arity]
	title = The Safety of Call Arity
	author = Joachim Breitner <http://pp.ipd.kit.edu/~breitner>
	date = 2015-02-20
	topic = Computer Science/Programming Languages/Transformations
	abstract =
	We formalize the Call Arity analysis, as implemented in GHC, and prove
	both functional correctness and, more interestingly, safety (i.e. the
	transformation does not increase allocation).
	<p>
	We use syntax and the denotational semantics from the entry
	"Launchbury", where we formalized Launchbury's natural semantics for
	lazy evaluation.
	<p>
	The functional correctness of Call Arity is proved with regard to that
	denotational semantics. The operational properties are shown with
	regard to a small-step semantics akin to Sestoft's mark 1 machine,
	which we prove to be equivalent to Launchbury's semantics.
	<p>
	We use Christian Urban's Nominal2 package to define our terms and make
	use of Brian Huffman's HOLCF package for the domain-theoretical
	aspects of the development.
	extra-history =
	Change history:
	[2015-03-16]: This entry now builds on top of the Launchbury entry,
	and the equivalency proof of the natural and the small-step semantics
	was added.
	notify =

	[CCS]
	title = CCS in nominal logic
	author = Jesper Bengtson <http://www.itu.dk/people/jebe>
	date = 2012-05-29
	topic = Computer Science/Concurrency/Process Calculi
	abstract = We formalise a large portion of CCS as described in Milner's book 'Communication and Concurrency' using the nominal datatype package in Isabelle. Our results include many of the standard theorems of bisimulation equivalence and congruence, for both weak and strong versions. One main goal of this formalisation is to keep the machine-checked proofs as close to their pen-and-paper counterpart as possible.
	<p>
	This entry is described in detail in <a href="http://www.itu.dk/people/jebe/files/thesis.pdf">Bengtson's thesis</a>.
	notify =

	[Pi_Calculus]
	title = The pi-calculus in nominal logic
	author = Jesper Bengtson <http://www.itu.dk/people/jebe>
	date = 2012-05-29
	topic = Computer Science/Concurrency/Process Calculi
	abstract = We formalise the pi-calculus using the nominal datatype package, based on ideas from the nominal logic by Pitts et al., and demonstrate an implementation in Isabelle/HOL. The purpose is to derive powerful induction rules for the semantics in order to conduct machine checkable proofs, closely following the intuitive arguments found in manual proofs. In this way we have covered many of the standard theorems of bisimulation equivalence and congruence, both late and early, and both strong and weak in a uniform manner. We thus provide one of the most extensive formalisations of a the pi-calculus ever done inside a theorem prover.
	<p>
	A significant gain in our formulation is that agents are identified up to alpha-equivalence, thereby greatly reducing the arguments about bound names. This is a normal strategy for manual proofs about the pi-calculus, but that kind of hand waving has previously been difficult to incorporate smoothly in an interactive theorem prover. We show how the nominal logic formalism and its support in Isabelle accomplishes this and thus significantly reduces the tedium of conducting completely formal proofs. This improves on previous work using weak higher order abstract syntax since we do not need extra assumptions to filter out exotic terms and can keep all arguments within a familiar first-order logic.
	<p>
	This entry is described in detail in <a href="http://www.itu.dk/people/jebe/files/thesis.pdf">Bengtson's thesis</a>.
	notify =

	[Psi_Calculi]
	title = Psi-calculi in Isabelle
	author = Jesper Bengtson <http://www.itu.dk/people/jebe>
	date = 2012-05-29
	topic = Computer Science/Concurrency/Process Calculi
	abstract = Psi-calculi are extensions of the pi-calculus, accommodating arbitrary nominal datatypes to represent not only data but also communication channels, assertions and conditions, giving it an expressive power beyond the applied pi-calculus and the concurrent constraint pi-calculus.
	<p>
	We have formalised psi-calculi in the interactive theorem prover Isabelle using its nominal datatype package. One distinctive feature is that the framework needs to treat binding sequences, as opposed to single binders, in an efficient way. While different methods for formalising single binder calculi have been proposed over the last decades, representations for such binding sequences are not very well explored.
	<p>
	The main effort in the formalisation is to keep the machine checked proofs as close to their pen-and-paper counterparts as possible. This includes treating all binding sequences as atomic elements, and creating custom induction and inversion rules that to remove the bulk of manual alpha-conversions.
	<p>
	This entry is described in detail in <a href="http://www.itu.dk/people/jebe/files/thesis.pdf">Bengtson's thesis</a>.
	notify =

	[Encodability_Process_Calculi]
	title = Analysing and Comparing Encodability Criteria for Process Calculi
	author = Kirstin Peters <mailto:kirstin.peters@tu-berlin.de>, Rob van Glabbeek <http://theory.stanford.edu/~rvg/>
	date = 2015-08-10
	topic = Computer Science/Concurrency/Process Calculi
	abstract = Encodings or the proof of their absence are the main way to
	compare process calculi. To analyse the quality of encodings and to rule out
	trivial or meaningless encodings, they are augmented with quality
	criteria. There exists a bunch of different criteria and different variants
	of criteria in order to reason in different settings. This leads to
	incomparable results. Moreover it is not always clear whether the criteria
	used to obtain a result in a particular setting do indeed fit to this
	setting. We show how to formally reason about and compare encodability
	criteria by mapping them on requirements on a relation between source and
	target terms that is induced by the encoding function. In particular we
	analyse the common criteria full abstraction, operational correspondence,
	divergence reflection, success sensitiveness, and respect of barbs; e.g. we
	analyse the exact nature of the simulation relation (coupled simulation
	versus bisimulation) that is induced by different variants of operational
	correspondence. This way we reduce the problem of analysing or comparing
	encodability criteria to the better understood problem of comparing
	relations on processes.
	notify = kirstin.peters@tu-berlin.de

	[Circus]
	title = Isabelle/Circus
	author = Abderrahmane Feliachi <mailto:abderrahmane.feliachi@lri.fr>, Burkhart Wolff <mailto:wolff@lri.fr>, Marie-Claude Gaudel <mailto:mcg@lri.fr>
	contributors = Makarius Wenzel <mailto:Makarius.wenzel@lri.fr>
	date = 2012-05-27
	topic = Computer Science/Concurrency/Process Calculi, Computer Science/System Description Languages
	abstract = The Circus specification language combines elements for complex data and behavior specifications, using an integration of Z and CSP with a refinement calculus. Its semantics is based on Hoare and He's Unifying Theories of Programming (UTP). Isabelle/Circus is a formalization of the UTP and the Circus language in Isabelle/HOL. It contains proof rules and tactic support that allows for proofs of refinement for Circus processes (involving both data and behavioral aspects).
	<p>
	The Isabelle/Circus environment supports a syntax for the semantic definitions which is close to textbook presentations of Circus. This article contains an extended version of corresponding VSTTE Paper together with the complete formal development of its underlying commented theories.
	extra-history =
	Change history:
	[2014-06-05]: More polishing, shorter proofs, added Circus syntax, added Makarius Wenzel as contributor.
	notify =

	[Dijkstra_Shortest_Path]
	title = Dijkstra's Shortest Path Algorithm
	author = Benedikt Nordhoff <mailto:b.n@wwu.de>, Peter Lammich <http://www21.in.tum.de/~lammich>
	topic = Computer Science/Algorithms
	date = 2012-01-30
	abstract = We implement and prove correct Dijkstra's algorithm for the
	single source shortest path problem, conceived in 1956 by E. Dijkstra.
	The algorithm is implemented using the data refinement framework for monadic,
	nondeterministic programs. An efficient implementation is derived using data
	structures from the Isabelle Collection Framework.
	notify = lammich@in.tum.de

	[Refine_Monadic]
	title = Refinement for Monadic Programs
	author = Peter Lammich <http://www21.in.tum.de/~lammich>
	topic = Computer Science/Programming Languages/Logics
	date = 2012-01-30
	abstract = We provide a framework for program and data refinement in Isabelle/HOL.
	The framework is based on a nondeterminism-monad with assertions, i.e.,
	the monad carries a set of results or an assertion failure.
	Recursion is expressed by fixed points. For convenience, we also provide
	while and foreach combinators.
	<p>
	The framework provides tools to automatize canonical tasks, such as
	verification condition generation, finding appropriate data refinement relations,
	and refine an executable program to a form that is accepted by the
	Isabelle/HOL code generator.
	<p>
	This submission comes with a collection of examples and a user-guide,
	illustrating the usage of the framework.
	extra-history =
	Change history:
	[2012-04-23] Introduced ordered FOREACH loops<br>
	[2012-06] New features:
	REC_rule_arb and RECT_rule_arb allow for generalizing over variables.
	prepare_code_thms - command extracts code equations for recursion combinators.<br>
	[2012-07] New example: Nested DFS for emptiness check of Buchi-automata with witness.<br>
	New feature:
	fo_rule method to apply resolution using first-order matching. Useful for arg_conf, fun_cong.<br>
	[2012-08] Adaptation to ICF v2.<br>
	[2012-10-05] Adaptations to include support for Automatic Refinement Framework.<br>
	[2013-09] This entry now depends on Automatic Refinement<br>
	[2014-06] New feature: vc_solve method to solve verification conditions.
	Maintenace changes: VCG-rules for nfoldli, improved setup for FOREACH-loops.<br>
	[2014-07] Now defining recursion via flat domain. Dropped many single-valued prerequisites.
	Changed notion of data refinement. In single-valued case, this matches the old notion.
	In non-single valued case, the new notion allows for more convenient rules.
	In particular, the new definitions allow for projecting away ghost variables as a refinement step.<br>
	[2014-11] New features: le-or-fail relation (leof), modular reasoning about loop invariants.
	notify = lammich@in.tum.de

	[Refine_Imperative_HOL]
	title = The Imperative Refinement Framework
	author = Peter Lammich <http://www21.in.tum.de/~lammich>
	notify = lammich@in.tum.de
	date = 2016-08-08
	topic = Computer Science/Programming Languages/Transformations,Computer Science/Data Structures
	abstract =
	We present the Imperative Refinement Framework (IRF), a tool that
	supports a stepwise refinement based approach to imperative programs.
	This entry is based on the material we presented in [ITP-2015,
	CPP-2016]. It uses the Monadic Refinement Framework as a frontend for
	the specification of the abstract programs, and Imperative/HOL as a
	backend to generate executable imperative programs. The IRF comes
	with tool support to synthesize imperative programs from more
	abstract, functional ones, using efficient imperative implementations
	for the abstract data structures. This entry also includes the
	Imperative Isabelle Collection Framework (IICF), which provides a
	library of re-usable imperative collection data structures. Moreover,
	this entry contains a quickstart guide and a reference manual, which
	provide an introduction to using the IRF for Isabelle/HOL experts. It
	also provids a collection of (partly commented) practical examples,
	some highlights being Dijkstra's Algorithm, Nested-DFS, and a generic
	worklist algorithm with subsumption. Finally, this entry contains
	benchmark scripts that compare the runtime of some examples against
	reference implementations of the algorithms in Java and C++.
	[ITP-2015] Peter Lammich: Refinement to Imperative/HOL. ITP 2015:
	253--269 [CPP-2016] Peter Lammich: Refinement based verification of
	imperative data structures. CPP 2016: 27--36

	[Automatic_Refinement]
	title = Automatic Data Refinement
	author = Peter Lammich <mailto:lammich@in.tum.de>
	topic = Computer Science/Programming Languages/Logics
	date = 2013-10-02
	abstract = We present the Autoref tool for Isabelle/HOL, which automatically
	refines algorithms specified over abstract concepts like maps
	and sets to algorithms over concrete implementations like red-black-trees,
	and produces a refinement theorem. It is based on ideas borrowed from
	relational parametricity due to Reynolds and Wadler.
	The tool allows for rapid prototyping of verified, executable algorithms.
	Moreover, it can be configured to fine-tune the result to the user~s needs.
	Our tool is able to automatically instantiate generic algorithms, which
	greatly simplifies the implementation of executable data structures.
	<p>
	This AFP-entry provides the basic tool, which is then used by the
	Refinement and Collection Framework to provide automatic data refinement for
	the nondeterminism monad and various collection datastructures.
	notify = lammich@in.tum.de

	[EdmondsKarp_Maxflow]
	title = Formalizing the Edmonds-Karp Algorithm
	author = Peter Lammich <mailto:lammich@in.tum.de>, S. Reza Sefidgar<>
	notify = lammich@in.tum.de
	date = 2016-08-12
	topic = Computer Science/Algorithms
	abstract =
	We present a formalization of the Ford-Fulkerson method for computing
	the maximum flow in a network. Our formal proof closely follows a
	standard textbook proof, and is accessible even without being an
	expert in Isabelle/HOL--- the interactive theorem prover used for the
	formalization. We then use stepwise refinement to obtain the
	Edmonds-Karp algorithm, and formally prove a bound on its complexity.
	Further refinement yields a verified implementation, whose execution
	time compares well to an unverified reference implementation in Java.
	This entry is based on our ITP-2016 paper with the same title.

	[VerifyThis2018]
	title = VerifyThis 2018 - Polished Isabelle Solutions
	author = Peter Lammich <http://www21.in.tum.de/~lammich>, Simon Wimmer <http://in.tum.de/~wimmers>
	topic = Computer Science/Algorithms
	date = 2018-04-27
	notify = lammich@in.tum.de
	abstract =
	<a
	href="http://www.pm.inf.ethz.ch/research/verifythis.html">VerifyThis
	2018</a> was a program verification competition associated with
	ETAPS 2018. It was the 7th event in the VerifyThis competition series.
	In this entry, we present polished and completed versions of our
	solutions that we created during the competition.

	[PseudoHoops]
	title = Pseudo Hoops
	author = George Georgescu <>, Laurentiu Leustean <>, Viorel Preoteasa <http://users.abo.fi/vpreotea/>
	topic = Mathematics/Algebra
	date = 2011-09-22
	abstract = Pseudo-hoops are algebraic structures introduced by B. Bosbach under the name of complementary semigroups. In this formalization we prove some properties of pseudo-hoops and we define the basic concepts of filter and normal filter. The lattice of normal filters is isomorphic with the lattice of congruences of a pseudo-hoop. We also study some important classes of pseudo-hoops. Bounded Wajsberg pseudo-hoops are equivalent to pseudo-Wajsberg algebras and bounded basic pseudo-hoops are equivalent to pseudo-BL algebras. Some examples of pseudo-hoops are given in the last section of the formalization.
	notify = viorel.preoteasa@aalto.fi

	[MonoBoolTranAlgebra]
	title = Algebra of Monotonic Boolean Transformers
	author = Viorel Preoteasa <http://users.abo.fi/vpreotea/>
	topic = Computer Science/Programming Languages/Logics
	date = 2011-09-22
	abstract = Algebras of imperative programming languages have been successful in reasoning about programs. In general an algebra of programs is an algebraic structure with programs as elements and with program compositions (sequential composition, choice, skip) as algebra operations. Various versions of these algebras were introduced to model partial correctness, total correctness, refinement, demonic choice, and other aspects. We formalize here an algebra which can be used to model total correctness, refinement, demonic and angelic choice. The basic model of this algebra are monotonic Boolean transformers (monotonic functions from a Boolean algebra to itself).
	notify = viorel.preoteasa@aalto.fi

	[LatticeProperties]
	title = Lattice Properties
	author = Viorel Preoteasa <http://users.abo.fi/vpreotea/>
	topic = Mathematics/Algebra
	date = 2011-09-22
	abstract = This formalization introduces and collects some algebraic structures based on lattices and complete lattices for use in other developments. The structures introduced are modular, and lattice ordered groups. In addition to the results proved for the new lattices, this formalization also introduces theorems about latices and complete lattices in general.
	extra-history =
	Change history:
	[2012-01-05]: Removed the theory about distributive complete lattices which is in the standard library now.
	Added a theory about well founded and transitive relations and a result about fixpoints in complete lattices and well founded relations.
	Moved the results about conjunctive and disjunctive functions to a new theory.
	Removed the syntactic classes for inf and sup which are in the standard library now.
	notify = viorel.preoteasa@aalto.fi

	[Impossible_Geometry]
	title = Proving the Impossibility of Trisecting an Angle and Doubling the Cube
	author = Ralph Romanos <mailto:ralph.romanos@student.ecp.fr>, Lawrence C. Paulson <http://www.cl.cam.ac.uk/~lp15/>
	topic = Mathematics/Algebra, Mathematics/Geometry
	date = 2012-08-05
	abstract = Squaring the circle, doubling the cube and trisecting an angle, using a compass and straightedge alone, are classic unsolved problems first posed by the ancient Greeks. All three problems were proved to be impossible in the 19th century. The following document presents the proof of the impossibility of solving the latter two problems using Isabelle/HOL, following a proof by Carrega. The proof uses elementary methods: no Galois theory or field extensions. The set of points constructible using a compass and straightedge is defined inductively. Radical expressions, which involve only square roots and arithmetic of rational numbers, are defined, and we find that all constructive points have radical coordinates. Finally, doubling the cube and trisecting certain angles requires solving certain cubic equations that can be proved to have no rational roots. The Isabelle proofs require a great many detailed calculations.
	notify = ralph.romanos@student.ecp.fr, lp15@cam.ac.uk

	[IP_Addresses]
	title = IP Addresses
	author = Cornelius Diekmann <http://net.in.tum.de/~diekmann>, Julius Michaelis <http://liftm.de>, Lars Hupel <https://www21.in.tum.de/~hupel/>
	notify = diekmann@net.in.tum.de
	date = 2016-06-28
	topic = Computer Science/Networks
	abstract =
	This entry contains a definition of IP addresses and a library to work
	with them. Generic IP addresses are modeled as machine words of
	arbitrary length. Derived from this generic definition, IPv4 addresses
	are 32bit machine words, IPv6 addresses are 128bit words.
	Additionally, IPv4 addresses can be represented in dot-decimal
	notation and IPv6 addresses in (compressed) colon-separated notation.
	We support toString functions and parsers for both notations. Sets of
	IP addresses can be represented with a netmask (e.g.
	192.168.0.0/255.255.0.0) or in CIDR notation (e.g. 192.168.0.0/16). To
	provide executable code for set operations on IP address ranges, the
	library includes a datatype to work on arbitrary intervals of machine
	words.

	[Simple_Firewall]
	title = Simple Firewall
	author = Cornelius Diekmann <http://net.in.tum.de/~diekmann>, Julius Michaelis <http://liftm.de>, Maximilian Haslbeck<https://home.in.tum.de/~haslbecm/>
	notify = diekmann@net.in.tum.de, max.haslbeck@gmx.de
	date = 2016-08-24
	topic = Computer Science/Networks
	abstract =
	We present a simple model of a firewall. The firewall can accept or
	drop a packet and can match on interfaces, IP addresses, protocol, and
	ports. It was designed to feature nice mathematical properties: The
	type of match expressions was carefully crafted such that the
	conjunction of two match expressions is only one match expression.
	This model is too simplistic to mirror all aspects of the real world.
	In the upcoming entry "Iptables Semantics", we will translate the
	Linux firewall iptables to this model. For a fixed service (e.g. ssh,
	http), we provide an algorithm to compute an overview of the
	firewall's filtering behavior. The algorithm computes minimal service
	matrices, i.e. graphs which partition the complete IPv4 and IPv6
	address space and visualize the allowed accesses between partitions.
	For a detailed description, see
	<a href="http://dl.ifip.org/db/conf/networking/networking2016/1570232858.pdf">Verified iptables Firewall
	Analysis</a>, IFIP Networking 2016.

	[Iptables_Semantics]
	title = Iptables Semantics
	author = Cornelius Diekmann <http://net.in.tum.de/~diekmann>, Lars Hupel <https://www21.in.tum.de/~hupel/>
	notify = diekmann@net.in.tum.de, hupel@in.tum.de
	date = 2016-09-09
	topic = Computer Science/Networks
	abstract =
	We present a big step semantics of the filtering behavior of the
	Linux/netfilter iptables firewall. We provide algorithms to simplify
	complex iptables rulests to a simple firewall model (c.f. AFP entry <a
	href="https://www.isa-afp.org/entries/Simple_Firewall.html">Simple_Firewall</a>)
	and to verify spoofing protection of a ruleset.
	Internally, we embed our semantics into ternary logic, ultimately
	supporting every iptables match condition by abstracting over
	unknowns. Using this AFP entry and all entries it depends on, we
	created an easy-to-use, stand-alone haskell tool called <a
	href="http://iptables.isabelle.systems">fffuu</a>. The tool does not
	require any input —except for the <tt>iptables-save</tt> dump of
	the analyzed firewall— and presents interesting results about
	the user's ruleset. Real-Word firewall errors have been uncovered, and
	the correctness of rulesets has been proved, with the help of
	our tool.

	[Routing]
	title = Routing
	author = Julius Michaelis <http://liftm.de>, Cornelius Diekmann <http://net.in.tum.de/~diekmann>
	notify = afp@liftm.de
	date = 2016-08-31
	topic = Computer Science/Networks
	abstract =
	This entry contains definitions for routing with routing
	tables/longest prefix matching. A routing table entry is modelled as
	a record of a prefix match, a metric, an output port, and an optional
	next hop. A routing table is a list of entries, sorted by prefix
	length and metric. Additionally, a parser and serializer for the
	output of the ip-route command, a function to create a relation from
	output port to corresponding destination IP space, and a model of a
	Linux-style router are included.

	[KBPs]
	title = Knowledge-based programs
	author = Peter Gammie <http://peteg.org>
	topic = Computer Science/Automata and Formal Languages
	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.
	extra-history =
	Change history:
	[2012-03-06]: Add some more views and revive the code generation.
	notify = kleing@cse.unsw.edu.au

	[Tarskis_Geometry]
	title = The independence of Tarski's Euclidean axiom
	author = T. J. M. Makarios <mailto:tjm1983@gmail.com>
	topic = Mathematics/Geometry
	date = 2012-10-30
	abstract =
	Tarski's axioms of plane geometry are formalized and, using the standard
	real Cartesian model, shown to be consistent. A substantial theory of
	the projective plane is developed. Building on this theory, the
	Klein-Beltrami model of the hyperbolic plane is defined and shown to
	satisfy all of Tarski's axioms except his Euclidean axiom; thus Tarski's
	Euclidean axiom is shown to be independent of his other axioms of plane
	geometry.
	<p>
	An earlier version of this work was the subject of the author's
	<a href="http://researcharchive.vuw.ac.nz/handle/10063/2315">MSc thesis</a>,
	which contains natural-language explanations of some of the
	more interesting proofs.
	notify = tjm1983@gmail.com

	[General-Triangle]
	title = The General Triangle Is Unique
	author = Joachim Breitner <mailto:mail@joachim-breitner.de>
	topic = Mathematics/Geometry
	date = 2011-04-01
	abstract = Some acute-angled triangles are special, e.g. right-angled or isoscele triangles. Some are not of this kind, but, without measuring angles, look as if they were. In that sense, there is exactly one general triangle. This well-known fact is proven here formally.
	notify = mail@joachim-breitner.de

	[LightweightJava]
	title = Lightweight Java
	author = Rok Strniša <http://rok.strnisa.com/lj/>, Matthew Parkinson <http://research.microsoft.com/people/mattpark/>
	topic = Computer Science/Programming Languages/Language Definitions
	date = 2011-02-07
	abstract = A fully-formalized and extensible minimal imperative fragment of Java.
	notify = rok@strnisa.com

	[Lower_Semicontinuous]
	title = Lower Semicontinuous Functions
	author = Bogdan Grechuk <mailto:grechukbogdan@yandex.ru>
	topic = Mathematics/Analysis
	date = 2011-01-08
	abstract = We define the notions of lower and upper semicontinuity for functions from a metric space to the extended real line. We prove that a function is both lower and upper semicontinuous if and only if it is continuous. We also give several equivalent characterizations of lower semicontinuity. In particular, we prove that a function is lower semicontinuous if and only if its epigraph is a closed set. Also, we introduce the notion of the lower semicontinuous hull of an arbitrary function and prove its basic properties.
	notify = hoelzl@in.tum.de

	[RIPEMD-160-SPARK]
	title = RIPEMD-160
	author = Fabian Immler <mailto:immler@in.tum.de>
	topic = Computer Science/Programming Languages/Static Analysis
	date = 2011-01-10
	abstract = This work presents a verification of an implementation in SPARK/ADA of the cryptographic hash-function RIPEMD-160. A functional specification of RIPEMD-160 is given in Isabelle/HOL. Proofs for the verification conditions generated by the static-analysis toolset of SPARK certify the functional correctness of the implementation.
	extra-history =
	Change history:
	[2015-11-09]: Entry is now obsolete, moved to Isabelle distribution.
	notify = immler@in.tum.de

	[Regular-Sets]
	title = Regular Sets and Expressions
	author = Alexander Krauss <http://www.in.tum.de/~krauss>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	contributors = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Computer Science/Automata and Formal Languages
	date = 2010-05-12
	abstract = This is a library of constructions on regular expressions and languages. It provides the operations of concatenation, Kleene star and derivative on languages. Regular expressions and their meaning are defined. An executable equivalence checker for regular expressions is verified; it does not need automata but works directly on regular expressions. <i>By mapping regular expressions to binary relations, an automatic and complete proof method for (in)equalities of binary relations over union, concatenation and (reflexive) transitive closure is obtained.</i> <P> Extended regular expressions with complement and intersection are also defined and an equivalence checker is provided.
	extra-history =
	Change history:
	[2011-08-26]: Christian Urban added a theory about derivatives and partial derivatives of regular expressions<br>
	[2012-05-10]: Tobias Nipkow added extended regular expressions<br>
	[2012-05-10]: Tobias Nipkow added equivalence checking with partial derivatives
	notify = nipkow@in.tum.de, krauss@in.tum.de, christian.urban@kcl.ac.uk

	[Regex_Equivalence]
	title = Unified Decision Procedures for Regular Expression Equivalence
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>, Dmitriy Traytel <mailto:traytel@in.tum.de>
	topic = Computer Science/Automata and Formal Languages
	date = 2014-01-30
	abstract =
	We formalize a unified framework for verified decision procedures for regular
	expression equivalence. Five recently published formalizations of such
	decision procedures (three based on derivatives, two on marked regular
	expressions) can be obtained as instances of the framework. We discover that
	the two approaches based on marked regular expressions, which were previously
	thought to be the same, are different, and one seems to produce uniformly
	smaller automata. The common framework makes it possible to compare the
	performance of the different decision procedures in a meaningful way.
	<a href="http://www21.in.tum.de/~nipkow/pubs/itp14.html">
	The formalization is described in a paper of the same name presented at
	Interactive Theorem Proving 2014</a>.
	notify = nipkow@in.tum.de, traytel@in.tum.de

	[MSO_Regex_Equivalence]
	title = Decision Procedures for MSO on Words Based on Derivatives of Regular Expressions
	author = Dmitriy Traytel <mailto:traytel@in.tum.de>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	topic = Computer Science/Automata and Formal Languages, Logic
	date = 2014-06-12
	abstract =
	Monadic second-order logic on finite words (MSO) is a decidable yet
	expressive logic into which many decision problems can be encoded. Since MSO
	formulas correspond to regular languages, equivalence of MSO formulas can be
	reduced to the equivalence of some regular structures (e.g. automata). We
	verify an executable decision procedure for MSO formulas that is not based
	on automata but on regular expressions.
	<p>
	Decision procedures for regular expression equivalence have been formalized
	before, usually based on Brzozowski derivatives. Yet, for a straightforward
	embedding of MSO formulas into regular expressions an extension of regular
	expressions with a projection operation is required. We prove total
	correctness and completeness of an equivalence checker for regular
	expressions extended in that way. We also define a language-preserving
	translation of formulas into regular expressions with respect to two
	different semantics of MSO.
	<p>
	The formalization is described in this <a href="http://www21.in.tum.de/~nipkow/pubs/icfp13.html">ICFP 2013 functional pearl</a>.
	notify = traytel@in.tum.de, nipkow@in.tum.de

	[Formula_Derivatives]
	title = Derivatives of Logical Formulas
	author = Dmitriy Traytel <http://www21.in.tum.de/~traytel>
	topic = Computer Science/Automata and Formal Languages, Logic
	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 <em>not</em> 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).
	<p>
	The WS1S instance is described in the draft paper <a
	href="https://people.inf.ethz.ch/trayteld/papers/csl15-ws1s_derivatives/index.html">A
	Coalgebraic Decision Procedure for WS1S</a> by the author.
	notify = traytel@in.tum.de

	[Myhill-Nerode]
	title = The Myhill-Nerode Theorem Based on Regular Expressions
	author = Chunhan Wu <>, Xingyuan Zhang <>, Christian Urban <http://www.inf.kcl.ac.uk/staff/urbanc/>
	contributors = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Computer Science/Automata and Formal Languages
	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.
	notify = christian.urban@kcl.ac.uk

	[Universal_Turing_Machine]
	title = Universal Turing Machine
	author = Jian Xu<>, Xingyuan Zhang<>, Christian Urban <https://nms.kcl.ac.uk/christian.urban/>, Sebastiaan J. C. Joosten <http://sjcjoosten.nl/>
	topic = Logic, Computer Science/Automata and Formal Languages
	date = 2019-02-08
	notify = sjcjoosten@gmail.com, christian.urban@kcl.ac.uk
	abstract =
	We formalise results from computability theory: recursive functions,
	undecidability of the halting problem, and the existence of a
	universal Turing machine. This formalisation is the AFP entry
	corresponding to the paper Mechanising Turing Machines and Computability Theory
	in Isabelle/HOL, ITP 2013.

	[CYK]
	title = A formalisation of the Cocke-Younger-Kasami algorithm
	author = Maksym Bortin <mailto:Maksym.Bortin@nicta.com.au>
	date = 2016-04-27
	topic = Computer Science/Algorithms, Computer Science/Automata and Formal Languages
	abstract =
	The theory provides a formalisation of the Cocke-Younger-Kasami
	algorithm (CYK for short), an approach to solving the word problem
	for context-free languages. CYK decides if a word is in the
	languages generated by a context-free grammar in Chomsky normal form.
	The formalized algorithm is executable.
	notify = maksym.bortin@nicta.com.au

	[Boolean_Expression_Checkers]
	title = Boolean Expression Checkers
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2014-06-08
	topic = Computer Science/Algorithms, Logic
	abstract =
	This entry provides executable checkers for the following properties of
	boolean expressions: satisfiability, tautology and equivalence. Internally,
	the checkers operate on binary decision trees and are reasonably efficient
	(for purely functional algorithms).
	extra-history =
	Change history: [2015-09-23]: Salomon Sickert added an interface that does not require the usage of the Boolean formula datatype. Furthermore the general Mapping type is used instead of an association list.
	notify = nipkow@in.tum.de

	[Presburger-Automata]
	title = Formalizing the Logic-Automaton Connection
	author = Stefan Berghofer <http://www.in.tum.de/~berghofe>, Markus Reiter <>
	date = 2009-12-03
	topic = Computer Science/Automata and Formal Languages, Logic
	abstract = This work presents a formalization of a library for automata on bit strings. It forms the basis of a reflection-based decision procedure for Presburger arithmetic, which is efficiently executable thanks to Isabelle's code generator. With this work, we therefore provide a mechanized proof of a well-known connection between logic and automata theory. The formalization is also described in a publication [TPHOLs 2009].
	notify = berghofe@in.tum.de

	[Functional-Automata]
	title = Functional Automata
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2004-03-30
	topic = Computer Science/Automata and Formal Languages
	abstract = This theory defines deterministic and nondeterministic automata in a functional representation: the transition function/relation and the finality predicate are just functions. Hence the state space may be infinite. It is shown how to convert regular expressions into such automata. A scanner (generator) is implemented with the help of functional automata: the scanner chops the input up into longest recognized substrings. Finally we also show how to convert a certain subclass of functional automata (essentially the finite deterministic ones) into regular sets.
	notify = nipkow@in.tum.de

	[Statecharts]
	title = Formalizing Statecharts using Hierarchical Automata
	author = Steffen Helke <mailto:helke@cs.tu-berlin.de>, Florian Kammüller <mailto:flokam@cs.tu-berlin.de>
	topic = Computer Science/Automata and Formal Languages
	date = 2010-08-08
	abstract = We formalize in Isabelle/HOL the abtract syntax and a synchronous
	step semantics for the specification language Statecharts. The formalization
	is based on Hierarchical Automata which allow a structural decomposition of
	Statecharts into Sequential Automata. To support the composition of
	Statecharts, we introduce calculating operators to construct a Hierarchical
	Automaton in a stepwise manner. Furthermore, we present a complete semantics
	of Statecharts including a theory of data spaces, which enables the modelling
	of racing effects. We also adapt CTL for
	Statecharts to build a bridge for future combinations with model
	checking. However the main motivation of this work is to provide a sound and
	complete basis for reasoning on Statecharts. As a central meta theorem we
	prove that the well-formedness of a Statechart is preserved by the semantics.
	notify = nipkow@in.tum.de

	[Stuttering_Equivalence]
	title = Stuttering Equivalence
	author = Stephan Merz <http://www.loria.fr/~merz>
	topic = Computer Science/Automata and Formal Languages
	date = 2012-05-07
	abstract = <p>Two omega-sequences are stuttering equivalent if they differ only by finite repetitions of elements. Stuttering equivalence is a fundamental concept in the theory of concurrent and distributed systems. Notably, Lamport argues that refinement notions for such systems should be insensitive to finite stuttering. Peled and Wilke showed that all PLTL (propositional linear-time temporal logic) properties that are insensitive to stuttering equivalence can be expressed without the next-time operator. Stuttering equivalence is also important for certain verification techniques such as partial-order reduction for model checking.</p> <p>We formalize stuttering equivalence in Isabelle/HOL. Our development relies on the notion of stuttering sampling functions that may skip blocks of identical sequence elements. We also encode PLTL and prove the theorem due to Peled and Wilke.</p>
	extra-history =
	Change history:
	[2013-01-31]: Added encoding of PLTL and proved Peled and Wilke's theorem. Adjusted abstract accordingly.
	notify = Stephan.Merz@loria.fr

	[Coinductive_Languages]
	title = A Codatatype of Formal Languages
	author = Dmitriy Traytel <mailto:traytel@in.tum.de>
	topic = Computer Science/Automata and Formal Languages
	date = 2013-11-15
	abstract = <p>We define formal languages as a codataype of infinite trees
	branching over the alphabet. Each node in such a tree indicates whether the
	path to this node constitutes a word inside or outside of the language. This
	codatatype is isormorphic to the set of lists representation of languages,
	but caters for definitions by corecursion and proofs by coinduction.</p>
	<p>Regular operations on languages are then defined by primitive corecursion.
	A difficulty arises here, since the standard definitions of concatenation and
	iteration from the coalgebraic literature are not primitively
	corecursive-they require guardedness up-to union/concatenation.
	Without support for up-to corecursion, these operation must be defined as a
	composition of primitive ones (and proved being equal to the standard
	definitions). As an exercise in coinduction we also prove the axioms of
	Kleene algebra for the defined regular operations.</p>
	<p>Furthermore, a language for context-free grammars given by productions in
	Greibach normal form and an initial nonterminal is constructed by primitive
	corecursion, yielding an executable decision procedure for the word problem
	without further ado.</p>
	notify = traytel@in.tum.de

	[Tree-Automata]
	title = Tree Automata
	author = Peter Lammich <http://www21.in.tum.de/~lammich>
	date = 2009-11-25
	topic = Computer Science/Automata and Formal Languages
	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.
	notify = peter.lammich@uni-muenster.de, nipkow@in.tum.de

	[Depth-First-Search]
	title = Depth First Search
	author = Toshiaki Nishihara <>, Yasuhiko Minamide <>
	date = 2004-06-24
	topic = Computer Science/Algorithms
	abstract = Depth-first search of a graph is formalized with recdef. It is shown that it visits all of the reachable nodes from a given list of nodes. Executable ML code of depth-first search is obtained using the code generation feature of Isabelle/HOL.
	notify = lp15@cam.ac.uk, krauss@in.tum.de

	[FFT]
	title = Fast Fourier Transform
	author = Clemens Ballarin <http://www21.in.tum.de/~ballarin/>
	date = 2005-10-12
	topic = Computer Science/Algorithms
	abstract = We formalise a functional implementation of the FFT algorithm over the complex numbers, and its inverse. Both are shown equivalent to the usual definitions of these operations through Vandermonde matrices. They are also shown to be inverse to each other, more precisely, that composition of the inverse and the transformation yield the identity up to a scalar.
	notify = ballarin@in.tum.de

	[Gauss-Jordan-Elim-Fun]
	title = Gauss-Jordan Elimination for Matrices Represented as Functions
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2011-08-19
	topic = Computer Science/Algorithms, Mathematics/Algebra
	abstract = This theory provides a compact formulation of Gauss-Jordan elimination for matrices represented as functions. Its distinctive feature is succinctness. It is not meant for large computations.
	notify = nipkow@in.tum.de

	[UpDown_Scheme]
	title = Verification of the UpDown Scheme
	author = Johannes Hölzl <mailto:hoelzl@in.tum.de>
	date = 2015-01-28
	topic = Computer Science/Algorithms
	abstract =
	The UpDown scheme is a recursive scheme used to compute the stiffness matrix
	on a special form of sparse grids. Usually, when discretizing a Euclidean
	space of dimension d we need O(n^d) points, for n points along each dimension.
	Sparse grids are a hierarchical representation where the number of points is
	reduced to O(n * log(n)^d). One disadvantage of such sparse grids is that the
	algorithm now operate recursively in the dimensions and levels of the sparse grid.
	<p>
	The UpDown scheme allows us to compute the stiffness matrix on such a sparse
	grid. The stiffness matrix represents the influence of each representation
	function on the L^2 scalar product. For a detailed description see
	Dirk Pflüger's PhD thesis. This formalization was developed as an
	interdisciplinary project (IDP) at the Technische Universität München.
	notify = hoelzl@in.tum.de

	[GraphMarkingIBP]
	title = Verification of the Deutsch-Schorr-Waite Graph Marking Algorithm using Data Refinement
	author = Viorel Preoteasa <http://users.abo.fi/vpreotea/>, Ralph-Johan Back <http://users.abo.fi/Ralph-Johan.Back/>
	date = 2010-05-28
	topic = Computer Science/Algorithms
	abstract = The verification of the Deutsch-Schorr-Waite graph marking algorithm is used as a benchmark in many formalizations of pointer programs. The main purpose of this mechanization is to show how data refinement of invariant based programs can be used in verifying practical algorithms. The verification starts with an abstract algorithm working on a graph given by a relation <i>next</i> on nodes. Gradually the abstract program is refined into Deutsch-Schorr-Waite graph marking algorithm where only one bit per graph node of additional memory is used for marking.
	extra-history =
	Change history:
	[2012-01-05]: Updated for the new definition of data refinement and the new syntax for demonic and angelic update statements
	notify = viorel.preoteasa@aalto.fi

	[Efficient-Mergesort]
	title = Efficient Mergesort
	topic = Computer Science/Algorithms
	date = 2011-11-09
	author = Christian Sternagel <mailto:c.sternagel@gmail.com>
	abstract = We provide a formalization of the mergesort algorithm as used in GHC's Data.List module, proving correctness and stability. Furthermore, experimental data suggests that generated (Haskell-)code for this algorithm is much faster than for previous algorithms available in the Isabelle distribution.
	extra-history =
	Change history:
	[2012-10-24]:
	Added reference to journal article.<br>
	[2018-09-17]:
	Added theory Efficient_Mergesort that works exclusively with the mutual
	induction schemas generated by the function package.<br>
	[2018-09-19]:
	Added theory Mergesort_Complexity that proves an upper bound on the number of
	comparisons that are required by mergesort.<br>
	[2018-09-19]:
	Theory Efficient_Mergesort replaces theory Efficient_Sort but keeping the old
	name Efficient_Sort.
	notify = c.sternagel@gmail.com

	[SATSolverVerification]
	title = Formal Verification of Modern SAT Solvers
	author = Filip Maric <http://poincare.matf.bg.ac.rs/~filip/>
	date = 2008-07-23
	topic = Computer Science/Algorithms
	abstract = This document contains formal correctness proofs of modern SAT solvers. Following (Krstic et al, 2007) and (Nieuwenhuis et al., 2006), solvers are described using state-transition systems. Several different SAT solver descriptions are given and their partial correctness and termination is proved. These include: <ul> <li> a solver based on classical DPLL procedure (using only a backtrack-search with unit propagation),</li> <li> a very general solver with backjumping and learning (similar to the description given in (Nieuwenhuis et al., 2006)), and</li> <li> a solver with a specific conflict analysis algorithm (similar to the description given in (Krstic et al., 2007)).</li> </ul> Within the SAT solver correctness proofs, a large number of lemmas about propositional logic and CNF formulae are proved. This theory is self-contained and could be used for further exploring of properties of CNF based SAT algorithms.
	notify =

	[Transitive-Closure]
	title = Executable Transitive Closures of Finite Relations
	topic = Computer Science/Algorithms
	date = 2011-03-14
	author = Christian Sternagel <mailto:c.sternagel@gmail.com>, René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	license = LGPL
	abstract = We provide a generic work-list algorithm to compute the transitive closure of finite relations where only successors of newly detected states are generated. This algorithm is then instantiated for lists over arbitrary carriers and red black trees (which are faster but require a linear order on the carrier), respectively. Our formalization was performed as part of the IsaFoR/CeTA project where reflexive transitive closures of large tree automata have to be computed.
	extra-history =
	Change history:
	[2014-09-04] added example simprocs in Finite_Transitive_Closure_Simprocs
	notify = c.sternagel@gmail.com, rene.thiemann@uibk.ac.at

	[Transitive-Closure-II]
	title = Executable Transitive Closures
	topic = Computer Science/Algorithms
	date = 2012-02-29
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	license = LGPL
	abstract =
	<p>
	We provide a generic work-list algorithm to compute the
	(reflexive-)transitive closure of relations where only successors of newly
	detected states are generated.
	In contrast to our previous work, the relations do not have to be finite,
	but each element must only have finitely many (indirect) successors.
	Moreover, a subsumption relation can be used instead of pure equality.
	An executable variant of the algorithm is available where the generic operations
	are instantiated with list operations.
	</p><p>
	This formalization was performed as part of the IsaFoR/CeTA project,
	and it has been used to certify size-change
	termination proofs where large transitive closures have to be computed.
	</p>
	notify = rene.thiemann@uibk.ac.at

	[MuchAdoAboutTwo]
	title = Much Ado About Two
	author = Sascha Böhme <http://www21.in.tum.de/~boehmes/>
	date = 2007-11-06
	topic = Computer Science/Algorithms
	abstract = This article is an Isabelle formalisation of a paper with the same title. In a similar way as Knuth's 0-1-principle for sorting algorithms, that paper develops a 0-1-2-principle for parallel prefix computations.
	notify = boehmes@in.tum.de

	[DiskPaxos]
	title = Proving the Correctness of Disk Paxos
	date = 2005-06-22
	author = Mauro Jaskelioff <http://www.fceia.unr.edu.ar/~mauro/>, Stephan Merz <http://www.loria.fr/~merz>
	topic = Computer Science/Algorithms/Distributed
	abstract = Disk Paxos is an algorithm for building arbitrary fault-tolerant distributed systems. The specification of Disk Paxos has been proved correct informally and tested using the TLC model checker, but up to now, it has never been fully formally verified. In this work we have formally verified its correctness using the Isabelle theorem prover and the HOL logic system, showing that Isabelle is a practical tool for verifying properties of TLA+ specifications.
	notify = kleing@cse.unsw.edu.au

	[GenClock]
	title = Formalization of a Generalized Protocol for Clock Synchronization
	author = Alwen Tiu <http://users.cecs.anu.edu.au/~tiu/>
	date = 2005-06-24
	topic = Computer Science/Algorithms/Distributed
	abstract = We formalize the generalized Byzantine fault-tolerant clock synchronization protocol of Schneider. This protocol abstracts from particular algorithms or implementations for clock synchronization. This abstraction includes several assumptions on the behaviors of physical clocks and on general properties of concrete algorithms/implementations. Based on these assumptions the correctness of the protocol is proved by Schneider. His proof was later verified by Shankar using the theorem prover EHDM (precursor to PVS). Our formalization in Isabelle/HOL is based on Shankar's formalization.
	notify = kleing@cse.unsw.edu.au

	[ClockSynchInst]
	title = Instances of Schneider's generalized protocol of clock synchronization
	author = Damián Barsotti <http://www.cs.famaf.unc.edu.ar/~damian/>
	date = 2006-03-15
	topic = Computer Science/Algorithms/Distributed
	abstract = F. B. Schneider ("Understanding protocols for Byzantine clock synchronization") generalizes a number of protocols for Byzantine fault-tolerant clock synchronization and presents a uniform proof for their correctness. In Schneider's schema, each processor maintains a local clock by periodically adjusting each value to one computed by a convergence function applied to the readings of all the clocks. Then, correctness of an algorithm, i.e. that the readings of two clocks at any time are within a fixed bound of each other, is based upon some conditions on the convergence function. To prove that a particular clock synchronization algorithm is correct it suffices to show that the convergence function used by the algorithm meets Schneider's conditions. Using the theorem prover Isabelle, we formalize the proofs that the convergence functions of two algorithms, namely, the Interactive Convergence Algorithm (ICA) of Lamport and Melliar-Smith and the Fault-tolerant Midpoint algorithm of Lundelius-Lynch, meet Schneider's conditions. Furthermore, we experiment on handling some parts of the proofs with fully automatic tools like ICS and CVC-lite. These theories are part of a joint work with Alwen Tiu and Leonor P. Nieto <a href="http://users.rsise.anu.edu.au/~tiu/clocksync.pdf">"Verification of Clock Synchronization Algorithms: Experiments on a combination of deductive tools"</a> in proceedings of AVOCS 2005. In this work the correctness of Schneider schema was also verified using Isabelle (entry <a href="GenClock.html">GenClock</a> in AFP).
	notify = kleing@cse.unsw.edu.au

	[Heard_Of]
	title = Verifying Fault-Tolerant Distributed Algorithms in the Heard-Of Model
	date = 2012-07-27
	author = Henri Debrat <mailto:henri.debrat@loria.fr>, Stephan Merz <http://www.loria.fr/~merz>
	topic = Computer Science/Algorithms/Distributed
	abstract =
	Distributed computing is inherently based on replication, promising
	increased tolerance to failures of individual computing nodes or
	communication channels. Realizing this promise, however, involves
	quite subtle algorithmic mechanisms, and requires precise statements
	about the kinds and numbers of faults that an algorithm tolerates (such
	as process crashes, communication faults or corrupted values). The
	landmark theorem due to Fischer, Lynch, and Paterson shows that it is
	impossible to achieve Consensus among N asynchronously communicating
	nodes in the presence of even a single permanent failure. Existing
	solutions must rely on assumptions of "partial synchrony".
	<p>
	Indeed, there have been numerous misunderstandings on what exactly a given
	algorithm is supposed to realize in what kinds of environments. Moreover, the
	abundance of subtly different computational models complicates comparisons
	between different algorithms. Charron-Bost and Schiper introduced the Heard-Of
	model for representing algorithms and failure assumptions in a uniform
	framework, simplifying comparisons between algorithms.
	<p>
	In this contribution, we represent the Heard-Of model in Isabelle/HOL. We define
	two semantics of runs of algorithms with different unit of atomicity and relate
	these through a reduction theorem that allows us to verify algorithms in the
	coarse-grained semantics (where proofs are easier) and infer their correctness
	for the fine-grained one (which corresponds to actual executions). We
	instantiate the framework by verifying six Consensus algorithms that differ in
	the underlying algorithmic mechanisms and the kinds of faults they tolerate.
	notify = Stephan.Merz@loria.fr

	[Consensus_Refined]
	title = Consensus Refined
	date = 2015-03-18
	author = Ognjen Maric <>, Christoph Sprenger <mailto:sprenger@inf.ethz.ch>
	topic = Computer Science/Algorithms/Distributed
	abstract =
	Algorithms for solving the consensus problem are fundamental to
	distributed computing. Despite their brevity, their
	ability to operate in concurrent, asynchronous and failure-prone
	environments comes at the cost of complex and subtle
	behaviors. Accordingly, understanding how they work and proving
	their correctness is a non-trivial endeavor where abstraction
	is immensely helpful.
	Moreover, research on consensus has yielded a large number of
	algorithms, many of which appear to share common algorithmic
	ideas. A natural question is whether and how these similarities can
	be distilled and described in a precise, unified way.
	In this work, we combine stepwise refinement and
	lockstep models to provide an abstract and unified
	view of a sizeable family of consensus algorithms. Our models
	provide insights into the design choices underlying the different
	algorithms, and classify them based on those choices.
	notify = sprenger@inf.ethz.ch

	[Key_Agreement_Strong_Adversaries]
	title = Refining Authenticated Key Agreement with Strong Adversaries
	author = Joseph Lallemand <mailto:joseph.lallemand@loria.fr>, Christoph Sprenger <mailto:sprenger@inf.ethz.ch>
	topic = Computer Science/Security
	license = LGPL
	date = 2017-01-31
	notify = joseph.lallemand@loria.fr, sprenger@inf.ethz.ch
	abstract =
	We develop a family of key agreement protocols that are correct by
	construction. Our work substantially extends prior work on developing
	security protocols by refinement. First, we strengthen the adversary
	by allowing him to compromise different resources of protocol
	participants, such as their long-term keys or their session keys. This
	enables the systematic development of protocols that ensure strong
	properties such as perfect forward secrecy. Second, we broaden the
	class of protocols supported to include those with non-atomic keys and
	equationally defined cryptographic operators. We use these extensions
	to develop key agreement protocols including signed Diffie-Hellman and
	the core of IKEv1 and SKEME.

	[Security_Protocol_Refinement]
	title = Developing Security Protocols by Refinement
	author = Christoph Sprenger <mailto:sprenger@inf.ethz.ch>, Ivano Somaini<>
	topic = Computer Science/Security
	license = LGPL
	date = 2017-05-24
	notify = sprenger@inf.ethz.ch
	abstract =
	We propose a development method for security protocols based on
	stepwise refinement. Our refinement strategy transforms abstract
	security goals into protocols that are secure when operating over an
	insecure channel controlled by a Dolev-Yao-style intruder. As
	intermediate levels of abstraction, we employ messageless guard
	protocols and channel protocols communicating over channels with
	security properties. These abstractions provide insights on why
	protocols are secure and foster the development of families of
	protocols sharing common structure and properties. We have implemented
	our method in Isabelle/HOL and used it to develop different entity
	authentication and key establishment protocols, including realistic
	features such as key confirmation, replay caches, and encrypted
	tickets. Our development highlights that guard protocols and channel
	protocols provide fundamental abstractions for bridging the gap
	between security properties and standard protocol descriptions based
	on cryptographic messages. It also shows that our refinement approach
	scales to protocols of nontrivial size and complexity.

	[Abortable_Linearizable_Modules]
	title = Abortable Linearizable Modules
	author = Rachid Guerraoui <mailto:rachid.guerraoui@epfl.ch>, Viktor Kuncak <http://lara.epfl.ch/~kuncak/>, Giuliano Losa <mailto:giuliano.losa@epfl.ch>
	date = 2012-03-01
	topic = Computer Science/Algorithms/Distributed
	abstract =
	We define the Abortable Linearizable Module automaton (ALM for short)
	and prove its key composition property using the IOA theory of
	HOLCF. The ALM is at the heart of the Speculative Linearizability
	framework. This framework simplifies devising correct speculative
	algorithms by enabling their decomposition into independent modules
	that can be analyzed and proved correct in isolation. It is
	particularly useful when working in a distributed environment, where
	the need to tolerate faults and asynchrony has made current
	monolithic protocols so intricate that it is no longer tractable to
	check their correctness. Our theory contains a typical example of a
	refinement proof in the I/O-automata framework of Lynch and Tuttle.
	notify = giuliano@losa.fr, nipkow@in.tum.de

	[Amortized_Complexity]
	title = Amortized Complexity Verified
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2014-07-07
	topic = Computer Science/Data Structures
	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.
	<p>
	A preliminary version of this work (without pairing heaps) is described
	in a <a href="http://www21.in.tum.de/~nipkow/pubs/itp15.html">paper</a>
	published in the proceedings of the conference on Interactive
	Theorem Proving ITP 2015. An extended version of this publication
	is available <a href="http://www21.in.tum.de/~nipkow/pubs/jfp16.html">here</a>.
	extra-history =
	Change history:
	[2015-03-17]: Added pairing heaps by Hauke Brinkop.<br>
	[2016-07-12]: Moved splay heaps from here to Splay_Tree<br>
	[2016-07-14]: Moved pairing heaps from here to the new Pairing_Heap
	notify = nipkow@in.tum.de

	[Dynamic_Tables]
	title = Parameterized Dynamic Tables
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2015-06-07
	topic = Computer Science/Data Structures
	abstract =
	This article formalizes the amortized analysis of dynamic tables
	parameterized with their minimal and maximal load factors and the
	expansion and contraction factors.
	<P>
	A full description is found in a
	<a href="http://www21.in.tum.de/~nipkow/pubs">companion paper</a>.
	notify = nipkow@in.tum.de

	[AVL-Trees]
	title = AVL Trees
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>, Cornelia Pusch <>
	date = 2004-03-19
	topic = Computer Science/Data Structures
	abstract = Two formalizations of AVL trees with room for extensions. The first formalization is monolithic and shorter, the second one in two stages, longer and a bit simpler. The final implementation is the same. If you are interested in developing this further, please contact <tt>gerwin.klein@nicta.com.au</tt>.
	extra-history =
	Change history:
	[2011-04-11]: Ondrej Kuncar added delete function
	notify = kleing@cse.unsw.edu.au

	[BDD]
	title = BDD Normalisation
	author = Veronika Ortner <>, Norbert Schirmer <>
	date = 2008-02-29
	topic = Computer Science/Data Structures
	abstract = We present the verification of the normalisation of a binary decision diagram (BDD). The normalisation follows the original algorithm presented by Bryant in 1986 and transforms an ordered BDD in a reduced, ordered and shared BDD. The verification is based on Hoare logics.
	notify = kleing@cse.unsw.edu.au, norbert.schirmer@web.de

	[BinarySearchTree]
	title = Binary Search Trees
	author = Viktor Kuncak <http://lara.epfl.ch/~kuncak/>
	date = 2004-04-05
	topic = Computer Science/Data Structures
	abstract = The correctness is shown of binary search tree operations (lookup, insert and remove) implementing a set. Two versions are given, for both structured and linear (tactic-style) proofs. An implementation of integer-indexed maps is also verified.
	notify = lp15@cam.ac.uk

	[Splay_Tree]
	title = Splay Tree
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	notify = nipkow@in.tum.de
	date = 2014-08-12
	topic = Computer Science/Data Structures
	abstract =
	Splay trees are self-adjusting binary search trees which were invented by Sleator and Tarjan [JACM 1985].
	This entry provides executable and verified functional splay trees
	as well as the related splay heaps (due to Okasaki).
	<p>
	The amortized complexity of splay trees and heaps is analyzed in the AFP entry
	<a href="http://isa-afp.org/entries/Amortized_Complexity.html">Amortized Complexity</a>.
	extra-history =
	Change history:
	[2016-07-12]: Moved splay heaps here from Amortized_Complexity

	[Root_Balanced_Tree]
	title = Root-Balanced Tree
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	notify = nipkow@in.tum.de
	date = 2017-08-20
	topic = Computer Science/Data Structures
	abstract =
	<p>
	Andersson introduced <em>general balanced trees</em>,
	search trees based on the design principle of partial rebuilding:
	perform update operations naively until the tree becomes too
	unbalanced, at which point a whole subtree is rebalanced. This article
	defines and analyzes a functional version of general balanced trees,
	which we call <em>root-balanced trees</em>. Using a lightweight model
	of execution time, amortized logarithmic complexity is verified in
	the theorem prover Isabelle.
	</p>
	<p>
	This is the Isabelle formalization of the material decribed in the APLAS 2017 article
	<a href="http://www21.in.tum.de/~nipkow/pubs/aplas17.html">Verified Root-Balanced Trees</a>
	by the same author, which also presents experimental results that show
	competitiveness of root-balanced with AVL and red-black trees.
	</p>

	[Skew_Heap]
	title = Skew Heap
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2014-08-13
	topic = Computer Science/Data Structures
	abstract =
	Skew heaps are an amazingly simple and lightweight implementation of
	priority queues. They were invented by Sleator and Tarjan [SIAM 1986]
	and have logarithmic amortized complexity. This entry provides executable
	and verified functional skew heaps.
	<p>
	The amortized complexity of skew heaps is analyzed in the AFP entry
	<a href="http://isa-afp.org/entries/Amortized_Complexity.html">Amortized Complexity</a>.
	notify = nipkow@in.tum.de

	[Pairing_Heap]
	title = Pairing Heap
	author = Hauke Brinkop <mailto:hauke.brinkop@googlemail.com>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2016-07-14
	topic = Computer Science/Data Structures
	abstract =
	This library defines three different versions of pairing heaps: a
	functional version of the original design based on binary
	trees [Fredman et al. 1986], the version by Okasaki [1998] and
	a modified version of the latter that is free of structural invariants.
	<p>
	The amortized complexity of pairing heaps is analyzed in the AFP article
	<a href="http://isa-afp.org/entries/Amortized_Complexity.html">Amortized Complexity</a>.
	extra-0 = Origin: This library was extracted from Amortized Complexity and extended.
	notify = nipkow@in.tum.de

	[Priority_Queue_Braun]
	title = Priority Queues Based on Braun Trees
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2014-09-04
	topic = Computer Science/Data Structures
	abstract =
	This theory implements priority queues via Braun trees. Insertion
	and deletion take logarithmic time and preserve the balanced nature
	of Braun trees.
	notify = nipkow@in.tum.de

	[Binomial-Queues]
	title = Functional Binomial Queues
	author = René Neumann <mailto:neumannr@in.tum.de>
	date = 2010-10-28
	topic = Computer Science/Data Structures
	abstract = Priority queues are an important data structure and efficient implementations of them are crucial. We implement a functional variant of binomial queues in Isabelle/HOL and show its functional correctness. A verification against an abstract reference specification of priority queues has also been attempted, but could not be achieved to the full extent.
	notify = florian.haftmann@informatik.tu-muenchen.de, rene.neumann@informatik.tu-muenchen.de

	[Binomial-Heaps]
	title = Binomial Heaps and Skew Binomial Heaps
	author = Rene Meis <mailto:rene.meis@uni-muenster.de>, Finn Nielsen <mailto:finn.nielsen@uni-muenster.de>, Peter Lammich <http://www21.in.tum.de/~lammich>
	date = 2010-10-28
	topic = Computer Science/Data Structures
	abstract =
	We implement and prove correct binomial heaps and skew binomial heaps.
	Both are data-structures for priority queues.
	While binomial heaps have logarithmic <em>findMin</em>, <em>deleteMin</em>,
	<em>insert</em>, and <em>meld</em> operations,
	skew binomial heaps have constant time <em>findMin</em>, <em>insert</em>,
	and <em>meld</em> operations, and only the <em>deleteMin</em>-operation is
	logarithmic. This is achieved by using <em>skew links</em> to avoid
	cascading linking on <em>insert</em>-operations, and <em>data-structural
	bootstrapping</em> to get constant-time <em>findMin</em> and <em>meld</em>
	operations. Our implementation follows the paper by Brodal and Okasaki.
	notify = peter.lammich@uni-muenster.de

	[Finger-Trees]
	title = Finger Trees
	author = Benedikt Nordhoff <mailto:b_nord01@uni-muenster.de>, Stefan Körner <mailto:s_koer03@uni-muenster.de>, Peter Lammich <http://www21.in.tum.de/~lammich>
	date = 2010-10-28
	topic = Computer Science/Data Structures
	abstract =
	We implement and prove correct 2-3 finger trees.
	Finger trees are a general purpose data structure, that can be used to
	efficiently implement other data structures, such as priority queues.
	Intuitively, a finger tree is an annotated sequence, where the annotations are
	elements of a monoid. Apart from operations to access the ends of the sequence,
	the main operation is to split the sequence at the point where a
	<em>monotone predicate</em> over the sum of the left part of the sequence
	becomes true for the first time.
	The implementation follows the paper of Hinze and Paterson.
	The code generator can be used to get efficient, verified code.
	notify = peter.lammich@uni-muenster.de

	[Trie]
	title = Trie
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2015-03-30
	topic = Computer Science/Data Structures
	abstract =
	This article formalizes the ``trie'' data structure invented by
	Fredkin [CACM 1960]. It also provides a specialization where the entries
	in the trie are lists.
	extra-0 =
	Origin: This article was extracted from existing articles by the authors.
	notify = nipkow@in.tum.de

	[FinFun]
	title = Code Generation for Functions as Data
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>
	date = 2009-05-06
	topic = Computer Science/Data Structures
	abstract = FinFuns are total functions that are constant except for a finite set of points, i.e. a generalisation of finite maps. They are formalised as a new type in Isabelle/HOL such that the code generator can handle equality tests and quantification on FinFuns. On the code output level, FinFuns are explicitly represented by constant functions and pointwise updates, similarly to associative lists. Inside the logic, they behave like ordinary functions with extensionality. Via the update/constant pattern, a recursion combinator and an induction rule for FinFuns allow for defining and reasoning about operators on FinFun that are also executable.
	extra-history =
	Change history:
	[2010-08-13]:
	new concept domain of a FinFun as a FinFun
	(revision 34b3517cbc09)<br>
	[2010-11-04]:
	new conversion function from FinFun to list of elements in the domain
	(revision 0c167102e6ed)<br>
	[2012-03-07]:
	replace sets as FinFuns by predicates as FinFuns because the set type constructor has been reintroduced
	(revision b7aa87989f3a)
	notify = nipkow@in.tum.de

	[Collections]
	title = Collections Framework
	author = Peter Lammich <http://www21.in.tum.de/~lammich>
	contributors = Andreas Lochbihler <http://www.andreas-lochbihler.de>, Thomas Tuerk <>
	date = 2009-11-25
	topic = Computer Science/Data Structures
	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.
	extra-history =
	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.<br>
	[2010-12-01]: New Interfaces: Priority Queues, Annotated Lists. Implemented by finger trees, (skew) binomial queues.<br>
	[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<br>
	[2012-04-25]: New iterator foundation by Tuerk. Various maintenance changes.<br>
	[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.<br>
	[2013-09]: Added Generic Collection Framework based on Autoref. The GenCF provides: Arbitrary nesting, full integration with Autoref.<br>
	[2014-06]: Maintenace changes to GenCF: Optimized inj_image on list_set. op_set_cart (Cartesian product). big-Union operation. atLeastLessThan - operation ({a..<b})<br>
	notify = lammich@in.tum.de

	[Containers]
	title = Light-weight Containers
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>
	contributors = René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	date = 2013-04-15
	topic = Computer Science/Data Structures
	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.
	<p>
	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.
	extra-history =
	Change history:
	[2013-07-11]: add pretty printing for sets (revision 7f3f52c5f5fa)<br>
	[2013-09-20]:
	provide generators for canonical type class instantiations
	(revision 159f4401f4a8 by René Thiemann)<br>
	[2014-07-08]: add support for going from partial functions to mappings (revision 7a6fc957e8ed)<br>
	[2018-03-05]: add two application examples: depth-first search and 2SAT (revision e5e1a1da2411)
	notify = mail@andreas-lochbihler.de

	[FileRefinement]
	title = File Refinement
	author = Karen Zee <http://www.mit.edu/~kkz/>, Viktor Kuncak <http://lara.epfl.ch/~kuncak/>
	date = 2004-12-09
	topic = Computer Science/Data Structures
	abstract = These theories illustrates the verification of basic file operations (file creation, file read and file write) in the Isabelle theorem prover. We describe a file at two levels of abstraction: an abstract file represented as a resizable array, and a concrete file represented using data blocks.
	notify = kkz@mit.edu

	[Datatype_Order_Generator]
	title = Generating linear orders for datatypes
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	date = 2012-08-07
	topic = Computer Science/Data Structures
	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.
	<p>
	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.
	<p>
	Our formalization was performed as part of the <a href="http://cl-informatik.uibk.ac.at/software/ceta">IsaFoR/CeTA</a> project.
	With our new tactic we could completely remove
	tedious proofs for linear orders of two datatypes.
	<p>
	This development is aimed at datatypes generated by the "old_datatype"
	command.
	notify = rene.thiemann@uibk.ac.at

	[Deriving]
	title = Deriving class instances for datatypes
	author = Christian Sternagel <mailto:c.sternagel@gmail.com>, René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	date = 2015-03-11
	topic = Computer Science/Data Structures
	abstract =
	<p>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.</p>
	<p>We further implemented such automatic methods to derive comparators, linear orders, parametrizable equality functions,
	and hash-functions which are required in the
	Isabelle Collection Framework and the Container Framework.
	Moreover, for the tactic of Blanchette to show that a datatype is countable, we implemented a
	wrapper so that this tactic becomes accessible in our framework. All of the generators are based on
	the infrastructure that is provided by the BNF-based datatype package.</p>
	<p>Our formalization was performed as part of the <a href="http://cl-informatik.uibk.ac.at/software/ceta">IsaFoR/CeTA</a> project.
	With our new tactics we could remove
	several tedious proofs for (conditional) linear orders, and conditional equality operators
	within IsaFoR and the Container Framework.</p>
	notify = rene.thiemann@uibk.ac.at

	[List-Index]
	title = List Index
	date = 2010-02-20
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	topic = Computer Science/Data Structures
	abstract = This theory provides functions for finding the index of an element in a list, by predicate and by value.
	notify = nipkow@in.tum.de

	[List-Infinite]
	title = Infinite Lists
	date = 2011-02-23
	author = David Trachtenherz <>
	topic = Computer Science/Data Structures
	abstract = We introduce a theory of infinite lists in HOL formalized as functions over naturals (folder ListInf, theories ListInf and ListInf_Prefix). It also provides additional results for finite lists (theory ListInf/List2), natural numbers (folder CommonArith, esp. division/modulo, naturals with infinity), sets (folder CommonSet, esp. cutting/truncating sets, traversing sets of naturals).
	notify = nipkow@in.tum.de

	[Matrix]
	title = Executable Matrix Operations on Matrices of Arbitrary Dimensions
	topic = Computer Science/Data Structures
	date = 2010-06-17
	author = Christian Sternagel <http://cl-informatik.uibk.ac.at/~griff>, René Thiemann <http://cl-informatik.uibk.ac.at/~thiemann>
	license = LGPL
	abstract =
	We provide the operations of matrix addition, multiplication,
	transposition, and matrix comparisons as executable functions over
	ordered semirings. Moreover, it is proven that strongly normalizing
	(monotone) orders can be lifted to strongly normalizing (monotone) orders
	over matrices. We further show that the standard semirings over the
	naturals, integers, and rationals, as well as the arctic semirings
	satisfy the axioms that are required by our matrix theory. Our
	formalization is part of the <a
	href="http://cl-informatik.uibk.ac.at/software/ceta">CeTA</a> system
	which contains several termination techniques. The provided theories have
	been essential to formalize matrix-interpretations and arctic
	interpretations.
	extra-history =
	Change history:
	[2010-09-17]: Moved theory on arbitrary (ordered) semirings to Abstract Rewriting.
	notify = rene.thiemann@uibk.ac.at, christian.sternagel@uibk.ac.at

	[Matrix_Tensor]
	title = Tensor Product of Matrices
	topic = Computer Science/Data Structures, Mathematics/Algebra
	date = 2016-01-18
	author = T.V.H. Prathamesh <mailto:prathamesh@imsc.res.in>
	abstract =
	In this work, the Kronecker tensor product of matrices and the proofs of
	some of its properties are formalized. Properties which have been formalized
	include associativity of the tensor product and the mixed-product
	property.
	notify = prathamesh@imsc.res.in

	[Huffman]
	title = The Textbook Proof of Huffman's Algorithm
	author = Jasmin Christian Blanchette <http://www21.in.tum.de/~blanchet>
	date = 2008-10-15
	topic = Computer Science/Data Structures
	abstract = Huffman's algorithm is a procedure for constructing a binary tree with minimum weighted path length. This report presents a formal proof of the correctness of Huffman's algorithm written using Isabelle/HOL. Our proof closely follows the sketches found in standard algorithms textbooks, uncovering a few snags in the process. Another distinguishing feature of our formalization is the use of custom induction rules to help Isabelle's automatic tactics, leading to very short proofs for most of the lemmas.
	notify = jasmin.blanchette@gmail.com

	[Partial_Function_MR]
	title = Mutually Recursive Partial Functions
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	topic = Computer Science/Functional Programming
	date = 2014-02-18
	license = LGPL
	abstract = We provide a wrapper around the partial-function command that supports mutual recursion.
	notify = rene.thiemann@uibk.ac.at

	[Lifting_Definition_Option]
	title = Lifting Definition Option
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	topic = Computer Science/Functional Programming
	date = 2014-10-13
	license = LGPL
	abstract =
	We implemented a command that can be used to easily generate
	elements of a restricted type <tt>{x :: 'a. P x}</tt>,
	provided the definition is of the form
	<tt>f ys = (if check ys then Some(generate ys :: 'a) else None)</tt> where
	<tt>ys</tt> is a list of variables <tt>y1 ... yn</tt> and
	<tt>check ys ==> P(generate ys)</tt> can be proved.
	<p>
	In principle, such a definition is also directly possible using the
	<tt>lift_definition</tt> command. However, then this definition will not be
	suitable for code-generation. To this end, we automated a more complex
	construction of Joachim Breitner which is amenable for code-generation, and
	where the test <tt>check ys</tt> will only be performed once. In the
	automation, one auxiliary type is created, and Isabelle's lifting- and
	transfer-package is invoked several times.
	notify = rene.thiemann@uibk.ac.at

	[Coinductive]
	title = Coinductive
	topic = Computer Science/Functional Programming
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>
	contributors = Johannes Hölzl <mailto:hoelzl@in.tum.de>
	date = 2010-02-12
	abstract = This article collects formalisations of general-purpose coinductive data types and sets. Currently, it contains coinductive natural numbers, coinductive lists, i.e. lazy lists or streams, infinite streams, coinductive terminated lists, coinductive resumptions, a library of operations on coinductive lists, and a version of König's lemma as an application for coinductive lists.<br>The initial theory was contributed by Paulson and Wenzel. Extensions and other coinductive formalisations of general interest are welcome.
	extra-history =
	Change history:
	[2010-06-10]:
	coinductive lists: setup for quotient package
	(revision 015574f3bf3c)<br>
	[2010-06-28]:
	new codatatype terminated lazy lists
	(revision e12de475c558)<br>
	[2010-08-04]:
	terminated lazy lists: setup for quotient package;
	more lemmas
	(revision 6ead626f1d01)<br>
	[2010-08-17]:
	Koenig's lemma as an example application for coinductive lists
	(revision f81ce373fa96)<br>
	[2011-02-01]:
	lazy implementation of coinductive (terminated) lists for the code generator
	(revision 6034973dce83)<br>
	[2011-07-20]:
	new codatatype resumption
	(revision 811364c776c7)<br>
	[2012-06-27]:
	new codatatype stream with operations (with contributions by Peter Gammie)
	(revision dd789a56473c)<br>
	[2013-03-13]:
	construct codatatypes with the BNF package and adjust the definitions and proofs,
	setup for lifting and transfer packages
	(revision f593eda5b2c0)<br>
	[2013-09-20]:
	stream theory uses type and operations from HOL/BNF/Examples/Stream
	(revision 692809b2b262)<br>
	[2014-04-03]:
	ccpo structure on codatatypes used to define ldrop, ldropWhile, lfilter, lconcat as least fixpoint;
	ccpo topology on coinductive lists contributed by Johannes Hölzl;
	added examples
	(revision 23cd8156bd42)<br>
	notify = mail@andreas-lochbihler.de

	[Stream-Fusion]
	title = Stream Fusion
	author = Brian Huffman <http://cs.pdx.edu/~brianh>
	topic = Computer Science/Functional Programming
	date = 2009-04-29
	abstract = Stream Fusion is a system for removing intermediate list structures from Haskell programs; it consists of a Haskell library along with several compiler rewrite rules. (The library is available <a href="http://hackage.haskell.org/package/stream-fusion">online</a>.)<br><br>These theories contain a formalization of much of the Stream Fusion library in HOLCF. Lazy list and stream types are defined, along with coercions between the two types, as well as an equivalence relation for streams that generate the same list. List and stream versions of map, filter, foldr, enumFromTo, append, zipWith, and concatMap are defined, and the stream versions are shown to respect stream equivalence.
	notify = brianh@cs.pdx.edu

	[Tycon]
	title = Type Constructor Classes and Monad Transformers
	author = Brian Huffman <mailto:huffman@in.tum.de>
	date = 2012-06-26
	topic = Computer Science/Functional Programming
	abstract =
	These theories contain a formalization of first class type constructors
	and axiomatic constructor classes for HOLCF. This work is described
	in detail in the ICFP 2012 paper <i>Formal Verification of Monad
	Transformers</i> by the author. The formalization is a revised and
	updated version of earlier joint work with Matthews and White.
	<P>
	Based on the hierarchy of type classes in Haskell, we define classes
	for functors, monads, monad-plus, etc. Each one includes all the
	standard laws as axioms. We also provide a new user command,
	tycondef, for defining new type constructors in HOLCF. Using tycondef,
	we instantiate the type class hierarchy with various monads and monad
	transformers.
	notify = huffman@in.tum.de

	[CoreC++]
	title = CoreC++
	author = Daniel Wasserrab <http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php>
	date = 2006-05-15
	topic = Computer Science/Programming Languages/Language Definitions
	abstract = We present an operational semantics and type safety proof for multiple inheritance in C++. The semantics models the behavior of method calls, field accesses, and two forms of casts in C++ class hierarchies. For explanations see the OOPSLA 2006 paper by Wasserrab, Nipkow, Snelting and Tip.
	notify = nipkow@in.tum.de

	[FeatherweightJava]
	title = A Theory of Featherweight Java in Isabelle/HOL
	author = J. Nathan Foster <http://www.cs.cornell.edu/~jnfoster/>, Dimitrios Vytiniotis <http://research.microsoft.com/en-us/people/dimitris/>
	date = 2006-03-31
	topic = Computer Science/Programming Languages/Language Definitions
	abstract = We formalize the type system, small-step operational semantics, and type soundness proof for Featherweight Java, a simple object calculus, in Isabelle/HOL.
	notify = kleing@cse.unsw.edu.au

	[Jinja]
	title = Jinja is not Java
	author = Gerwin Klein <http://www.cse.unsw.edu.au/~kleing/>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2005-06-01
	topic = Computer Science/Programming Languages/Language Definitions
	abstract = We introduce Jinja, a Java-like programming language with a formal semantics designed to exhibit core features of the Java language architecture. Jinja is a compromise between realism of the language and tractability and clarity of the formal semantics. The following aspects are formalised: a big and a small step operational semantics for Jinja and a proof of their equivalence; a type system and a definite initialisation analysis; a type safety proof of the small step semantics; a virtual machine (JVM), its operational semantics and its type system; a type safety proof for the JVM; a bytecode verifier, i.e. data flow analyser for the JVM; a correctness proof of the bytecode verifier w.r.t. the type system; a compiler and a proof that it preserves semantics and well-typedness. The emphasis of this work is not on particular language features but on providing a unified model of the source language, the virtual machine and the compiler. The whole development has been carried out in the theorem prover Isabelle/HOL.
	notify = kleing@cse.unsw.edu.au, nipkow@in.tum.de

	[JinjaThreads]
	title = Jinja with Threads
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>
	date = 2007-12-03
	topic = Computer Science/Programming Languages/Language Definitions
	abstract = We extend the Jinja source code semantics by Klein and Nipkow with Java-style arrays and threads. Concurrency is captured in a generic framework semantics for adding concurrency through interleaving to a sequential semantics, which features dynamic thread creation, inter-thread communication via shared memory, lock synchronisation and joins. Also, threads can suspend themselves and be notified by others. We instantiate the framework with the adapted versions of both Jinja source and byte code and show type safety for the multithreaded case. Equally, the compiler from source to byte code is extended, for which we prove weak bisimilarity between the source code small step semantics and the defensive Jinja virtual machine. On top of this, we formalise the JMM and show the DRF guarantee and consistency. For description of the different parts, see Lochbihler's papers at FOOL 2008, ESOP 2010, ITP 2011, and ESOP 2012.
	extra-history =
	Change history:
	[2008-04-23]:
	added bytecode formalisation with arrays and threads, added thread joins
	(revision f74a8be156a7)<br>
	[2009-04-27]:
	added verified compiler from source code to bytecode;
	encapsulate native methods in separate semantics
	(revision e4f26541e58a)<br>
	[2009-11-30]:
	extended compiler correctness proof to infinite and deadlocking computations
	(revision e50282397435)<br>
	[2010-06-08]:
	added thread interruption;
	new abstract memory model with sequential consistency as implementation
	(revision 0cb9e8dbd78d)<br>
	[2010-06-28]:
	new thread interruption model
	(revision c0440d0a1177)<br>
	[2010-10-15]:
	preliminary version of the Java memory model for source code
	(revision 02fee0ef3ca2)<br>
	[2010-12-16]:
	improved version of the Java memory model, also for bytecode
	executable scheduler for source code semantics
	(revision 1f41c1842f5a)<br>
	[2011-02-02]:
	simplified code generator setup
	new random scheduler
	(revision 3059dafd013f)<br>
	[2011-07-21]:
	new interruption model,
	generalized JMM proof of DRF guarantee,
	allow class Object to declare methods and fields,
	simplified subtyping relation,
	corrected division and modulo implementation
	(revision 46e4181ed142)<br>
	[2012-02-16]:
	added example programs
	(revision bf0b06c8913d)<br>
	[2012-11-21]:
	type safety proof for the Java memory model,
	allow spurious wake-ups
	(revision 76063d860ae0)<br>
	[2013-05-16]:
	support for non-deterministic memory allocators
	(revision cc3344a49ced)<br>
	[2017-10-20]:
	add an atomic compare-and-swap operation for volatile fields
	(revision a6189b1d6b30)<br>
	notify = mail@andreas-lochbihler.de

	[Locally-Nameless-Sigma]
	title = Locally Nameless Sigma Calculus
	author = Ludovic Henrio <mailto:Ludovic.Henrio@sophia.inria.fr>, Florian Kammüller <mailto:flokam@cs.tu-berlin.de>, Bianca Lutz <mailto:sowilo@cs.tu-berlin.de>, Henry Sudhof <mailto:hsudhof@cs.tu-berlin.de>
	date = 2010-04-30
	topic = Computer Science/Programming Languages/Language Definitions
	abstract = We present a Theory of Objects based on the original functional sigma-calculus by Abadi and Cardelli but with an additional parameter to methods. We prove confluence of the operational semantics following the outline of Nipkow's proof of confluence for the lambda-calculus reusing his theory Commutation, a generic diamond lemma reduction. We furthermore formalize a simple type system for our sigma-calculus including a proof of type safety. The entire development uses the concept of Locally Nameless representation for binders. We reuse an earlier proof of confluence for a simpler sigma-calculus based on de Bruijn indices and lists to represent objects.
	notify = nipkow@in.tum.de

	[AutoFocus-Stream]
	title = AutoFocus Stream Processing for Single-Clocking and Multi-Clocking Semantics
	author = David Trachtenherz <>
	date = 2011-02-23
	topic = Computer Science/Programming Languages/Language Definitions
	abstract = We formalize the AutoFocus Semantics (a time-synchronous subset of the Focus formalism) as stream processing functions on finite and infinite message streams represented as finite/infinite lists. The formalization comprises both the conventional single-clocking semantics (uniform global clock for all components and communications channels) and its extension to multi-clocking semantics (internal execution clocking of a component may be a multiple of the external communication clocking). The semantics is defined by generic stream processing functions making it suitable for simulation/code generation in Isabelle/HOL. Furthermore, a number of AutoFocus semantics properties are formalized using definitions from the IntervalLogic theories.
	notify = nipkow@in.tum.de

	[FocusStreamsCaseStudies]
	title = Stream Processing Components: Isabelle/HOL Formalisation and Case Studies
	author = Maria Spichkova <mailto:maria.spichkova@rmit.edu.au>
	date = 2013-11-14
	topic = Computer Science/Programming Languages/Language Definitions
	abstract = This set of theories presents an Isabelle/HOL formalisation of stream processing components introduced
	in Focus,
	a framework for formal specification and development of interactive systems.
	This is an extended and updated version of the formalisation, which was
	elaborated within the methodology "Focus on Isabelle".
	In addition, we also applied the formalisation on three case studies
	that cover different application areas: process control (Steam Boiler System),
	data transmission (FlexRay communication protocol),
	memory and processing components (Automotive-Gateway System).
	notify = lp15@cam.ac.uk, maria.spichkova@rmit.edu.au

	[Isabelle_Meta_Model]
	title = A Meta-Model for the Isabelle API
	author = Frédéric Tuong <mailto:tuong@users.gforge.inria.fr>, Burkhart Wolff <https://www.lri.fr/~wolff/>
	date = 2015-09-16
	topic = Computer Science/Programming Languages/Language Definitions
	abstract =
	We represent a theory <i>of</i> (a fragment of) Isabelle/HOL <i>in</i>
	Isabelle/HOL. The purpose of this exercise is to write packages for
	domain-specific specifications such as class models, B-machines, ...,
	and generally speaking, any domain-specific languages whose
	abstract syntax can be defined by a HOL "datatype". On this basis, the
	Isabelle code-generator can then be used to generate code for global
	context transformations as well as tactic code.
	<p>
	Consequently the package is geared towards
	parsing, printing and code-generation to the Isabelle API.
	It is at the moment not sufficiently rich for doing meta theory on
	Isabelle itself. Extensions in this direction are possible though.
	<p>
	Moreover, the chosen fragment is fairly rudimentary. However it should be
	easily adapted to one's needs if a package is written on top of it.
	The supported API contains types, terms, transformation of
	global context like definitions and data-type declarations as well
	as infrastructure for Isar-setups.
	<p>
	This theory is drawn from the
	<a href="http://isa-afp.org/entries/Featherweight_OCL.html">Featherweight OCL</a>
	project where
	it is used to construct a package for object-oriented data-type theories
	generated from UML class diagrams. The Featherweight OCL, for example, allows for
	both the direct execution of compiled tactic code by the Isabelle API
	as well as the generation of ".thy"-files for debugging purposes.
	<p>
	Gained experience from this project shows that the compiled code is sufficiently
	efficient for practical purposes while being based on a formal <i>model</i>
	on which properties of the package can be proven such as termination of certain
	transformations, correctness, etc.
	notify = tuong@users.gforge.inria.fr, wolff@lri.fr

	[PCF]
	title = Logical Relations for PCF
	author = Peter Gammie <mailto:peteg42@gmail.com>
	date = 2012-07-01
	topic = Computer Science/Programming Languages/Lambda Calculi
	abstract = We apply Andy Pitts's methods of defining relations over domains to
	several classical results in the literature. We show that the Y
	combinator coincides with the domain-theoretic fixpoint operator,
	that parallel-or and the Plotkin existential are not definable in
	PCF, that the continuation semantics for PCF coincides with the
	direct semantics, and that our domain-theoretic semantics for PCF is
	adequate for reasoning about contextual equivalence in an
	operational semantics. Our version of PCF is untyped and has both
	strict and non-strict function abstractions. The development is
	carried out in HOLCF.
	notify = peteg42@gmail.com

	[POPLmark-deBruijn]
	title = POPLmark Challenge Via de Bruijn Indices
	author = Stefan Berghofer <http://www.in.tum.de/~berghofe>
	date = 2007-08-02
	topic = Computer Science/Programming Languages/Lambda Calculi
	abstract = We present a solution to the POPLmark challenge designed by Aydemir et al., which has as a goal the formalization of the meta-theory of System F<sub><:</sub>. The formalization is carried out in the theorem prover Isabelle/HOL using an encoding based on de Bruijn indices. We start with a relatively simple formalization covering only the basic features of System F<sub><:</sub>, and explain how it can be extended to also cover records and more advanced binding constructs.
	notify = berghofe@in.tum.de

	[Lam-ml-Normalization]
	title = Strong Normalization of Moggis's Computational Metalanguage
	author = Christian Doczkal <mailto:doczkal@ps.uni-saarland.de>
	date = 2010-08-29
	topic = Computer Science/Programming Languages/Lambda Calculi
	abstract = Handling variable binding is one of the main difficulties in formal proofs. In this context, Moggi's computational metalanguage serves as an interesting case study. It features monadic types and a commuting conversion rule that rearranges the binding structure. Lindley and Stark have given an elegant proof of strong normalization for this calculus. The key construction in their proof is a notion of relational TT-lifting, using stacks of elimination contexts to obtain a Girard-Tait style logical relation. I give a formalization of their proof in Isabelle/HOL-Nominal with a particular emphasis on the treatment of bound variables.
	notify = doczkal@ps.uni-saarland.de, nipkow@in.tum.de

	[MiniML]
	title = Mini ML
	author = Wolfgang Naraschewski <>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2004-03-19
	topic = Computer Science/Programming Languages/Type Systems
	abstract = This theory defines the type inference rules and the type inference algorithm <i>W</i> for MiniML (simply-typed lambda terms with <tt>let</tt>) due to Milner. It proves the soundness and completeness of <i>W</i> w.r.t. the rules.
	notify = kleing@cse.unsw.edu.au

	[Simpl]
	title = A Sequential Imperative Programming Language Syntax, Semantics, Hoare Logics and Verification Environment
	author = Norbert Schirmer <>
	date = 2008-02-29
	topic = Computer Science/Programming Languages/Language Definitions, Computer Science/Programming Languages/Logics
	license = LGPL
	abstract = We present the theory of Simpl, a sequential imperative programming language. We introduce its syntax, its semantics (big and small-step operational semantics) and Hoare logics for both partial as well as total correctness. We prove soundness and completeness of the Hoare logic. We integrate and automate the Hoare logic in Isabelle/HOL to obtain a practically usable verification environment for imperative programs. Simpl is independent of a concrete programming language but expressive enough to cover all common language features: mutually recursive procedures, abrupt termination and exceptions, runtime faults, local and global variables, pointers and heap, expressions with side effects, pointers to procedures, partial application and closures, dynamic method invocation and also unbounded nondeterminism.
	notify = kleing@cse.unsw.edu.au, norbert.schirmer@web.de

	[Separation_Algebra]
	title = Separation Algebra
	author = Gerwin Klein <mailto:kleing@cse.unsw.edu.au>, Rafal Kolanski <mailto:rafal.kolanski@nicta.com.au>, Andrew Boyton <mailto:andrew.boyton@nicta.com.au>
	date = 2012-05-11
	topic = Computer Science/Programming Languages/Logics
	license = BSD
	abstract = We present a generic type class implementation of separation algebra for Isabelle/HOL as well as lemmas and generic tactics which can be used directly for any instantiation of the type class. <P> The ex directory contains example instantiations that include structures such as a heap or virtual memory. <P> The abstract separation algebra is based upon "Abstract Separation Logic" by Calcagno et al. These theories are also the basis of the ITP 2012 rough diamond "Mechanised Separation Algebra" by the authors. <P> The aim of this work is to support and significantly reduce the effort for future separation logic developments in Isabelle/HOL by factoring out the part of separation logic that can be treated abstractly once and for all. This includes developing typical default rule sets for reasoning as well as automated tactic support for separation logic.
	notify = kleing@cse.unsw.edu.au, rafal.kolanski@nicta.com.au

	[Separation_Logic_Imperative_HOL]
	title = A Separation Logic Framework for Imperative HOL
	author = Peter Lammich <http://www21.in.tum.de/~lammich>, Rene Meis <mailto:rene.meis@uni-due.de>
	date = 2012-11-14
	topic = Computer Science/Programming Languages/Logics
	license = BSD
	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.
	<br>
	As we target Imperative HOL, our programs can be translated to
	efficiently executable code in various target languages, including
	ML, OCaml, Haskell, and Scala.
	notify = lammich@in.tum.de

	[Inductive_Confidentiality]
	title = Inductive Study of Confidentiality
	author = Giampaolo Bella <http://www.dmi.unict.it/~giamp/>
	date = 2012-05-02
	topic = Computer Science/Security
	abstract = This document contains the full theory files accompanying article <i>Inductive Study of Confidentiality --- for Everyone</i> in <i>Formal Aspects of Computing</i>. They aim at an illustrative and didactic presentation of the Inductive Method of protocol analysis, focusing on the treatment of one of the main goals of security protocols: confidentiality against a threat model. The treatment of confidentiality, which in fact forms a key aspect of all protocol analysis tools, has been found cryptic by many learners of the Inductive Method, hence the motivation for this work. The theory files in this document guide the reader step by step towards design and proof of significant confidentiality theorems. These are developed against two threat models, the standard Dolev-Yao and a more audacious one, the General Attacker, which turns out to be particularly useful also for teaching purposes.
	notify = giamp@dmi.unict.it

	[Possibilistic_Noninterference]
	title = Possibilistic Noninterference
	author = Andrei Popescu <mailto:uuomul@yahoo.com>, Johannes Hölzl <mailto:hoelzl@in.tum.de>
	date = 2012-09-10
	topic = Computer Science/Security, Computer Science/Programming Languages/Type Systems
	abstract = We formalize a wide variety of Volpano/Smith-style noninterference
	notions for a while language with parallel composition.
	We systematize and classify these notions according to
	compositionality w.r.t. the language constructs. Compositionality
	yields sound syntactic criteria (a.k.a. type systems) in a uniform way.
	<p>
	An <a href="http://www21.in.tum.de/~nipkow/pubs/cpp12.html">article</a>
	about these proofs is published in the proceedings
	of the conference Certified Programs and Proofs 2012.
	notify = hoelzl@in.tum.de

	[SIFUM_Type_Systems]
	title = A Formalization of Assumptions and Guarantees for Compositional Noninterference
	author = Sylvia Grewe <mailto:grewe@cs.tu-darmstadt.de>, Heiko Mantel <mailto:mantel@mais.informatik.tu-darmstadt.de>, Daniel Schoepe <mailto:daniel@schoepe.org>
	date = 2014-04-23
	topic = Computer Science/Security, Computer Science/Programming Languages/Type Systems
	abstract = Research in information-flow security aims at developing methods to
	identify undesired information leaks within programs from private
	(high) sources to public (low) sinks. For a concurrent system, it is
	desirable to have compositional analysis methods that allow for
	analyzing each thread independently and that nevertheless guarantee
	that the parallel composition of successfully analyzed threads
	satisfies a global security guarantee. However, such a compositional
	analysis should not be overly pessimistic about what an environment
	might do with shared resources. Otherwise, the analysis will reject
	many intuitively secure programs.
	<p>
	The paper "Assumptions and Guarantees for Compositional
	Noninterference" by Mantel et. al. presents one solution for this problem:
	an approach for compositionally reasoning about non-interference in
	concurrent programs via rely-guarantee-style reasoning. We present an
	Isabelle/HOL formalization of the concepts and proofs of this approach.
	notify = grewe@cs.tu-darmstadt.de

	[Dependent_SIFUM_Type_Systems]
	title = A Dependent Security Type System for Concurrent Imperative Programs
	author = Toby Murray <http://people.eng.unimelb.edu.au/tobym/>, Robert Sison<>, Edward Pierzchalski<>, Christine Rizkallah<https://www.mpi-inf.mpg.de/~crizkall/>
	notify = toby.murray@unimelb.edu.au
	date = 2016-06-25
	topic = Computer Science/Security, Computer Science/Programming Languages/Type Systems
	abstract =
	The paper "Compositional Verification and Refinement of Concurrent
	Value-Dependent Noninterference" by Murray et. al. (CSF 2016) presents
	a dependent security type system for compositionally verifying a
	value-dependent noninterference property, defined in (Murray, PLAS
	2015), for concurrent programs. This development formalises that
	security definition, the type system and its soundness proof, and
	demonstrates its application on some small examples. It was derived
	from the SIFUM_Type_Systems AFP entry, by Sylvia Grewe, Heiko Mantel
	and Daniel Schoepe, and whose structure it inherits.
	extra-history =
	Change history:
	[2016-08-19]:
	Removed unused "stop" parameter and "stop_no_eval" assumption from the sifum_security locale.
	(revision dbc482d36372)
	[2016-09-27]:
	Added security locale support for the imposition of requirements on the initial memory.
	(revision cce4ceb74ddb)

	[Dependent_SIFUM_Refinement]
	title = Compositional Security-Preserving Refinement for Concurrent Imperative Programs
	author = Toby Murray <http://people.eng.unimelb.edu.au/tobym/>, Robert Sison<>, Edward Pierzchalski<>, Christine Rizkallah<https://www.mpi-inf.mpg.de/~crizkall/>
	notify = toby.murray@unimelb.edu.au
	date = 2016-06-28
	topic = Computer Science/Security
	abstract =
	The paper "Compositional Verification and Refinement of Concurrent
	Value-Dependent Noninterference" by Murray et. al. (CSF 2016) presents
	a compositional theory of refinement for a value-dependent
	noninterference property, defined in (Murray, PLAS 2015), for
	concurrent programs. This development formalises that refinement
	theory, and demonstrates its application on some small examples.
	extra-history =
	Change history:
	[2016-08-19]:
	Removed unused "stop" parameters from the sifum_refinement locale.
	(revision dbc482d36372)
	[2016-09-02]:
	TobyM extended "simple" refinement theory to be usable for all bisimulations.
	(revision 547f31c25f60)

	[Strong_Security]
	title = A Formalization of Strong Security
	author = Sylvia Grewe <mailto:grewe@cs.tu-darmstadt.de>, Alexander Lux <mailto:lux@mais.informatik.tu-darmstadt.de>, Heiko Mantel <mailto:mantel@mais.informatik.tu-darmstadt.de>, Jens Sauer <mailto:sauer@mais.informatik.tu-darmstadt.de>
	date = 2014-04-23
	topic = Computer Science/Security, Computer Science/Programming Languages/Type Systems
	abstract = Research in information-flow security aims at developing methods to
	identify undesired information leaks within programs from private
	sources to public sinks. Noninterference captures this
	intuition. Strong security from Sabelfeld and Sands
	formalizes noninterference for concurrent systems.
	<p>
	We present an Isabelle/HOL formalization of strong security for
	arbitrary security lattices (Sabelfeld and Sands use
	a two-element security lattice in the original publication).
	The formalization includes
	compositionality proofs for strong security and a soundness proof
	for a security type system that checks strong security for programs
	in a simple while language with dynamic thread creation.
	<p>
	Our formalization of the security type system is abstract in the
	language for expressions and in the semantic side conditions for
	expressions. It can easily be instantiated with different syntactic
	approximations for these side conditions. The soundness proof of
	such an instantiation boils down to showing that these syntactic
	approximations imply the semantic side conditions.
	notify = grewe@cs.tu-darmstadt.de

	[WHATandWHERE_Security]
	title = A Formalization of Declassification with WHAT-and-WHERE-Security
	author = Sylvia Grewe <mailto:grewe@cs.tu-darmstadt.de>, Alexander Lux <mailto:lux@mais.informatik.tu-darmstadt.de>, Heiko Mantel <mailto:mantel@mais.informatik.tu-darmstadt.de>, Jens Sauer <mailto:sauer@mais.informatik.tu-darmstadt.de>
	date = 2014-04-23
	topic = Computer Science/Security, Computer Science/Programming Languages/Type Systems
	abstract = Research in information-flow security aims at developing methods to
	identify undesired information leaks within programs from private
	sources to public sinks. Noninterference captures this intuition by
	requiring that no information whatsoever flows from private sources
	to public sinks. However, in practice this definition is often too
	strict: Depending on the intuitive desired security policy, the
	controlled declassification of certain private information (WHAT) at
	certain points in the program (WHERE) might not result in an
	undesired information leak.
	<p>
	We present an Isabelle/HOL formalization of such a security property
	for controlled declassification, namely WHAT&WHERE-security from
	"Scheduler-Independent Declassification" by Lux, Mantel, and Perner.
	The formalization includes
	compositionality proofs for and a soundness proof for a security
	type system that checks for programs in a simple while language with
	dynamic thread creation.
	<p>
	Our formalization of the security type system is abstract in the
	language for expressions and in the semantic side conditions for
	expressions. It can easily be instantiated with different syntactic
	approximations for these side conditions. The soundness proof of
	such an instantiation boils down to showing that these syntactic
	approximations imply the semantic side conditions.
	<p>
	This Isabelle/HOL formalization uses theories from the entry
	Strong Security.
	notify = grewe@cs.tu-darmstadt.de

	[VolpanoSmith]
	title = A Correctness Proof for the Volpano/Smith Security Typing System
	author = Gregor Snelting <http://pp.info.uni-karlsruhe.de/personhp/gregor_snelting.php>, Daniel Wasserrab <http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php>
	date = 2008-09-02
	topic = Computer Science/Programming Languages/Type Systems, Computer Science/Security
	abstract = The Volpano/Smith/Irvine security type systems requires that variables are annotated as high (secret) or low (public), and provides typing rules which guarantee that secret values cannot leak to public output ports. This property of a program is called confidentiality. For a simple while-language without threads, our proof shows that typeability in the Volpano/Smith system guarantees noninterference. Noninterference means that if two initial states for program execution are low-equivalent, then the final states are low-equivalent as well. This indeed implies that secret values cannot leak to public ports. The proof defines an abstract syntax and operational semantics for programs, formalizes noninterference, and then proceeds by rule induction on the operational semantics. The mathematically most intricate part is the treatment of implicit flows. Note that the Volpano/Smith system is not flow-sensitive and thus quite unprecise, resulting in false alarms. However, due to the correctness property, all potential breaks of confidentiality are discovered.
	notify =

	[Abstract-Hoare-Logics]
	title = Abstract Hoare Logics
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2006-08-08
	topic = Computer Science/Programming Languages/Logics
	abstract = These therories describe Hoare logics for a number of imperative language constructs, from while-loops to mutually recursive procedures. Both partial and total correctness are treated. In particular a proof system for total correctness of recursive procedures in the presence of unbounded nondeterminism is presented.
	notify = nipkow@in.tum.de

	[Stone_Algebras]
	title = Stone Algebras
	author = Walter Guttmann <http://www.cosc.canterbury.ac.nz/walter.guttmann/>
	notify = walter.guttmann@canterbury.ac.nz
	date = 2016-09-06
	topic = Mathematics/Algebra
	abstract =
	A range of algebras between lattices and Boolean algebras generalise
	the notion of a complement. We develop a hierarchy of these
	pseudo-complemented algebras that includes Stone algebras.
	Independently of this theory we study filters based on partial orders.
	Both theories are combined to prove Chen and Grätzer's construction
	theorem for Stone algebras. The latter involves extensive reasoning
	about algebraic structures in addition to reasoning in algebraic
	structures.

	[Kleene_Algebra]
	title = Kleene Algebra
	author = Alasdair Armstrong <>, Georg Struth <http://staffwww.dcs.shef.ac.uk/people/G.Struth/>, Tjark Weber <http://user.it.uu.se/~tjawe125/>
	date = 2013-01-15
	topic = Computer Science/Programming Languages/Logics, Computer Science/Automata and Formal Languages, Mathematics/Algebra
	abstract =
	These files contain a formalisation of variants of Kleene algebras and
	their most important models as axiomatic type classes in Isabelle/HOL.
	Kleene algebras are foundational structures in computing with
	applications ranging from automata and language theory to computational
	modeling, program construction and verification.
	<p>
	We start with formalising dioids, which are additively idempotent
	semirings, and expand them by axiomatisations of the Kleene star for
	finite iteration and an omega operation for infinite iteration. We
	show that powersets over a given monoid, (regular) languages, sets of
	paths in a graph, sets of computation traces, binary relations and
	formal power series form Kleene algebras, and consider further models
	based on lattices, max-plus semirings and min-plus semirings. We also
	demonstrate that dioids are closed under the formation of matrices
	(proofs for Kleene algebras remain to be completed).
	<p>
	On the one hand we have aimed at a reference formalisation of variants
	of Kleene algebras that covers a wide range of variants and the core
	theorems in a structured and modular way and provides readable proofs
	at text book level. On the other hand, we intend to use this algebraic
	hierarchy and its models as a generic algebraic middle-layer from which
	programming applications can quickly be explored, implemented and verified.
	notify = g.struth@sheffield.ac.uk, tjark.weber@it.uu.se

	[KAT_and_DRA]
	title = Kleene Algebra with Tests and Demonic Refinement Algebras
	author = Alasdair Armstrong <>, Victor B. F. Gomes <http://www.dcs.shef.ac.uk/~victor>, Georg Struth <http://www.dcs.shef.ac.uk/~georg>
	date = 2014-01-23
	topic = Computer Science/Programming Languages/Logics, Computer Science/Automata and Formal Languages, Mathematics/Algebra
	abstract =
	We formalise Kleene algebra with tests (KAT) and demonic refinement
	algebra (DRA) in Isabelle/HOL. KAT is relevant for program verification
	and correctness proofs in the partial correctness setting. While DRA
	targets similar applications in the context of total correctness. Our
	formalisation contains the two most important models of these algebras:
	binary relations in the case of KAT and predicate transformers in the
	case of DRA. In addition, we derive the inference rules for Hoare logic
	in KAT and its relational model and present a simple formally verified
	program verification tool prototype based on the algebraic approach.
	notify = g.struth@dcs.shef.ac.uk

	[KAD]
	title = Kleene Algebras with Domain
	author = Victor B. F. Gomes <http://www.dcs.shef.ac.uk/~victor>, Walter Guttmann <http://www.cosc.canterbury.ac.nz/walter.guttmann/>, Peter Höfner <http://www.hoefner-online.de/>, Georg Struth <http://www.dcs.shef.ac.uk/~georg>, Tjark Weber <http://user.it.uu.se/~tjawe125/>
	date = 2016-04-12
	topic = Computer Science/Programming Languages/Logics, Computer Science/Automata and Formal Languages, Mathematics/Algebra
	abstract =
	Kleene algebras with domain are Kleene algebras endowed with an
	operation that maps each element of the algebra to its domain of
	definition (or its complement) in abstract fashion. They form a simple
	algebraic basis for Hoare logics, dynamic logics or predicate
	transformer semantics. We formalise a modular hierarchy of algebras
	with domain and antidomain (domain complement) operations in
	Isabelle/HOL that ranges from domain and antidomain semigroups to
	modal Kleene algebras and divergence Kleene algebras. We link these
	algebras with models of binary relations and program traces. We
	include some examples from modal logics, termination and program
	analysis.
	notify = walter.guttman@canterbury.ac.nz, g.struth@sheffield.ac.uk, tjark.weber@it.uu.se

	[Regular_Algebras]
	title = Regular Algebras
	author = Simon Foster <http://www-users.cs.york.ac.uk/~simonf>, Georg Struth <http://www.dcs.shef.ac.uk/~georg>
	date = 2014-05-21
	topic = Computer Science/Automata and Formal Languages, Mathematics/Algebra
	abstract =
	Regular algebras axiomatise the equational theory of regular expressions as induced by
	regular language identity. We use Isabelle/HOL for a detailed systematic study of regular
	algebras given by Boffa, Conway, Kozen and Salomaa. We investigate the relationships between
	these classes, formalise a soundness proof for the smallest class (Salomaa's) and obtain
	completeness of the largest one (Boffa's) relative to a deep result by Krob. In addition
	we provide a large collection of regular identities in the general setting of Boffa's axiom.
	Our regular algebra hierarchy is orthogonal to the Kleene algebra hierarchy in the Archive
	of Formal Proofs; we have not aimed at an integration for pragmatic reasons.
	notify = simon.foster@york.ac.uk, g.struth@sheffield.ac.uk

	[BytecodeLogicJmlTypes]
	title = A Bytecode Logic for JML and Types
	author = Lennart Beringer <>, Martin Hofmann <http://www.tcs.informatik.uni-muenchen.de/~mhofmann>
	date = 2008-12-12
	topic = Computer Science/Programming Languages/Logics
	abstract = This document contains the Isabelle/HOL sources underlying the paper <i>A bytecode logic for JML and types</i> by Beringer and Hofmann, updated to Isabelle 2008. We present a program logic for a subset of sequential Java bytecode that is suitable for representing both, features found in high-level specification language JML as well as interpretations of high-level type systems. To this end, we introduce a fine-grained collection of assertions, including strong invariants, local annotations and VDM-reminiscent partial-correctness specifications. Thanks to a goal-oriented structure and interpretation of judgements, verification may proceed without recourse to an additional control flow analysis. The suitability for interpreting intensional type systems is illustrated by the proof-carrying-code style encoding of a type system for a first-order functional language which guarantees a constant upper bound on the number of objects allocated throughout an execution, be the execution terminating or non-terminating. Like the published paper, the formal development is restricted to a comparatively small subset of the JVML, lacking (among other features) exceptions, arrays, virtual methods, and static fields. This shortcoming has been overcome meanwhile, as our paper has formed the basis of the Mobius base logic, a program logic for the full sequential fragment of the JVML. Indeed, the present formalisation formed the basis of a subsequent formalisation of the Mobius base logic in the proof assistant Coq, which includes a proof of soundness with respect to the Bicolano operational semantics by Pichardie.
	notify =

	[DataRefinementIBP]
	title = Semantics and Data Refinement of Invariant Based Programs
	author = Viorel Preoteasa <http://users.abo.fi/vpreotea/>, Ralph-Johan Back <http://users.abo.fi/Ralph-Johan.Back/>
	date = 2010-05-28
	topic = Computer Science/Programming Languages/Logics
	abstract = The invariant based programming is a technique of constructing correct programs by first identifying the basic situations (pre- and post-conditions and invariants) that can occur during the execution of the program, and then defining the transitions and proving that they preserve the invariants. Data refinement is a technique of building correct programs working on concrete datatypes as refinements of more abstract programs. In the theories presented here we formalize the predicate transformer semantics for invariant based programs and their data refinement.
	extra-history =
	Change history:
	[2012-01-05]: Moved some general complete lattice properties to the AFP entry Lattice Properties.
	Changed the definition of the data refinement relation to be more general and updated all corresponding theorems.
	Added new syntax for demonic and angelic update statements.
	notify = viorel.preoteasa@aalto.fi

	[RefinementReactive]
	title = Formalization of Refinement Calculus for Reactive Systems
	author = Viorel Preoteasa <mailto:viorel.preoteasa@aalto.fi>
	date = 2014-10-08
	topic = Computer Science/Programming Languages/Logics
	abstract =
	We present a formalization of refinement calculus for reactive systems.
	Refinement calculus is based on monotonic predicate transformers
	(monotonic functions from sets of post-states to sets of pre-states),
	and it is a powerful formalism for reasoning about imperative programs.
	We model reactive systems as monotonic property transformers
	that transform sets of output infinite sequences into sets of input
	infinite sequences. Within this semantics we can model
	refinement of reactive systems, (unbounded) angelic and
	demonic nondeterminism, sequential composition, and
	other semantic properties. We can model systems that may
	fail for some inputs, and we can model compatibility of systems.
	We can specify systems that have liveness properties using
	linear temporal logic, and we can refine system specifications
	into systems based on symbolic transitions systems, suitable
	for implementations.
	notify = viorel.preoteasa@aalto.fi

	[SIFPL]
	title = Secure information flow and program logics
	author = Lennart Beringer <>, Martin Hofmann <http://www.tcs.informatik.uni-muenchen.de/~mhofmann>
	date = 2008-11-10
	topic = Computer Science/Programming Languages/Logics, Computer Science/Security
	abstract = We present interpretations of type systems for secure information flow in Hoare logic, complementing previous encodings in relational program logics. We first treat the imperative language IMP, extended by a simple procedure call mechanism. For this language we consider base-line non-interference in the style of Volpano et al. and the flow-sensitive type system by Hunt and Sands. In both cases, we show how typing derivations may be used to automatically generate proofs in the program logic that certify the absence of illicit flows. We then add instructions for object creation and manipulation, and derive appropriate proof rules for base-line non-interference. As a consequence of our work, standard verification technology may be used for verifying that a concrete program satisfies the non-interference property.<br><br>The present proof development represents an update of the formalisation underlying our paper [CSF 2007] and is intended to resolve any ambiguities that may be present in the paper.
	notify = lennart.beringer@ifi.lmu.de

	[TLA]
	title = A Definitional Encoding of TLA* in Isabelle/HOL
	author = Gudmund Grov <http://homepages.inf.ed.ac.uk/ggrov>, Stephan Merz <http://www.loria.fr/~merz>
	date = 2011-11-19
	topic = Computer Science/Programming Languages/Logics
	abstract = We mechanise the logic TLA*
	<a href="http://www.springerlink.com/content/ax3qk557qkdyt7n6/">[Merz 1999]</a>,
	an extension of Lamport's Temporal Logic of Actions (TLA)
	<a href="http://dl.acm.org/citation.cfm?doid=177492.177726">[Lamport 1994]</a>
	for specifying and reasoning
	about concurrent and reactive systems. Aiming at a framework for mechanising] the verification of TLA (or TLA*) specifications, this contribution reuses
	some elements from a previous axiomatic encoding of TLA in Isabelle/HOL
	by the second author [Merz 1998], which has been part of the Isabelle
	distribution. In contrast to that previous work, we give here a shallow,
	definitional embedding, with the following highlights:
	<ul>
	<li>a theory of infinite sequences, including a formalisation of the concepts of stuttering invariance central to TLA and TLA*;
	<li>a definition of the semantics of TLA*, which extends TLA by a mutually-recursive definition of formulas and pre-formulas, generalising TLA action formulas;
	<li>a substantial set of derived proof rules, including the TLA* axioms and Lamport's proof rules for system verification;
	<li>a set of examples illustrating the usage of Isabelle/TLA* for reasoning about systems.
	</ul>
	Note that this work is unrelated to the ongoing development of a proof system
	for the specification language TLA+, which includes an encoding of TLA+ as a
	new Isabelle object logic <a href="http://www.springerlink.com/content/354026160p14j175/">[Chaudhuri et al 2010]</a>.
	notify = ggrov@inf.ed.ac.uk

	[Compiling-Exceptions-Correctly]
	title = Compiling Exceptions Correctly
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2004-07-09
	topic = Computer Science/Programming Languages/Compiling
	abstract = An exception compilation scheme that dynamically creates and removes exception handler entries on the stack. A formalization of an article of the same name by <a href="http://www.cs.nott.ac.uk/~gmh/">Hutton</a> and Wright.
	notify = nipkow@in.tum.de

	[NormByEval]
	title = Normalization by Evaluation
	author = Klaus Aehlig <http://www.linta.de/~aehlig/>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2008-02-18
	topic = Computer Science/Programming Languages/Compiling
	abstract = This article formalizes normalization by evaluation as implemented in Isabelle. Lambda calculus plus term rewriting is compiled into a functional program with pattern matching. It is proved that the result of a successful evaluation is a) correct, i.e. equivalent to the input, and b) in normal form.
	notify = nipkow@in.tum.de

	[Program-Conflict-Analysis]
	title = Formalization of Conflict Analysis of Programs with Procedures, Thread Creation, and Monitors
	topic = Computer Science/Programming Languages/Static Analysis
	author = Peter Lammich <http://www21.in.tum.de/~lammich>, Markus Müller-Olm <http://cs.uni-muenster.de/u/mmo/>
	date = 2007-12-14
	abstract = In this work we formally verify the soundness and precision of a static program analysis that detects conflicts (e. g. data races) in programs with procedures, thread creation and monitors with the Isabelle theorem prover. As common in static program analysis, our program model abstracts guarded branching by nondeterministic branching, but completely interprets the call-/return behavior of procedures, synchronization by monitors, and thread creation. The analysis is based on the observation that all conflicts already occur in a class of particularly restricted schedules. These restricted schedules are suited to constraint-system-based program analysis. The formalization is based upon a flowgraph-based program model with an operational semantics as reference point.
	notify = peter.lammich@uni-muenster.de

	[Shivers-CFA]
	title = Shivers' Control Flow Analysis
	topic = Computer Science/Programming Languages/Static Analysis
	author = Joachim Breitner <mailto:mail@joachim-breitner.de>
	date = 2010-11-16
	abstract =
	In his dissertation, Olin Shivers introduces a concept of control flow graphs
	for functional languages, provides an algorithm to statically derive a safe
	approximation of the control flow graph and proves this algorithm correct. In
	this research project, Shivers' algorithms and proofs are formalized
	in the HOLCF extension of HOL.
	notify = mail@joachim-breitner.de, nipkow@in.tum.de

	[Slicing]
	title = Towards Certified Slicing
	author = Daniel Wasserrab <http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php>
	date = 2008-09-16
	topic = Computer Science/Programming Languages/Static Analysis
	abstract = Slicing is a widely-used technique with applications in e.g. compiler technology and software security. Thus verification of algorithms in these areas is often based on the correctness of slicing, which should ideally be proven independent of concrete programming languages and with the help of well-known verifying techniques such as proof assistants. As a first step in this direction, this contribution presents a framework for dynamic and static intraprocedural slicing based on control flow and program dependence graphs. Abstracting from concrete syntax we base the framework on a graph representation of the program fulfilling certain structural and well-formedness properties.<br><br>The formalization consists of the basic framework (in subdirectory Basic/), the correctness proof for dynamic slicing (in subdirectory Dynamic/), the correctness proof for static intraprocedural slicing (in subdirectory StaticIntra/) and instantiations of the framework with a simple While language (in subdirectory While/) and the sophisticated object-oriented bytecode language of Jinja (in subdirectory JinjaVM/). For more information on the framework, see the TPHOLS 2008 paper by Wasserrab and Lochbihler and the PLAS 2009 paper by Wasserrab et al.
	notify =

	[HRB-Slicing]
	title = Backing up Slicing: Verifying the Interprocedural Two-Phase Horwitz-Reps-Binkley Slicer
	author = Daniel Wasserrab <http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php>
	date = 2009-11-13
	topic = Computer Science/Programming Languages/Static Analysis
	abstract = After verifying <a href="Slicing.html">dynamic and static interprocedural slicing</a>, we present a modular framework for static interprocedural slicing. To this end, we formalized the standard two-phase slicer from Horwitz, Reps and Binkley (see their TOPLAS 12(1) 1990 paper) together with summary edges as presented by Reps et al. (see FSE 1994). The framework is again modular in the programming language by using an abstract CFG, defined via structural and well-formedness properties. Using a weak simulation between the original and sliced graph, we were able to prove the correctness of static interprocedural slicing. We also instantiate our framework with a simple While language with procedures. This shows that the chosen abstractions are indeed valid.
	notify = nipkow@in.tum.de

	[WorkerWrapper]
	title = The Worker/Wrapper Transformation
	author = Peter Gammie <http://peteg.org>
	date = 2009-10-30
	topic = Computer Science/Programming Languages/Transformations
	abstract = Gill and Hutton formalise the worker/wrapper transformation, building on the work of Launchbury and Peyton-Jones who developed it as a way of changing the type at which a recursive function operates. This development establishes the soundness of the technique and several examples of its use.
	notify = peteg42@gmail.com, nipkow@in.tum.de

	[JiveDataStoreModel]
	title = Jive Data and Store Model
	author = Nicole Rauch <mailto:rauch@informatik.uni-kl.de>, Norbert Schirmer <>
	date = 2005-06-20
	license = LGPL
	topic = Computer Science/Programming Languages/Misc
	abstract = This document presents the formalization of an object-oriented data and store model in Isabelle/HOL. This model is being used in the Java Interactive Verification Environment, Jive.
	notify = kleing@cse.unsw.edu.au, schirmer@in.tum.de

	[HotelKeyCards]
	title = Hotel Key Card System
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2006-09-09
	topic = Computer Science/Security
	abstract = Two models of an electronic hotel key card system are contrasted: a state based and a trace based one. Both are defined, verified, and proved equivalent in the theorem prover Isabelle/HOL. It is shown that if a guest follows a certain safety policy regarding her key cards, she can be sure that nobody but her can enter her room.
	notify = nipkow@in.tum.de

	[RSAPSS]
	title = SHA1, RSA, PSS and more
	author = Christina Lindenberg <>, Kai Wirt <>
	date = 2005-05-02
	topic = Computer Science/Security/Cryptography
	abstract = Formal verification is getting more and more important in computer science. However the state of the art formal verification methods in cryptography are very rudimentary. These theories are one step to provide a tool box allowing the use of formal methods in every aspect of cryptography. Moreover we present a proof of concept for the feasibility of verification techniques to a standard signature algorithm.
	notify = nipkow@in.tum.de

	[InformationFlowSlicing]
	title = Information Flow Noninterference via Slicing
	author = Daniel Wasserrab <http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php>
	date = 2010-03-23
	topic = Computer Science/Security
	abstract =
	<p>
	In this contribution, we show how correctness proofs for <a
	href="Slicing.html">intra-</a> and <a
	href="HRB-Slicing.html">interprocedural slicing</a> can be used to prove
	that slicing is able to guarantee information flow noninterference.
	Moreover, we also illustrate how to lift the control flow graphs of the
	respective frameworks such that they fulfil the additional assumptions
	needed in the noninterference proofs. A detailed description of the
	intraprocedural proof and its interplay with the slicing framework can be
	found in the PLAS'09 paper by Wasserrab et al.
	</p>
	<p>
	This entry contains the part for intra-procedural slicing. See entry
	<a href="InformationFlowSlicing_Inter.html">InformationFlowSlicing_Inter</a>
	for the inter-procedural part.
	</p>
	extra-history =
	Change history:
	[2016-06-10]: The original entry <a
	href="InformationFlowSlicing.html">InformationFlowSlicing</a> contained both
	the <a href="InformationFlowSlicing_Inter.html">inter-</a> and <a
	href="InformationFlowSlicing.html">intra-procedural</a> case was split into
	two for easier maintenance.
	notify =

	[InformationFlowSlicing_Inter]
	title = Inter-Procedural Information Flow Noninterference via Slicing
	author = Daniel Wasserrab <http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php>
	date = 2010-03-23
	topic = Computer Science/Security
	abstract =
	<p>
	In this contribution, we show how correctness proofs for <a
	href="Slicing.html">intra-</a> and <a
	href="HRB-Slicing.html">interprocedural slicing</a> can be used to prove
	that slicing is able to guarantee information flow noninterference.
	Moreover, we also illustrate how to lift the control flow graphs of the
	respective frameworks such that they fulfil the additional assumptions
	needed in the noninterference proofs. A detailed description of the
	intraprocedural proof and its interplay with the slicing framework can be
	found in the PLAS'09 paper by Wasserrab et al.
	</p>
	<p>
	This entry contains the part for inter-procedural slicing. See entry
	<a href="InformationFlowSlicing.html">InformationFlowSlicing</a>
	for the intra-procedural part.
	</p>
	extra-history =
	Change history:
	[2016-06-10]: The original entry <a
	href="InformationFlowSlicing.html">InformationFlowSlicing</a> contained both
	the <a href="InformationFlowSlicing_Inter.html">inter-</a> and <a
	href="InformationFlowSlicing.html">intra-procedural</a> case was split into
	two for easier maintenance.
	notify =

	[ComponentDependencies]
	title = Formalisation and Analysis of Component Dependencies
	author = Maria Spichkova <mailto:maria.spichkova@rmit.edu.au>
	date = 2014-04-28
	topic = Computer Science/System Description Languages
	abstract = This set of theories presents a formalisation in Isabelle/HOL of data dependencies between components. The approach allows to analyse system structure oriented towards efficient checking of system: it aims at elaborating for a concrete system, which parts of the system are necessary to check a given property.
	notify = maria.spichkova@rmit.edu.au

	[Verified-Prover]
	title = A Mechanically Verified, Efficient, Sound and Complete Theorem Prover For First Order Logic
	author = Tom Ridge <>
	date = 2004-09-28
	topic = Logic
	abstract = Soundness and completeness for a system of first order logic are formally proved, building on James Margetson's formalization of work by Wainer and Wallen. The completeness proofs naturally suggest an algorithm to derive proofs. This algorithm, which can be implemented tail recursively, is formalized in Isabelle/HOL. The algorithm can be executed via the rewriting tactics of Isabelle. Alternatively, the definitions can be exported to OCaml, yielding a directly executable program.
	notify = lp15@cam.ac.uk

	[Completeness]
	title = Completeness theorem
	author = James Margetson <>, Tom Ridge <>
	date = 2004-09-20
	topic = Logic
	abstract = The completeness of first-order logic is proved, following the first five pages of Wainer and Wallen's chapter of the book <i>Proof Theory</i> by Aczel et al., CUP, 1992. Their presentation of formulas allows the proofs to use symmetry arguments. Margetson formalized this theorem by early 2000. The Isar conversion is thanks to Tom Ridge. A paper describing the formalization is available <a href="Completeness-paper.pdf">[pdf]</a>.
	notify = lp15@cam.ac.uk

	[Ordinal]
	title = Countable Ordinals
	author = Brian Huffman <http://web.cecs.pdx.edu/~brianh/>
	date = 2005-11-11
	topic = Logic
	abstract = This development defines a well-ordered type of countable ordinals. It includes notions of continuous and normal functions, recursively defined functions over ordinals, least fixed-points, and derivatives. Much of ordinal arithmetic is formalized, including exponentials and logarithms. The development concludes with formalizations of Cantor Normal Form and Veblen hierarchies over normal functions.
	notify = lcp@cl.cam.ac.uk

	[Ordinals_and_Cardinals]
	title = Ordinals and Cardinals
	author = Andrei Popescu <>
	date = 2009-09-01
	topic = Logic
	abstract = We develop a basic theory of ordinals and cardinals in Isabelle/HOL, up to the point where some cardinality facts relevant for the ``working mathematician" become available. Unlike in set theory, here we do not have at hand canonical notions of ordinal and cardinal. Therefore, here an ordinal is merely a well-order relation and a cardinal is an ordinal minim w.r.t. order embedding on its field.
	extra-history =
	Change history:
	[2012-09-25]: This entry has been discontinued because it is now part of the Isabelle distribution.
	notify = uuomul@yahoo.com, nipkow@in.tum.de

	[FOL-Fitting]
	title = First-Order Logic According to Fitting
	author = Stefan Berghofer <http://www.in.tum.de/~berghofe>
	contributors = Andreas Halkjær From <http://www.student.dtu.dk/~s144442/>
	date = 2007-08-02
	topic = Logic
	abstract = We present a formalization of parts of Melvin Fitting's book "First-Order Logic and Automated Theorem Proving". The formalization covers the syntax of first-order logic, its semantics, the model existence theorem, a natural deduction proof calculus together with a proof of correctness and completeness, as well as the Löwenheim-Skolem theorem.
	extra-history =
	Change history:
	[2018-07-21]: Proved completeness theorem for open formulas. Proofs are now written in the declarative style. Enumeration of pairs and datatypes is automated using the Countable theory.
	notify = berghofe@in.tum.de

	[Epistemic_Logic]
	title = Epistemic Logic
	author = Andreas Halkjær From <http://www.student.dtu.dk/~s144442/>
	topic = Logic
	date = 2018-10-29
	notify = s144442@student.dtu.dk
	abstract =
	This work is a formalization of epistemic logic with countably many
	agents. It includes proofs of soundness and completeness for the axiom
	system K. The completeness proof is based on the textbook
	"Reasoning About Knowledge" by Fagin, Halpern, Moses and
	Vardi (MIT Press 1995).

	[SequentInvertibility]
	title = Invertibility in Sequent Calculi
	author = Peter Chapman <>
	date = 2009-08-28
	topic = Logic
	license = LGPL
	abstract = The invertibility of the rules of a sequent calculus is important for guiding proof search and can be used in some formalised proofs of Cut admissibility. We present sufficient conditions for when a rule is invertible with respect to a calculus. We illustrate the conditions with examples. It must be noted we give purely syntactic criteria; no guarantees are given as to the suitability of the rules.
	notify = pc@cs.st-andrews.ac.uk, nipkow@in.tum.de

	[LinearQuantifierElim]
	title = Quantifier Elimination for Linear Arithmetic
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2008-01-11
	topic = Logic
	abstract = This article formalizes quantifier elimination procedures for dense linear orders, linear real arithmetic and Presburger arithmetic. In each case both a DNF-based non-elementary algorithm and one or more (doubly) exponential NNF-based algorithms are formalized, including the well-known algorithms by Ferrante and Rackoff and by Cooper. The NNF-based algorithms for dense linear orders are new but based on Ferrante and Rackoff and on an algorithm by Loos and Weisspfenning which simulates infenitesimals. All algorithms are directly executable. In particular, they yield reflective quantifier elimination procedures for HOL itself. The formalization makes heavy use of locales and is therefore highly modular.
	notify = nipkow@in.tum.de

	[Nat-Interval-Logic]
	title = Interval Temporal Logic on Natural Numbers
	author = David Trachtenherz <>
	date = 2011-02-23
	topic = Logic
	abstract = We introduce a theory of temporal logic operators using sets of natural numbers as time domain, formalized in a shallow embedding manner. The theory comprises special natural intervals (theory IL_Interval: open and closed intervals, continuous and modulo intervals, interval traversing results), operators for shifting intervals to left/right on the number axis as well as expanding/contracting intervals by constant factors (theory IL_IntervalOperators.thy), and ultimately definitions and results for unary and binary temporal operators on arbitrary natural sets (theory IL_TemporalOperators).
	notify = nipkow@in.tum.de

	[Recursion-Theory-I]
	title = Recursion Theory I
	author = Michael Nedzelsky <>
	date = 2008-04-05
	topic = Logic
	abstract = This document presents the formalization of introductory material from recursion theory --- definitions and basic properties of primitive recursive functions, Cantor pairing function and computably enumerable sets (including a proof of existence of a one-complete computably enumerable set and a proof of the Rice's theorem).
	notify = MichaelNedzelsky@yandex.ru

	[Free-Boolean-Algebra]
	topic = Logic
	title = Free Boolean Algebra
	author = Brian Huffman <http://web.cecs.pdx.edu/~brianh/>
	date = 2010-03-29
	abstract = This theory defines a type constructor representing the free Boolean algebra over a set of generators. Values of type (α)<i>formula</i> represent propositional formulas with uninterpreted variables from type α, ordered by implication. In addition to all the standard Boolean algebra operations, the library also provides a function for building homomorphisms to any other Boolean algebra type.
	notify = brianh@cs.pdx.edu

	[Sort_Encodings]
	title = Sound and Complete Sort Encodings for First-Order Logic
	author = Jasmin Christian Blanchette <http://www21.in.tum.de/~blanchet>, Andrei Popescu <http://www21.in.tum.de/~popescua>
	date = 2013-06-27
	topic = Logic
	abstract =
	This is a formalization of the soundness and completeness properties
	for various efficient encodings of sorts in unsorted first-order logic
	used by Isabelle's Sledgehammer tool.
	<p>
	Essentially, the encodings proceed as follows:
	a many-sorted problem is decorated with (as few as possible) tags or
	guards that make the problem monotonic; then sorts can be soundly
	erased.
	<p>
	The development employs a formalization of many-sorted first-order logic
	in clausal form (clauses, structures and the basic properties
	of the satisfaction relation), which could be of interest as the starting
	point for other formalizations of first-order logic metatheory.
	notify = uuomul@yahoo.com

	[Lambda_Free_RPOs]
	title = Formalization of Recursive Path Orders for Lambda-Free Higher-Order Terms
	author = Jasmin Christian Blanchette <mailto:jasmin.blanchette@gmail.com>, Uwe Waldmann <mailto:waldmann@mpi-inf.mpg.de>, Daniel Wand <mailto:dwand@mpi-inf.mpg.de>
	date = 2016-09-23
	topic = Logic/Rewriting
	abstract = This Isabelle/HOL formalization defines recursive path orders (RPOs) for higher-order terms without lambda-abstraction and proves many useful properties about them. The main order fully coincides with the standard RPO on first-order terms also in the presence of currying, distinguishing it from previous work. An optimized variant is formalized as well. It appears promising as the basis of a higher-order superposition calculus.
	notify = jasmin.blanchette@gmail.com

	[Lambda_Free_KBOs]
	title = Formalization of Knuth–Bendix Orders for Lambda-Free Higher-Order Terms
	author = Heiko Becker <mailto:hbecker@mpi-sws.org>, Jasmin Christian Blanchette <mailto:jasmin.blanchette@gmail.com>, Uwe Waldmann <mailto:waldmann@mpi-inf.mpg.de>, Daniel Wand <mailto:dwand@mpi-inf.mpg.de>
	date = 2016-11-12
	topic = Logic/Rewriting
	abstract = This Isabelle/HOL formalization defines Knuth–Bendix orders for higher-order terms without lambda-abstraction and proves many useful properties about them. The main order fully coincides with the standard transfinite KBO with subterm coefficients on first-order terms. It appears promising as the basis of a higher-order superposition calculus.
	notify = jasmin.blanchette@gmail.com

	[Lambda_Free_EPO]
	title = Formalization of the Embedding Path Order for Lambda-Free Higher-Order Terms
	author = Alexander Bentkamp <https://www.cs.vu.nl/~abp290/>
	topic = Logic/Rewriting
	date = 2018-10-19
	notify = a.bentkamp@vu.nl
	abstract =
	This Isabelle/HOL formalization defines the Embedding Path Order (EPO)
	for higher-order terms without lambda-abstraction and proves many
	useful properties about it. In contrast to the lambda-free recursive
	path orders, it does not fully coincide with RPO on first-order terms,
	but it is compatible with arbitrary higher-order contexts.

	[Nested_Multisets_Ordinals]
	title = Formalization of Nested Multisets, Hereditary Multisets, and Syntactic Ordinals
	author = Jasmin Christian Blanchette <mailto:jasmin.blanchette@gmail.com>, Mathias Fleury <mailto:fleury@mpi-inf.mpg.de>, Dmitriy Traytel <mailto:traytel@inf.ethz.ch>
	date = 2016-11-12
	topic = Logic/Rewriting
	abstract = This Isabelle/HOL formalization introduces a nested multiset datatype and defines Dershowitz and Manna's nested multiset order. The order is proved well founded and linear. By removing one constructor, we transform the nested multisets into hereditary multisets. These are isomorphic to the syntactic ordinals—the ordinals can be recursively expressed in Cantor normal form. Addition, subtraction, multiplication, and linear orders are provided on this type.
	notify = jasmin.blanchette@gmail.com

	[Abstract-Rewriting]
	title = Abstract Rewriting
	topic = Logic/Rewriting
	date = 2010-06-14
	author = Christian Sternagel <http://cl-informatik.uibk.ac.at/~griff>, René Thiemann <http://cl-informatik.uibk.ac.at/~thiemann>
	license = LGPL
	abstract =
	We present an Isabelle formalization of abstract rewriting (see, e.g.,
	the book by Baader and Nipkow). First, we define standard relations like
	<i>joinability</i>, <i>meetability</i>, <i>conversion</i>, etc. Then, we
	formalize important properties of abstract rewrite systems, e.g.,
	confluence and strong normalization. Our main concern is on strong
	normalization, since this formalization is the basis of <a
	href="http://cl-informatik.uibk.ac.at/software/ceta">CeTA</a> (which is
	mainly about strong normalization of term rewrite systems). Hence lemmas
	involving strong normalization constitute by far the biggest part of this
	theory. One of those is Newman's lemma.
	extra-history =
	Change history:
	[2010-09-17]: Added theories defining several (ordered)
	semirings related to strong normalization and giving some standard
	instances. <br>
	[2013-10-16]: Generalized delta-orders from rationals to Archimedean fields.
	notify = christian.sternagel@uibk.ac.at, rene.thiemann@uibk.ac.at

	[First_Order_Terms]
	title = First-Order Terms
	author = Christian Sternagel <http://cl-informatik.uibk.ac.at/~griff>, René Thiemann <http://cl-informatik.uibk.ac.at/users/thiemann/>
	topic = Logic/Rewriting, Computer Science/Algorithms
	license = LGPL
	date = 2018-02-06
	notify = c.sternagel@gmail.com, rene.thiemann@uibk.ac.at
	abstract =
	We formalize basic results on first-order terms, including matching and a
	first-order unification algorithm, as well as well-foundedness of the
	subsumption order. This entry is part of the <i>Isabelle
	Formalization of Rewriting</i> <a
	href="http://cl-informatik.uibk.ac.at/isafor">IsaFoR</a>,
	where first-order terms are omni-present: the unification algorithm is
	used to certify several confluence and termination techniques, like
	critical-pair computation and dependency graph approximations; and the
	subsumption order is a crucial ingredient for completion.

	[Free-Groups]
	title = Free Groups
	author = Joachim Breitner <mailto:mail@joachim-breitner.de>
	date = 2010-06-24
	topic = Mathematics/Algebra
	abstract =
	Free Groups are, in a sense, the most generic kind of group. They
	are defined over a set of generators with no additional relations in between
	them. They play an important role in the definition of group presentations
	and in other fields. This theory provides the definition of Free Group as
	the set of fully canceled words in the generators. The universal property is
	proven, as well as some isomorphisms results about Free Groups.
	extra-history =
	Change history:
	[2011-12-11]: Added the Ping Pong Lemma.
	notify =

	[CofGroups]
	title = An Example of a Cofinitary Group in Isabelle/HOL
	author = Bart Kastermans <http://kasterma.net>
	date = 2009-08-04
	topic = Mathematics/Algebra
	abstract = We formalize the usual proof that the group generated by the function k -> k + 1 on the integers gives rise to a cofinitary group.
	notify = nipkow@in.tum.de

	[Group-Ring-Module]
	title = Groups, Rings and Modules
	author = Hidetsune Kobayashi <>, L. Chen <>, H. Murao <>
	date = 2004-05-18
	topic = Mathematics/Algebra
	abstract = The theory of groups, rings and modules is developed to a great depth. Group theory results include Zassenhaus's theorem and the Jordan-Hoelder theorem. The ring theory development includes ideals, quotient rings and the Chinese remainder theorem. The module development includes the Nakayama lemma, exact sequences and Tensor products.
	notify = lp15@cam.ac.uk

	[Robbins-Conjecture]
	title = A Complete Proof of the Robbins Conjecture
	author = Matthew Wampler-Doty <>
	date = 2010-05-22
	topic = Mathematics/Algebra
	abstract = This document gives a formalization of the proof of the Robbins conjecture, following A. Mann, <i>A Complete Proof of the Robbins Conjecture</i>, 2003.
	notify = nipkow@in.tum.de

	[Valuation]
	title = Fundamental Properties of Valuation Theory and Hensel's Lemma
	author = Hidetsune Kobayashi <>
	date = 2007-08-08
	topic = Mathematics/Algebra
	abstract = Convergence with respect to a valuation is discussed as convergence of a Cauchy sequence. Cauchy sequences of polynomials are defined. They are used to formalize Hensel's lemma.
	notify = lp15@cam.ac.uk

	[Rank_Nullity_Theorem]
	title = Rank-Nullity Theorem in Linear Algebra
	author = Jose Divasón <http://www.unirioja.es/cu/jodivaso>, Jesús Aransay <http://www.unirioja.es/cu/jearansa>
	topic = Mathematics/Algebra
	date = 2013-01-16
	abstract = In this contribution, we present some formalizations based on the HOL-Multivariate-Analysis session of Isabelle. Firstly, a generalization of several theorems of such library are presented. Secondly, some definitions and proofs involving Linear Algebra and the four fundamental subspaces of a matrix are shown. Finally, we present a proof of the result known in Linear Algebra as the ``Rank-Nullity Theorem'', which states that, given any linear map f from a finite dimensional vector space V to a vector space W, then the dimension of V is equal to the dimension of the kernel of f (which is a subspace of V) and the dimension of the range of f (which is a subspace of W). The proof presented here is based on the one given by Sheldon Axler in his book <i>Linear Algebra Done Right</i>. As a corollary of the previous theorem, and taking advantage of the relationship between linear maps and matrices, we prove that, for every matrix A (which has associated a linear map between finite dimensional vector spaces), the sum of its null space and its column space (which is equal to the range of the linear map) is equal to the number of columns of A.
	extra-history =
	Change history:
	[2014-07-14]: Added some generalizations that allow us to formalize the Rank-Nullity Theorem over finite dimensional vector spaces, instead of over the more particular euclidean spaces. Updated abstract.
	notify = jose.divasonm@unirioja.es, jesus-maria.aransay@unirioja.es

	[Affine_Arithmetic]
	title = Affine Arithmetic
	author = Fabian Immler <http://www21.in.tum.de/~immler>
	date = 2014-02-07
	topic = Mathematics/Analysis
	abstract =
	We give a formalization of affine forms as abstract representations of zonotopes.
	We provide affine operations as well as overapproximations of some non-affine operations like multiplication and division.
	Expressions involving those operations can automatically be turned into (executable) functions approximating the original
	expression in affine arithmetic.
	extra-history =
	Change history:
	[2015-01-31]: added algorithm for zonotope/hyperplane intersection<br>
	[2017-09-20]: linear approximations for all symbols from the floatarith data
	type
	notify = immler@in.tum.de

	[Cauchy]
	title = Cauchy's Mean Theorem and the Cauchy-Schwarz Inequality
	author = Benjamin Porter <>
	date = 2006-03-14
	topic = Mathematics/Analysis
	abstract = This document presents the mechanised proofs of two popular theorems attributed to Augustin Louis Cauchy - Cauchy's Mean Theorem and the Cauchy-Schwarz Inequality.
	notify = kleing@cse.unsw.edu.au

	[Integration]
	title = Integration theory and random variables
	author = Stefan Richter <http://www-lti.informatik.rwth-aachen.de/~richter/>
	date = 2004-11-19
	topic = Mathematics/Analysis
	abstract = Lebesgue-style integration plays a major role in advanced probability. We formalize concepts of elementary measure theory, real-valued random variables as Borel-measurable functions, and a stepwise inductive definition of the integral itself. All proofs are carried out in human readable style using the Isar language.
	extra-note = Note: This article is of historical interest only. Lebesgue-style integration and probability theory are now available as part of the Isabelle/HOL distribution (directory Probability).
	notify = richter@informatik.rwth-aachen.de, nipkow@in.tum.de, hoelzl@in.tum.de

	[Ordinary_Differential_Equations]
	title = Ordinary Differential Equations
	author = Fabian Immler <http://www21.in.tum.de/~immler>, Johannes Hölzl <http://in.tum.de/~hoelzl>
	topic = Mathematics/Analysis
	date = 2012-04-26
	abstract =
	<p>Session Ordinary-Differential-Equations formalizes ordinary differential equations (ODEs) and initial value
	problems. This work comprises proofs for local and global existence of unique solutions
	(Picard-Lindelöf theorem). Moreover, it contains a formalization of the (continuous or even
	differentiable) dependency of the flow on initial conditions as the <i>flow</i> of ODEs.</p>
	<p>
	Not in the generated document are the following sessions:
	<ul>
	<li> HOL-ODE-Numerics:
	Rigorous numerical algorithms for computing enclosures of solutions based on Runge-Kutta methods
	and affine arithmetic. Reachability analysis with splitting and reduction at hyperplanes.</li>
	<li> HOL-ODE-Examples:
	Applications of the numerical algorithms to concrete systems of ODEs.</li>
	<li> Lorenz_C0, Lorenz_C1:
	Verified algorithms for checking C1-information according to Tucker's proof,
	computation of C0-information.</li>
	</ul>
	</p>
	extra-history =
	Change history:
	[2014-02-13]: added an implementation of the Euler method based on affine arithmetic<br>
	[2016-04-14]: added flow and variational equation<br>
	[2016-08-03]: numerical algorithms for reachability analysis (using second-order Runge-Kutta methods, splitting, and reduction) implemented using Lammich's framework for automatic refinement<br>
	[2017-09-20]: added Poincare map and propagation of variational equation in
	reachability analysis, verified algorithms for C1-information and computations
	for C0-information of the Lorenz attractor.
	notify = immler@in.tum.de, hoelzl@in.tum.de

	[Polynomials]
	title = Executable Multivariate Polynomials
	author = Christian Sternagel <http://cl-informatik.uibk.ac.at/~griff>, René Thiemann <http://cl-informatik.uibk.ac.at/~thiemann>, Alexander Maletzky <https://risc.jku.at/m/alexander-maletzky/>, Fabian Immler <http://www21.in.tum.de/~immler>, Florian Haftmann <http://isabelle.in.tum.de/~haftmann>, Andreas Lochbihler <http://www.andreas-lochbihler.de>, Alexander Bentkamp <mailto:bentkamp@gmail.com>
	date = 2010-08-10
	topic = Mathematics/Analysis, Mathematics/Algebra, Computer Science/Algorithms
	license = LGPL
	abstract =
	We define multivariate polynomials over arbitrary (ordered) semirings in
	combination with (executable) operations like addition, multiplication,
	and substitution. We also define (weak) monotonicity of polynomials and
	comparison of polynomials where we provide standard estimations like
	absolute positiveness or the more recent approach of Neurauter, Zankl,
	and Middeldorp. Moreover, it is proven that strongly normalizing
	(monotone) orders can be lifted to strongly normalizing (monotone) orders
	over polynomials. Our formalization was performed as part of the <a
	href="http://cl-informatik.uibk.ac.at/software/ceta">IsaFoR/CeTA-system</a>
	which contains several termination techniques. The provided theories have
	been essential to formalize polynomial interpretations.
	<p>
	This formalization also contains an abstract representation as coefficient functions with finite
	support and a type of power-products. If this type is ordered by a linear (term) ordering, various
	additional notions, such as leading power-product, leading coefficient etc., are introduced as
	well. Furthermore, a lot of generic properties of, and functions on, multivariate polynomials are
	formalized, including the substitution and evaluation homomorphisms, embeddings of polynomial rings
	into larger rings (i.e. with one additional indeterminate), homogenization and dehomogenization of
	polynomials, and the canonical isomorphism between R[X,Y] and R[X][Y].
	extra-history =
	Change history:
	[2010-09-17]: Moved theories on arbitrary (ordered) semirings to Abstract Rewriting.<br>
	[2016-10-28]: Added abstract representation of polynomials and authors Maletzky/Immler.<br>
	[2018-01-23]: Added authors Haftmann, Lochbihler after incorporating
	their formalization of multivariate polynomials based on Polynomial mappings.
	Moved material from Bentkamp's entry "Deep Learning".<br>
	[2019-04-18]: Added material about polynomials whose power-products are represented themselves
	by polynomial mappings.
	notify = rene.thiemann@uibk.ac.at, christian.sternagel@uibk.ac.at, alexander.maletzky@risc.jku.at, immler@in.tum.de

	[Sqrt_Babylonian]
	title = Computing N-th Roots using the Babylonian Method
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	date = 2013-01-03
	topic = Mathematics/Analysis
	license = LGPL
	abstract =
	We implement the Babylonian method to compute n-th roots of numbers.
	We provide precise algorithms for naturals, integers and rationals, and
	offer an approximation algorithm for square roots over linear ordered fields. Moreover, there
	are precise algorithms to compute the floor and the ceiling of n-th roots.
	extra-history =
	Change history:
	[2013-10-16]: Added algorithms to compute floor and ceiling of sqrt of integers.
	[2014-07-11]: Moved NthRoot_Impl from Real-Impl to this entry.
	notify = rene.thiemann@uibk.ac.at

	[Sturm_Sequences]
	title = Sturm's Theorem
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	date = 2014-01-11
	topic = Mathematics/Analysis
	abstract = Sturm's Theorem states that polynomial sequences with certain
	properties, so-called Sturm sequences, can be used to count the number
	of real roots of a real polynomial. This work contains a proof of
	Sturm's Theorem and code for constructing Sturm sequences efficiently.
	It also provides the “sturm” proof method, which can decide certain
	statements about the roots of real polynomials, such as “the polynomial
	P has exactly n roots in the interval I” or “P(x) > Q(x) for all x
	∈ ℝ”.
	notify = eberlm@in.tum.de

	[Sturm_Tarski]
	title = The Sturm-Tarski Theorem
	author = Wenda Li <mailto:wl302@cam.ac.uk>
	date = 2014-09-19
	topic = Mathematics/Analysis
	abstract = We have formalized the Sturm-Tarski theorem (also referred as the Tarski theorem), which generalizes Sturm's theorem. Sturm's theorem is usually used as a way to count distinct real roots, while the Sturm-Tarksi theorem forms the basis for Tarski's classic quantifier elimination for real closed field.
	notify = wl302@cam.ac.uk

	[Markov_Models]
	title = Markov Models
	author = Johannes Hölzl <http://in.tum.de/~hoelzl>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2012-01-03
	topic = Mathematics/Probability Theory, Computer Science/Automata and Formal Languages
	abstract = This is a formalization of Markov models in Isabelle/HOL. It
	builds on Isabelle's probability theory. The available models are
	currently Discrete-Time Markov Chains and a extensions of them with
	rewards.
	<p>
	As application of these models we formalize probabilistic model
	checking of pCTL formulas, analysis of IPv4 address allocation in
	ZeroConf and an analysis of the anonymity of the Crowds protocol.
	<a href="http://arxiv.org/abs/1212.3870">See here for the corresponding paper.</a>
	notify = hoelzl@in.tum.de

	[Probabilistic_System_Zoo]
	title = A Zoo of Probabilistic Systems
	author = Johannes Hölzl <http://in.tum.de/~hoelzl>,
	Andreas Lochbihler <http://www.andreas-lochbihler.de>,
	Dmitriy Traytel <http://www21.in.tum.de/~traytel>
	date = 2015-05-27
	topic = Computer Science/Automata and Formal Languages
	abstract =
	Numerous models of probabilistic systems are studied in the literature.
	Coalgebra has been used to classify them into system types and compare their
	expressiveness. We formalize the resulting hierarchy of probabilistic system
	types by modeling the semantics of the different systems as codatatypes.
	This approach yields simple and concise proofs, as bisimilarity coincides
	with equality for codatatypes.
	<p>
	This work is described in detail in the ITP 2015 publication by the authors.
	notify = traytel@in.tum.de

	[Density_Compiler]
	title = A Verified Compiler for Probability Density Functions
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>, Johannes Hölzl <http://in.tum.de/~hoelzl>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2014-10-09
	topic = Mathematics/Probability Theory, Computer Science/Programming Languages/Compiling
	abstract =
	<a href="https://doi.org/10.1007/978-3-642-36742-7_35">Bhat et al. [TACAS 2013]</a> developed an inductive compiler that computes
	density functions for probability spaces described by programs in a
	probabilistic functional language. In this work, we implement such a
	compiler for a modified version of this language within the theorem prover
	Isabelle and give a formal proof of its soundness w.r.t. the semantics of
	the source and target language. Together with Isabelle's code generation
	for inductive predicates, this yields a fully verified, executable density
	compiler. The proof is done in two steps: First, an abstract compiler
	working with abstract functions modelled directly in the theorem prover's
	logic is defined and proved sound. Then, this compiler is refined to a
	concrete version that returns a target-language expression.
	<p>
	An article with the same title and authors is published in the proceedings
	of ESOP 2015.
	A detailed presentation of this work can be found in the first author's
	master's thesis.
	notify = hoelzl@in.tum.de

	[CAVA_Automata]
	title = The CAVA Automata Library
	author = Peter Lammich <http://www21.in.tum.de/~lammich>
	date = 2014-05-28
	topic = Computer Science/Automata and Formal Languages
	abstract =
	We report on the graph and automata library that is used in the fully
	verified LTL model checker CAVA.
	As most components of CAVA use some type of graphs or automata, a common
	automata library simplifies assembly of the components and reduces
	redundancy.
	<p>
	The CAVA Automata Library provides a hierarchy of graph and automata
	classes, together with some standard algorithms.
	Its object oriented design allows for sharing of algorithms, theorems,
	and implementations between its classes, and also simplifies extensions
	of the library.
	Moreover, it is integrated into the Automatic Refinement Framework,
	supporting automatic refinement of the abstract automata types to
	efficient data structures.
	<p>
	Note that the CAVA Automata Library is work in progress. Currently, it
	is very specifically tailored towards the requirements of the CAVA model
	checker.
	Nevertheless, the formalization techniques presented here allow an
	extension of the library to a wider scope. Moreover, they are not
	limited to graph libraries, but apply to class hierarchies in general.
	<p>
	The CAVA Automata Library is described in the paper: Peter Lammich, The
	CAVA Automata Library, Isabelle Workshop 2014.
	notify = lammich@in.tum.de

	[LTL]
	title = Linear Temporal Logic
	author = Salomon Sickert <https://www7.in.tum.de/~sickert>
	contributors = Benedikt Seidl <mailto:benedikt.seidl@tum.de>
	date = 2016-03-01
	topic = Logic, Computer Science/Automata and Formal Languages
	abstract =
	This theory provides a formalisation of linear temporal logic (LTL)
	and unifies previous formalisations within the AFP. This entry
	establishes syntax and semantics for this logic and decouples it from
	existing entries, yielding a common environment for theories reasoning
	about LTL. Furthermore a parser written in SML and an executable
	simplifier are provided.
	extra-history =
	Change history:
	[2019-03-12]:
	Support for additional operators, implementation of common equivalence relations,
	definition of syntactic fragments of LTL and the minimal disjunctive normal form. <br>
	notify = sickert@in.tum.de

	[LTL_to_GBA]
	title = Converting Linear-Time Temporal Logic to Generalized Büchi Automata
	author = Alexander Schimpf <mailto:schimpfa@informatik.uni-freiburg.de>, Peter Lammich <http://www21.in.tum.de/~lammich>
	date = 2014-05-28
	topic = Computer Science/Automata and Formal Languages
	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.
	<p>
	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.
	notify = lammich@in.tum.de

	[Gabow_SCC]
	title = Verified Efficient Implementation of Gabow's Strongly Connected Components Algorithm
	author = Peter Lammich <http://www21.in.tum.de/~lammich>
	date = 2014-05-28
	topic = Computer Science/Algorithms, Mathematics/Graph Theory
	abstract =
	We present an Isabelle/HOL formalization of Gabow's algorithm for
	finding the strongly connected components of a directed graph.
	Using data refinement techniques, we extract efficient code that
	performs comparable to a reference implementation in Java.
	Our style of formalization allows for re-using large parts of the proofs
	when defining variants of the algorithm. We demonstrate this by
	verifying an algorithm for the emptiness check of generalized Büchi
	automata, re-using most of the existing proofs.
	notify = lammich@in.tum.de

	[Promela]
	title = Promela Formalization
	author = René Neumann <mailto:rene.neumann@in.tum.de>
	date = 2014-05-28
	topic = Computer Science/System Description Languages
	abstract =
	We present an executable formalization of the language Promela, the
	description language 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.
	notify = rene.neumann@in.tum.de

	[CAVA_LTL_Modelchecker]
	title = A Fully Verified Executable LTL Model Checker
	author = Javier Esparza <https://www7.in.tum.de/~esparza/>,
	Peter Lammich <http://www21.in.tum.de/~lammich>,
	René Neumann <mailto:rene.neumann@in.tum.de>,
	Tobias Nipkow <http://www21.in.tum.de/~nipkow>,
	Alexander Schimpf <mailto:schimpfa@informatik.uni-freiburg.de>,
	Jan-Georg Smaus <http://www.irit.fr/~Jan-Georg.Smaus>
	date = 2014-05-28
	topic = Computer Science/Automata and Formal Languages
	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.
	<p>
	An early version of this model checker is described in the
	<a href="http://www21.in.tum.de/~nipkow/pubs/cav13.html">CAV 2013 paper</a>
	with the same title.
	notify = rene.neumann@in.tum.de, lammich@in.tum.de

	[Fermat3_4]
	title = Fermat's Last Theorem for Exponents 3 and 4 and the Parametrisation of Pythagorean Triples
	author = Roelof Oosterhuis <>
	date = 2007-08-12
	topic = Mathematics/Number Theory
	abstract = This document presents the mechanised proofs of<ul><li>Fermat's Last Theorem for exponents 3 and 4 and</li><li>the parametrisation of Pythagorean Triples.</li></ul>
	notify = nipkow@in.tum.de, roelofoosterhuis@gmail.com

	[Perfect-Number-Thm]
	title = Perfect Number Theorem
	author = Mark Ijbema <mailto:ijbema@fmf.nl>
	date = 2009-11-22
	topic = Mathematics/Number Theory
	abstract = These theories present the mechanised proof of the Perfect Number Theorem.
	notify = nipkow@in.tum.de

	[SumSquares]
	title = Sums of Two and Four Squares
	author = Roelof Oosterhuis <>
	date = 2007-08-12
	topic = Mathematics/Number Theory
	abstract = This document presents the mechanised proofs of the following results:<ul><li>any prime number of the form 4m+1 can be written as the sum of two squares;</li><li>any natural number can be written as the sum of four squares</li></ul>
	notify = nipkow@in.tum.de, roelofoosterhuis@gmail.com

	[Lehmer]
	title = Lehmer's Theorem
	author = Simon Wimmer <mailto:simon.wimmer@tum.de>, Lars Noschinski <http://www21.in.tum.de/~noschinl/>
	date = 2013-07-22
	topic = Mathematics/Number Theory
	abstract = In 1927, Lehmer presented criterions for primality, based on the converse of Fermat's litte theorem. This work formalizes the second criterion from Lehmer's paper, a necessary and sufficient condition for primality.
	<p>
	As a side product we formalize some properties of Euler's phi-function,
	the notion of the order of an element of a group, and the cyclicity of the multiplicative group of a finite field.
	notify = noschinl@in.tum.de, simon.wimmer@tum.de

	[Pratt_Certificate]
	title = Pratt's Primality Certificates
	author = Simon Wimmer <mailto:simon.wimmer@tum.de>, Lars Noschinski <http://www21.in.tum.de/~noschinl/>
	date = 2013-07-22
	topic = Mathematics/Number Theory
	abstract = In 1975, Pratt introduced a proof system for certifying primes. He showed that a number <i>p</i> is prime iff a primality certificate for <i>p</i> exists. By showing a logarithmic upper bound on the length of the certificates in size of the prime number, he concluded that the decision problem for prime numbers is in NP. This work formalizes soundness and completeness of Pratt's proof system as well as an upper bound for the size of the certificate.
	notify = noschinl@in.tum.de, simon.wimmer@tum.de

	[Monad_Memo_DP]
	title = Monadification, Memoization and Dynamic Programming
	author = Simon Wimmer <http://home.in.tum.de/~wimmers/>, Shuwei Hu <mailto:shuwei.hu@tum.de>, Tobias Nipkow <http://www21.in.tum.de/~nipkow/>
	topic = Computer Science/Programming Languages/Transformations, Computer Science/Algorithms, Computer Science/Functional Programming
	date = 2018-05-22
	notify = wimmers@in.tum.de
	abstract =
	We present a lightweight framework for the automatic verified
	(functional or imperative) memoization of recursive functions. Our
	tool can turn a pure Isabelle/HOL function definition into a
	monadified version in a state monad or the Imperative HOL heap monad,
	and prove a correspondence theorem. We provide a variety of memory
	implementations for the two types of monads. A number of simple
	techniques allow us to achieve bottom-up computation and
	space-efficient memoization. The framework’s utility is demonstrated
	on a number of representative dynamic programming problems. A detailed
	description of our work can be found in the accompanying paper [2].

	[Probabilistic_Timed_Automata]
	title = Probabilistic Timed Automata
	author = Simon Wimmer <http://in.tum.de/~wimmers>, Johannes Hölzl <http://home.in.tum.de/~hoelzl>
	topic = Mathematics/Probability Theory, Computer Science/Automata and Formal Languages
	date = 2018-05-24
	notify = wimmers@in.tum.de, hoelzl@in.tum.de
	abstract =
	We present a formalization of probabilistic timed automata (PTA) for
	which we try to follow the formula MDP + TA = PTA as far as possible:
	our work starts from our existing formalizations of Markov decision
	processes (MDP) and timed automata (TA) and combines them modularly.
	We prove the fundamental result for probabilistic timed automata: the
	region construction that is known from timed automata carries over to
	the probabilistic setting. In particular, this allows us to prove that
	minimum and maximum reachability probabilities can be computed via a
	reduction to MDP model checking, including the case where one wants to
	disregard unrealizable behavior. Further information can be found in
	our ITP paper [2].

	[Hidden_Markov_Models]
	title = Hidden Markov Models
	author = Simon Wimmer <http://in.tum.de/~wimmers>
	topic = Mathematics/Probability Theory, Computer Science/Algorithms
	date = 2018-05-25
	notify = wimmers@in.tum.de
	abstract =
	This entry contains a formalization of hidden Markov models [3] based
	on Johannes Hölzl's formalization of discrete time Markov chains
	[1]. The basic definitions are provided and the correctness of two
	main (dynamic programming) algorithms for hidden Markov models is
	proved: the forward algorithm for computing the likelihood of an
	observed sequence, and the Viterbi algorithm for decoding the most
	probable hidden state sequence. The Viterbi algorithm is made
	executable including memoization. Hidden markov models have various
	applications in natural language processing. For an introduction see
	Jurafsky and Martin [2].

	[ArrowImpossibilityGS]
	title = Arrow and Gibbard-Satterthwaite
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2008-09-01
	topic = Mathematics/Economics
	abstract = This article formalizes two proofs of Arrow's impossibility theorem due to Geanakoplos and derives the Gibbard-Satterthwaite theorem as a corollary. One formalization is based on utility functions, the other one on strict partial orders.<br><br>An article about these proofs is found <a href="http://www21.in.tum.de/~nipkow/pubs/arrow.html">here</a>.
	notify = nipkow@in.tum.de

	[SenSocialChoice]
	title = Some classical results in Social Choice Theory
	author = Peter Gammie <http://peteg.org>
	date = 2008-11-09
	topic = Mathematics/Economics
	abstract = Drawing on Sen's landmark work "Collective Choice and Social Welfare" (1970), this development proves Arrow's General Possibility Theorem, Sen's Liberal Paradox and May's Theorem in a general setting. The goal was to make precise the classical statements and proofs of these results, and to provide a foundation for more recent results such as the Gibbard-Satterthwaite and Duggan-Schwartz theorems.
	notify = nipkow@in.tum.de

	[Vickrey_Clarke_Groves]
	title = VCG - Combinatorial Vickrey-Clarke-Groves Auctions
	author = Marco B. Caminati <>, Manfred Kerber <http://www.cs.bham.ac.uk/~mmk>, Christoph Lange<mailto:math.semantic.web@gmail.com>, Colin Rowat<mailto:c.rowat@bham.ac.uk>
	date = 2015-04-30
	topic = Mathematics/Economics
	abstract =
	A VCG auction (named after their inventors Vickrey, Clarke, and
	Groves) is a generalization of the single-good, second price Vickrey
	auction to the case of a combinatorial auction (multiple goods, from
	which any participant can bid on each possible combination). We
	formalize in this entry VCG auctions, including tie-breaking and prove
	that the functions for the allocation and the price determination are
	well-defined. Furthermore we show that the allocation function
	allocates goods only to participants, only goods in the auction are
	allocated, and no good is allocated twice. We also show that the price
	function is non-negative. These properties also hold for the
	automatically extracted Scala code.
	notify = mnfrd.krbr@gmail.com

	[Topology]
	title = Topology
	author = Stefan Friedrich <>
	date = 2004-04-26
	topic = Mathematics/Topology
	abstract = This entry contains two theories. The first, <tt>Topology</tt>, develops the basic notions of general topology. The second, which can be viewed as a demonstration of the first, is called <tt>LList_Topology</tt>. It develops the topology of lazy lists.
	notify = lcp@cl.cam.ac.uk

	[Knot_Theory]
	title = Knot Theory
	author = T.V.H. Prathamesh <mailto:prathamesh@imsc.res.in>
	date = 2016-01-20
	topic = Mathematics/Topology
	abstract =
	This work contains a formalization of some topics in knot theory.
	The concepts that were formalized include definitions of tangles, links,
	framed links and link/tangle equivalence. The formalization is based on a
	formulation of links in terms of tangles. We further construct and prove the
	invariance of the Bracket polynomial. Bracket polynomial is an invariant of
	framed links closely linked to the Jones polynomial. This is perhaps the first
	attempt to formalize any aspect of knot theory in an interactive proof assistant.
	notify = prathamesh@imsc.res.in

	[Graph_Theory]
	title = Graph Theory
	author = Lars Noschinski <http://www21.in.tum.de/~noschinl/>
	date = 2013-04-28
	topic = Mathematics/Graph Theory
	abstract = This development provides a formalization of directed graphs, supporting (labelled) multi-edges and infinite graphs. A polymorphic edge type allows edges to be treated as pairs of vertices, if multi-edges are not required. Formalized properties are i.a. walks (and related concepts), connectedness and subgraphs and basic properties of isomorphisms.
	<p>
	This formalization is used to prove characterizations of Euler Trails, Shortest Paths and Kuratowski subgraphs.
	notify = noschinl@in.tum.de

	[Planarity_Certificates]
	title = Planarity Certificates
	author = Lars Noschinski <http://www21.in.tum.de/~noschinl/>
	date = 2015-11-11
	topic = Mathematics/Graph Theory
	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).
	notify = noschinl@in.tum.de

	[Max-Card-Matching]
	title = Maximum Cardinality Matching
	author = Christine Rizkallah <https://www.mpi-inf.mpg.de/~crizkall/>
	date = 2011-07-21
	topic = Mathematics/Graph Theory
	abstract =
	<p>
	A <em>matching</em> in a graph <i>G</i> is a subset <i>M</i> of the
	edges of <i>G</i> such that no two share an endpoint. A matching has maximum
	cardinality if its cardinality is at least as large as that of any other
	matching. An <em>odd-set cover</em> <i>OSC</i> of a graph <i>G</i> is a
	labeling of the nodes of <i>G</i> with integers such that every edge of
	<i>G</i> is either incident to a node labeled 1 or connects two nodes
	labeled with the same number <i>i ≥ 2</i>.
	</p><p>
	This article proves Edmonds theorem:<br>
	Let <i>M</i> be a matching in a graph <i>G</i> and let <i>OSC</i> be an
	odd-set cover of <i>G</i>.
	For any <i>i ≥ 0</i>, let <var>n(i)</var> be the number of nodes
	labeled <i>i</i>. If <i>\|M\| = n(1) +
	∑<sub>i ≥ 2</sub>(n(i) div 2)</i>,
	then <i>M</i> is a maximum cardinality matching.
	</p>
	notify = nipkow@in.tum.de

	[Girth_Chromatic]
	title = A Probabilistic Proof of the Girth-Chromatic Number Theorem
	author = Lars Noschinski <http://www21.in.tum.de/~noschinl/>
	date = 2012-02-06
	topic = Mathematics/Graph Theory
	abstract = This works presents a formalization of the Girth-Chromatic number theorem in graph theory, stating that graphs with arbitrarily large girth and chromatic number exist. The proof uses the theory of Random Graphs to prove the existence with probabilistic arguments.
	notify = noschinl@in.tum.de

	[Random_Graph_Subgraph_Threshold]
	title = Properties of Random Graphs -- Subgraph Containment
	author = Lars Hupel <mailto:hupel@in.tum.de>
	date = 2014-02-13
	topic = Mathematics/Graph Theory, Mathematics/Probability Theory
	abstract = Random graphs are graphs with a fixed number of vertices, where each edge is present with a fixed probability. We are interested in the probability that a random graph contains a certain pattern, for example a cycle or a clique. A very high edge probability gives rise to perhaps too many edges (which degrades performance for many algorithms), whereas a low edge probability might result in a disconnected graph. We prove a theorem about a threshold probability such that a higher edge probability will asymptotically almost surely produce a random graph with the desired subgraph.
	notify = hupel@in.tum.de

	[Flyspeck-Tame]
	title = Flyspeck I: Tame Graphs
	author = Gertrud Bauer <>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2006-05-22
	topic = Mathematics/Graph Theory
	abstract =
	These theories present the verified enumeration of <i>tame</i> plane graphs
	as defined by Thomas C. Hales in his proof of the Kepler Conjecture in his
	book <i>Dense Sphere Packings. A Blueprint for Formal Proofs.</i> [CUP 2012].
	The values of the constants in the definition of tameness are identical to
	those in the <a href="https://code.google.com/p/flyspeck/">Flyspeck project</a>.
	The <a href="http://www21.in.tum.de/~nipkow/pubs/Flyspeck/">IJCAR 2006 paper by Nipkow, Bauer and Schultz</a> refers to the original version of Hales' proof,
	the <a href="http://www21.in.tum.de/~nipkow/pubs/itp11/">ITP 2011 paper by Nipkow</a> refers to the Blueprint version of the proof.
	extra-history =
	Change history:
	[2010-11-02]: modified theories to reflect the modified definition of tameness in Hales' revised proof.<br>
	[2014-07-03]: modified constants in def of tameness and Archive according to the final state of the Flyspeck proof.
	notify = nipkow@in.tum.de

	[Well_Quasi_Orders]
	title = Well-Quasi-Orders
	author = Christian Sternagel <mailto:c.sternagel@gmail.com>
	date = 2012-04-13
	topic = Mathematics/Combinatorics
	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:
	<ul>
	<li>If the sets A and B are wqo then their Cartesian product is wqo.</li>
	<li>If the set A is wqo then the set of finite lists over A is wqo.</li>
	<li>If the set A is wqo then the set of finite trees over A is wqo.</li>
	</ul>
	The research was funded by the Austrian Science Fund (FWF): J3202.
	extra-history =
	Change history:
	[2012-06-11]: Added Kruskal's Tree Theorem.<br>
	[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.<br>
	[2013-05-16]: Simplified construction of minimal bad sequences.<br>
	[2014-07-09]: Simplified proofs of Higman's lemma and Kruskal's tree theorem,
	based on homogeneous sequences.<br>
	[2016-01-03]: An alternative proof of Higman's lemma by open induction.<br>
	[2017-06-08]: Proved (classical) equivalence to inductive definition of
	almost-full relations according to the ITP 2012 paper "Stop When You Are
	Almost-Full" by Vytiniotis, Coquand, and Wahlstedt.
	notify = c.sternagel@gmail.com

	[Marriage]
	title = Hall's Marriage Theorem
	author = Dongchen Jiang <mailto:dongchenjiang@googlemail.com>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2010-12-17
	topic = Mathematics/Combinatorics
	abstract = Two proofs of Hall's Marriage Theorem: one due to Halmos and Vaughan, one due to Rado.
	extra-history =
	Change history:
	[2011-09-09]: Added Rado's proof
	notify = nipkow@in.tum.de

	[Bondy]
	title = Bondy's Theorem
	author = Jeremy Avigad <http://www.andrew.cmu.edu/user/avigad/>, Stefan Hetzl <http://www.logic.at/people/hetzl/>
	date = 2012-10-27
	topic = Mathematics/Combinatorics
	abstract = A proof of Bondy's theorem following B. Bollabas, Combinatorics, 1986, Cambridge University Press.
	notify = avigad@cmu.edu, hetzl@logic.at

	[Ramsey-Infinite]
	title = Ramsey's theorem, infinitary version
	author = Tom Ridge <>
	date = 2004-09-20
	topic = Mathematics/Combinatorics
	abstract = This formalization of Ramsey's theorem (infinitary version) is taken from Boolos and Jeffrey, <i>Computability and Logic</i>, 3rd edition, Chapter 26. It differs slightly from the text by assuming a slightly stronger hypothesis. In particular, the induction hypothesis is stronger, holding for any infinite subset of the naturals. This avoids the rather peculiar mapping argument between kj and aikj on p.263, which is unnecessary and slightly mars this really beautiful result.
	notify = lp15@cam.ac.uk

	[Derangements]
	title = Derangements Formula
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	date = 2015-06-27
	topic = Mathematics/Combinatorics
	abstract =
	The Derangements Formula describes the number of fixpoint-free permutations
	as a closed formula. This theorem is the 88th theorem in a list of the
	``<a href="http://www.cs.ru.nl/~freek/100/">Top 100 Mathematical Theorems</a>''.
	notify = lukas.bulwahn@gmail.com

	[Euler_Partition]
	title = Euler's Partition Theorem
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	date = 2015-11-19
	topic = Mathematics/Combinatorics
	abstract =
	Euler's Partition Theorem states that the number of partitions with only
	distinct parts is equal to the number of partitions with only odd parts.
	The combinatorial proof follows John Harrison's HOL Light formalization.
	This theorem is the 45th theorem of the Top 100 Theorems list.
	notify = lukas.bulwahn@gmail.com

	[Discrete_Summation]
	title = Discrete Summation
	author = Florian Haftmann <http://isabelle.in.tum.de/~haftmann>
	contributors = Amine Chaieb <>
	date = 2014-04-13
	topic = Mathematics/Combinatorics
	abstract = These theories introduce basic concepts and proofs about discrete summation: shifts, formal summation, falling factorials and stirling numbers. As proof of concept, a simple summation conversion is provided.
	notify = florian.haftmann@informatik.tu-muenchen.de

	[Open_Induction]
	title = Open Induction
	author = Mizuhito Ogawa <>, Christian Sternagel <http://cl-informatik.uibk.ac.at/~griff>
	date = 2012-11-02
	topic = Mathematics/Combinatorics
	abstract =
	A proof of the open induction schema based on J.-C. Raoult, Proving open properties by induction, <i>Information Processing Letters</i> 29, 1988, pp.19-23.
	<p>This research was supported by the Austrian Science Fund (FWF): J3202.</p>
	notify = c.sternagel@gmail.com

	[Category]
	title = Category Theory to Yoneda's Lemma
	author = Greg O'Keefe <http://users.rsise.anu.edu.au/~okeefe/>
	date = 2005-04-21
	topic = Mathematics/Category Theory
	license = LGPL
	abstract = This development proves Yoneda's lemma and aims to be readable by humans. It only defines what is needed for the lemma: categories, functors and natural transformations. Limits, adjunctions and other important concepts are not included.
	extra-history =
	Change history:
	[2010-04-23]: The definition of the constant <tt>equinumerous</tt> was slightly too weak in the original submission and has been fixed in revision <a href="https://bitbucket.org/isa-afp/afp-devel/commits/8c2b5b3c995f">8c2b5b3c995f</a>.
	notify = lcp@cl.cam.ac.uk

	[Category2]
	title = Category Theory
	author = Alexander Katovsky <mailto:apk32@cam.ac.uk>
	date = 2010-06-20
	topic = Mathematics/Category Theory
	abstract = This article presents a development of Category Theory in Isabelle/HOL. A Category is defined using records and locales. Functors and Natural Transformations are also defined. The main result that has been formalized is that the Yoneda functor is a full and faithful embedding. We also formalize the completeness of many sorted monadic equational logic. Extensive use is made of the HOLZF theory in both cases. For an informal description see <a href="http://www.srcf.ucam.org/~apk32/Isabelle/Category/Cat.pdf">here [pdf]</a>.
	notify = alexander.katovsky@cantab.net

	[FunWithFunctions]
	title = Fun With Functions
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	date = 2008-08-26
	topic = Mathematics/Misc
	abstract = This is a collection of cute puzzles of the form ``Show that if a function satisfies the following constraints, it must be ...'' Please add further examples to this collection!
	notify = nipkow@in.tum.de

	[FunWithTilings]
	title = Fun With Tilings
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>, Lawrence C. Paulson <http://www.cl.cam.ac.uk/~lp15/>
	date = 2008-11-07
	topic = Mathematics/Misc
	abstract = Tilings are defined inductively. It is shown that one form of mutilated chess board cannot be tiled with dominoes, while another one can be tiled with L-shaped tiles. Please add further fun examples of this kind!
	notify = nipkow@in.tum.de

	[Lazy-Lists-II]
	title = Lazy Lists II
	author = Stefan Friedrich <>
	date = 2004-04-26
	topic = Computer Science/Data Structures
	abstract = This theory contains some useful extensions to the LList (lazy list) theory by <a href="http://www.cl.cam.ac.uk/~lp15/">Larry Paulson</a>, including finite, infinite, and positive llists over an alphabet, as well as the new constants take and drop and the prefix order of llists. Finally, the notions of safety and liveness in the sense of Alpern and Schneider (1985) are defined.
	notify = lcp@cl.cam.ac.uk

	[Ribbon_Proofs]
	title = Ribbon Proofs
	author = John Wickerson <>
	date = 2013-01-19
	topic = Computer Science/Programming Languages/Logics
	abstract = This document concerns the theory of ribbon proofs: a diagrammatic proof system, based on separation logic, for verifying program correctness. We include the syntax, proof rules, and soundness results for two alternative formalisations of ribbon proofs. <p> Compared to traditional proof outlines, ribbon proofs emphasise the structure of a proof, so are intelligible and pedagogical. Because they contain less redundancy than proof outlines, and allow each proof step to be checked locally, they may be more scalable. Where proof outlines are cumbersome to modify, ribbon proofs can be visually manoeuvred to yield proofs of variant programs.
	notify =

	[Koenigsberg_Friendship]
	title = The Königsberg Bridge Problem and the Friendship Theorem
	author = Wenda Li <mailto:wl302@cam.ac.uk>
	date = 2013-07-19
	topic = Mathematics/Graph Theory
	abstract = This development provides a formalization of undirected graphs and simple graphs, which are based on Benedikt Nordhoff and Peter Lammich's simple formalization of labelled directed graphs in the archive. Then, with our formalization of graphs, we show both necessary and sufficient conditions for Eulerian trails and circuits as well as the fact that the Königsberg Bridge Problem does not have a solution. In addition, we show the Friendship Theorem in simple graphs.
	notify =

	[Tree_Decomposition]
	title = Tree Decomposition
	author = Christoph Dittmann <http://logic.las.tu-berlin.de/Members/Dittmann/>
	notify =
	date = 2016-05-31
	topic = Mathematics/Graph Theory
	abstract =
	We formalize tree decompositions and tree width in Isabelle/HOL,
	proving that trees have treewidth 1. We also show that every edge of
	a tree decomposition is a separation of the underlying graph. As an
	application of this theorem we prove that complete graphs of size n
	have treewidth n-1.

	[Menger]
	title = Menger's Theorem
	author = Christoph Dittmann <mailto:isabelle@christoph-d.de>
	topic = Mathematics/Graph Theory
	date = 2017-02-26
	notify = isabelle@christoph-d.de
	abstract =
	We present a formalization of Menger's Theorem for directed and
	undirected graphs in Isabelle/HOL. This well-known result shows that
	if two non-adjacent distinct vertices u, v in a directed graph have no
	separator smaller than n, then there exist n internally
	vertex-disjoint paths from u to v. The version for undirected graphs
	follows immediately because undirected graphs are a special case of
	directed graphs.

	[IEEE_Floating_Point]
	title = A Formal Model of IEEE Floating Point Arithmetic
	author = Lei Yu <mailto:ly271@cam.ac.uk>
	contributors = Fabian Hellauer <mailto:hellauer@in.tum.de>, Fabian Immler <http://www21.in.tum.de/~immler>
	date = 2013-07-27
	topic = Computer Science/Data Structures
	abstract = This development provides a formal model of IEEE-754 floating-point arithmetic. This formalization, including formal specification of the standard and proofs of important properties of floating-point arithmetic, forms the foundation for verifying programs with floating-point computation. There is also a code generation setup for floats so that we can execute programs using this formalization in functional programming languages.
	notify = lp15@cam.ac.uk, immler@in.tum.de
	extra-history =
	Change history:
	[2017-09-25]: Added conversions from and to software floating point numbers
	(by Fabian Hellauer and Fabian Immler).<br>
	[2018-02-05]: 'Modernized' representation following the formalization in HOL4:
	former "float_format" and predicate "is_valid" is now encoded in a type "('e, 'f) float" where
	'e and 'f encode the size of exponent and fraction.

	[Native_Word]
	title = Native Word
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>
	contributors = Peter Lammich <http://www21.in.tum.de/~lammich>
	date = 2013-09-17
	topic = Computer Science/Data Structures
	abstract = This entry makes machine words and machine arithmetic available for code generation from Isabelle/HOL. It provides a common abstraction that hides the differences between the different target languages. The code generator maps these operations to the APIs of the target languages. Apart from that, we extend the available bit operations on types int and integer, and map them to the operations in the target languages.
	extra-history =
	Change history:
	[2013-11-06]:
	added conversion function between native words and characters
	(revision fd23d9a7fe3a)<br>
	[2014-03-31]:
	added words of default size in the target language (by Peter Lammich)
	(revision 25caf5065833)<br>
	[2014-10-06]:
	proper test setup with compilation and execution of tests in all target languages
	(revision 5d7a1c9ae047)<br>
	[2017-09-02]:
	added 64-bit words (revision c89f86244e3c)<br>
	[2018-07-15]:
	added cast operators for default-size words (revision fc1f1fb8dd30)<br>
	notify = mail@andreas-lochbihler.de

	[XML]
	title = XML
	author = Christian Sternagel <mailto:c.sternagel@gmail.com>, René Thiemann <mailto:rene.thiemann@uibk.ac.at>
	date = 2014-10-03
	topic = Computer Science/Functional Programming, Computer Science/Data Structures
	abstract =
	This entry provides an XML library for Isabelle/HOL. This includes parsing
	and pretty printing of XML trees as well as combinators for transforming XML
	trees into arbitrary user-defined data. The main contribution of this entry is
	an interface (fit for code generation) that allows for communication between
	verified programs formalized in Isabelle/HOL and the outside world via XML.
	This library was developed as part of the IsaFoR/CeTA project
	to which we refer for examples of its usage.
	notify = c.sternagel@gmail.com, rene.thiemann@uibk.ac.at

	[HereditarilyFinite]
	title = The Hereditarily Finite Sets
	author = Lawrence C. Paulson <http://www.cl.cam.ac.uk/~lp15/>
	date = 2013-11-17
	topic = Logic
	abstract = The theory of hereditarily finite sets is formalised, following
	the <a href="http://journals.impan.gov.pl/dm/Inf/422-0-1.html">development</a> of Swierczkowski.
	An HF set is a finite collection of other HF sets; they enjoy an induction principle
	and satisfy all the axioms of ZF set theory apart from the axiom of infinity, which is negated.
	All constructions that are possible in ZF set theory (Cartesian products, disjoint sums, natural numbers,
	functions) without using infinite sets are possible here.
	The definition of addition for the HF sets follows Kirby.
	This development forms the foundation for the Isabelle proof of Gödel's incompleteness theorems,
	which has been <a href="Incompleteness.html">formalised separately</a>.
	extra-history =
	Change history:
	[2015-02-23]: Added the theory "Finitary" defining the class of types that can be embedded in hf, including int, char, option, list, etc.
	notify = lp15@cam.ac.uk

	[Incompleteness]
	title = Gödel's Incompleteness Theorems
	author = Lawrence C. Paulson <http://www.cl.cam.ac.uk/~lp15/>
	date = 2013-11-17
	topic = Logic
	abstract = Gödel's two incompleteness theorems are formalised, following a careful <a href="http://journals.impan.gov.pl/dm/Inf/422-0-1.html">presentation</a> by Swierczkowski, in the theory of <a href="HereditarilyFinite.html">hereditarily finite sets</a>. This represents the first ever machine-assisted proof of the second incompleteness theorem. Compared with traditional formalisations using Peano arithmetic (see e.g. Boolos), coding is simpler, with no need to formalise the notion
	of multiplication (let alone that of a prime number)
	in the formalised calculus upon which the theorem is based.
	However, other technical problems had to be solved in order to complete the argument.
	notify = lp15@cam.ac.uk

	[Finite_Automata_HF]
	title = Finite Automata in Hereditarily Finite Set Theory
	author = Lawrence C. Paulson <http://www.cl.cam.ac.uk/~lp15/>
	date = 2015-02-05
	topic = Computer Science/Automata and Formal Languages
	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.
	notify = lp15@cam.ac.uk

	[Decreasing-Diagrams]
	title = Decreasing Diagrams
	author = Harald Zankl <http://cl-informatik.uibk.ac.at/users/hzankl>
	license = LGPL
	date = 2013-11-01
	topic = Logic/Rewriting
	abstract = This theory contains a formalization of decreasing diagrams showing that any locally decreasing abstract rewrite system is confluent. We consider the valley (van Oostrom, TCS 1994) and the conversion version (van Oostrom, RTA 2008) and closely follow the original proofs. As an application we prove Newman's lemma.
	notify = Harald.Zankl@uibk.ac.at

	[Decreasing-Diagrams-II]
	title = Decreasing Diagrams II
	author = Bertram Felgenhauer <mailto:bertram.felgenhauer@uibk.ac.at>
	license = LGPL
	date = 2015-08-20
	topic = Logic/Rewriting
	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.
	notify = bertram.felgenhauer@uibk.ac.at

	[GoedelGod]
	title = Gödel's God in Isabelle/HOL
	author = Christoph Benzmüller <http://page.mi.fu-berlin.de/cbenzmueller/>, Bruno Woltzenlogel Paleo <http://www.logic.at/staff/bruno/>
	date = 2013-11-12
	topic = Logic/Philosophy
	abstract = Dana Scott's version of Gödel's proof of God's existence is formalized in quantified
	modal logic KB (QML KB).
	QML KB is modeled as a fragment of classical higher-order logic (HOL);
	thus, the formalization is essentially a formalization in HOL.
	notify = lp15@cam.ac.uk, c.benzmueller@fu-berlin.de

	[Types_Tableaus_and_Goedels_God]
	title = Types, Tableaus and Gödel’s God in Isabelle/HOL
	author = David Fuenmayor <mailto:davfuenmayor@gmail.com>, Christoph Benzmüller <http://www.christoph-benzmueller.de>
	topic = Logic/Philosophy
	date = 2017-05-01
	notify = davfuenmayor@gmail.com, c.benzmueller@gmail.com
	abstract =
	A computer-formalisation of the essential parts of Fitting's
	textbook "Types, Tableaus and Gödel's God" in
	Isabelle/HOL is presented. In particular, Fitting's (and
	Anderson's) variant of the ontological argument is verified and
	confirmed. This variant avoids the modal collapse, which has been
	criticised as an undesirable side-effect of Kurt Gödel's (and
	Dana Scott's) versions of the ontological argument.
	Fitting's work is employing an intensional higher-order modal
	logic, which we shallowly embed here in classical higher-order logic.
	We then utilize the embedded logic for the formalisation of
	Fitting's argument. (See also the earlier AFP entry ``Gödel's God in Isabelle/HOL''.)

	[GewirthPGCProof]
	title = Formalisation and Evaluation of Alan Gewirth's Proof for the Principle of Generic Consistency in Isabelle/HOL
	author = David Fuenmayor <mailto:davfuenmayor@gmail.com>, Christoph Benzmüller <http://christoph-benzmueller.de>
	topic = Logic/Philosophy
	date = 2018-10-30
	notify = davfuenmayor@gmail.com, c.benzmueller@gmail.com
	abstract =
	An ambitious ethical theory ---Alan Gewirth's "Principle of
	Generic Consistency"--- is encoded and analysed in Isabelle/HOL.
	Gewirth's theory has stirred much attention in philosophy and
	ethics and has been proposed as a potential means to bound the impact
	of artificial general intelligence.
	extra-history =
	Change history:
	[2019-04-09]:
	added proof for a stronger variant of the PGC and examplary inferences
	(revision 88182cb0a2f6)<br>

	[Lowe_Ontological_Argument]
	title = Computer-assisted Reconstruction and Assessment of E. J. Lowe's Modal Ontological Argument
	author = David Fuenmayor <mailto:davfuenmayor@gmail.com>, Christoph Benzmüller <http://www.christoph-benzmueller.de>
	topic = Logic/Philosophy
	date = 2017-09-21
	notify = davfuenmayor@gmail.com, c.benzmueller@gmail.com
	abstract =
	Computers may help us to understand --not just verify-- philosophical
	arguments. By utilizing modern proof assistants in an iterative
	interpretive process, we can reconstruct and assess an argument by
	fully formal means. Through the mechanization of a variant of St.
	Anselm's ontological argument by E. J. Lowe, which is a
	paradigmatic example of a natural-language argument with strong ties
	to metaphysics and religion, we offer an ideal showcase for our
	computer-assisted interpretive method.

	[AnselmGod]
	title = Anselm's God in Isabelle/HOL
	author = Ben Blumson <https://philpapers.org/profile/805>
	topic = Logic/Philosophy
	date = 2017-09-06
	notify = benblumson@gmail.com
	abstract =
	Paul Oppenheimer and Edward Zalta's formalisation of
	Anselm's ontological argument for the existence of God is
	automated by embedding a free logic for definite descriptions within
	Isabelle/HOL.

	[Tail_Recursive_Functions]
	title = A General Method for the Proof of Theorems on Tail-recursive Functions
	author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
	date = 2013-12-01
	topic = Computer Science/Functional Programming
	abstract =
	<p>
	Tail-recursive function definitions are sometimes more straightforward than
	alternatives, but proving theorems on them may be roundabout because of the
	peculiar form of the resulting recursion induction rules.
	</p><p>
	This paper describes a proof method that provides a general solution to
	this problem by means of suitable invariants over inductive sets, and
	illustrates the application of such method by examining two case studies.
	</p>
	notify = pasquale.noce.lavoro@gmail.com

	[CryptoBasedCompositionalProperties]
	title = Compositional Properties of Crypto-Based Components
	author = Maria Spichkova <mailto:maria.spichkova@rmit.edu.au>
	date = 2014-01-11
	topic = Computer Science/Security
	abstract = This paper presents an Isabelle/HOL set of theories which allows the specification of crypto-based components and the verification of their composition properties wrt. cryptographic aspects. We introduce a formalisation of the security property of data secrecy, the corresponding definitions and proofs. Please note that here we import the Isabelle/HOL theory ListExtras.thy, presented in the AFP entry FocusStreamsCaseStudies-AFP.
	notify = maria.spichkova@rmit.edu.au

	[Featherweight_OCL]
	title = Featherweight OCL: A Proposal for a Machine-Checked Formal Semantics for OCL 2.5
	author = Achim D. Brucker <mailto:brucker@spamfence.net>, Frédéric Tuong <mailto:tuong@users.gforge.inria.fr>, Burkhart Wolff <mailto:wolff@lri.fr>
	date = 2014-01-16
	topic = Computer Science/System Description Languages
	abstract = The Unified Modeling Language (UML) is one of the few
	modeling languages that is widely used in industry. While
	UML is mostly known as diagrammatic modeling language
	(e.g., visualizing class models), it is complemented by a
	textual language, called Object Constraint Language
	(OCL). The current version of OCL is based on a four-valued
	logic that turns UML into a formal language. Any type
	comprises the elements "invalid" and "null" which are
	propagated as strict and non-strict, respectively.
	Unfortunately, the former semi-formal semantics of this
	specification language, captured in the "Annex A" of the
	OCL standard, leads to different interpretations of corner
	cases. We formalize the core of OCL: denotational
	definitions, a logical calculus and operational rules that
	allow for the execution of OCL expressions by a mixture of
	term rewriting and code compilation. Our formalization
	reveals several inconsistencies and contradictions in the
	current version of the OCL standard. Overall, this document
	is intended to provide the basis for a machine-checked text
	"Annex A" of the OCL standard targeting at tool
	implementors.
	extra-history =
	Change history:
	[2015-10-13]:
	<a href="https://bitbucket.org/isa-afp/afp-devel/commits/ea3b38fc54d68535bcfafd40357b6ff8f1092057">afp-devel@ea3b38fc54d6</a> and
	<a href="https://projects.brucker.ch/hol-testgen/log/trunk?rev=12148">hol-testgen@12148</a><br>
	Update of Featherweight OCL including a change in the abstract.<br>
	[2014-01-16]:
	<a href="https://bitbucket.org/isa-afp/afp-devel/commits/9091ce05cb20d4ad3dc1961c18f1846d85e87f8e">afp-devel@9091ce05cb20</a> and
	<a href="https://projects.brucker.ch/hol-testgen/log/trunk?rev=10241">hol-testgen@10241</a><br>
	New Entry: Featherweight OCL
	notify = brucker@spamfence.net, tuong@users.gforge.inria.fr, wolff@lri.fr

	[Relation_Algebra]
	title = Relation Algebra
	author = Alasdair Armstrong <>,
	Simon Foster <mailto:simon.foster@york.ac.uk>,
	Georg Struth <http://staffwww.dcs.shef.ac.uk/people/G.Struth/>,
	Tjark Weber <http://user.it.uu.se/~tjawe125/>
	date = 2014-01-25
	topic = Mathematics/Algebra
	abstract = Tarski's algebra of binary relations is formalised along the lines of
	the standard textbooks of Maddux and Schmidt and Ströhlein. This
	includes relation-algebraic concepts such as subidentities, vectors and
	a domain operation as well as various notions associated to functions.
	Relation algebras are also expanded by a reflexive transitive closure
	operation, and they are linked with Kleene algebras and models of binary
	relations and Boolean matrices.
	notify = g.struth@sheffield.ac.uk, tjark.weber@it.uu.se

	[PSemigroupsConvolution]
	title = Partial Semigroups and Convolution Algebras
	author = Brijesh Dongol <mailto:brijesh.dongol@brunel.ac.uk>, Victor B. F. Gomes <mailto:victor.gomes@cl.cam.ac.uk>, Ian J. Hayes <mailto:ian.hayes@itee.uq.edu.au>, Georg Struth <mailto:g.struth@sheffield.ac.uk>
	topic = Mathematics/Algebra
	date = 2017-06-13
	notify = g.struth@sheffield.ac.uk, victor.gomes@cl.cam.ac.uk
	abstract =
	Partial Semigroups are relevant to the foundations of quantum
	mechanics and combinatorics as well as to interval and separation
	logics. Convolution algebras can be understood either as algebras of
	generalised binary modalities over ternary Kripke frames, in
	particular over partial semigroups, or as algebras of quantale-valued
	functions which are equipped with a convolution-style operation of
	multiplication that is parametrised by a ternary relation. Convolution
	algebras provide algebraic semantics for various substructural logics,
	including categorial, relevance and linear logics, for separation
	logic and for interval logics; they cover quantitative and qualitative
	applications. These mathematical components for partial semigroups and
	convolution algebras provide uniform foundations from which models of
	computation based on relations, program traces or pomsets, and
	verification components for separation or interval temporal logics can
	be built with little effort.

	[Secondary_Sylow]
	title = Secondary Sylow Theorems
	author = Jakob von Raumer <mailto:psxjv4@nottingham.ac.uk>
	date = 2014-01-28
	topic = Mathematics/Algebra
	abstract = These theories extend the existing proof of the first Sylow theorem
	(written by Florian Kammueller and L. C. Paulson) by what are often
	called the second, third and fourth Sylow theorems. These theorems
	state propositions about the number of Sylow p-subgroups of a group
	and the fact that they are conjugate to each other. The proofs make
	use of an implementation of group actions and their properties.
	notify = psxjv4@nottingham.ac.uk

	[Jordan_Hoelder]
	title = The Jordan-Hölder Theorem
	author = Jakob von Raumer <mailto:psxjv4@nottingham.ac.uk>
	date = 2014-09-09
	topic = Mathematics/Algebra
	abstract = This submission contains theories that lead to a formalization of the proof of the Jordan-Hölder theorem about composition series of finite groups. The theories formalize the notions of isomorphism classes of groups, simple groups, normal series, composition series, maximal normal subgroups. Furthermore, they provide proofs of the second isomorphism theorem for groups, the characterization theorem for maximal normal subgroups as well as many useful lemmas about normal subgroups and factor groups. The proof is inspired by course notes of Stuart Rankin.
	notify = psxjv4@nottingham.ac.uk

	[Cayley_Hamilton]
	title = The Cayley-Hamilton Theorem
	author = Stephan Adelsberger <http://nm.wu.ac.at/nm/sadelsbe>,
	Stefan Hetzl <http://www.logic.at/people/hetzl/>,
	Florian Pollak <mailto:florian.pollak@gmail.com>
	date = 2014-09-15
	topic = Mathematics/Algebra
	abstract =
	This document contains a proof of the Cayley-Hamilton theorem
	based on the development of matrices in HOL/Multivariate Analysis.
	notify = stvienna@gmail.com

	[Probabilistic_Noninterference]
	title = Probabilistic Noninterference
	author = Andrei Popescu <http://www21.in.tum.de/~popescua>, Johannes Hölzl <http://in.tum.de/~hoelzl>
	date = 2014-03-11
	topic = Computer Science/Security
	abstract = We formalize a probabilistic noninterference for a multi-threaded language with uniform scheduling, where probabilistic behaviour comes from both the scheduler and the individual threads. We define notions probabilistic noninterference in two variants: resumption-based and trace-based. For the resumption-based notions, we prove compositionality w.r.t. the language constructs and establish sound type-system-like syntactic criteria. This is a formalization of the mathematical development presented at CPP 2013 and CALCO 2013. It is the probabilistic variant of the Possibilistic Noninterference AFP entry.
	notify = hoelzl@in.tum.de

	[HyperCTL]
	title = A shallow embedding of HyperCTL*
	author = Markus N. Rabe <http://www.react.uni-saarland.de/people/rabe.html>, Peter Lammich <http://www21.in.tum.de/~lammich>, Andrei Popescu <http://www21.in.tum.de/~popescua>
	date = 2014-04-16
	topic = Computer Science/Security, Logic
	abstract = We formalize HyperCTL*, a temporal logic for expressing security properties. We
	first define a shallow embedding of HyperCTL*, within which we prove inductive and coinductive
	rules for the operators. Then we show that a HyperCTL* formula captures Goguen-Meseguer
	noninterference, a landmark information flow property. We also define a deep embedding and
	connect it to the shallow embedding by a denotational semantics, for which we prove sanity w.r.t.
	dependence on the free variables. Finally, we show that under some finiteness assumptions about
	the model, noninterference is given by a (finitary) syntactic formula.
	notify = uuomul@yahoo.com

	[Bounded_Deducibility_Security]
	title = Bounded-Deducibility Security
	author = Andrei Popescu <http://www21.in.tum.de/~popescua>, Peter Lammich <http://www21.in.tum.de/~lammich>
	date = 2014-04-22
	topic = Computer Science/Security
	abstract = This is a formalization of bounded-deducibility security (BD
	security), a flexible notion of information-flow security applicable
	to arbitrary input-output automata. It generalizes Sutherland's
	classic notion of nondeducibility by factoring in declassification
	bounds and trigger, whereas nondeducibility states that, in a
	system, information cannot flow between specified sources and sinks,
	BD security indicates upper bounds for the flow and triggers under
	which these upper bounds are no longer guaranteed.
	notify = uuomul@yahoo.com, lammich@in.tum.de

	[Network_Security_Policy_Verification]
	title = Network Security Policy Verification
	author = Cornelius Diekmann <http://net.in.tum.de/~diekmann>
	date = 2014-07-04
	topic = Computer Science/Security
	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.
	<ul>
	<li>Secure auto-completion of scenario-specific knowledge, which eases usability.</li>
	<li>Security violations can be repaired by tightening the policy iff the
	security invariants hold for the deny-all policy.</li>
	<li>An algorithm to compute a security policy.</li>
	<li>A formalization of stateful connection semantics in network security mechanisms.</li>
	<li>An algorithm to compute a secure stateful implementation of a policy.</li>
	<li>An executable implementation of all the theory.</li>
	<li>Examples, ranging from an aircraft cabin data network to the analysis
	of a large real-world firewall.</li>
	<li>More examples: A fully automated translation of high-level security goals to both
	firewall and SDN configurations (see Examples/Distributed_WebApp.thy).</li>
	</ul>
	For a detailed description, see
	<ul>
	<li>C. Diekmann, A. Korsten, and G. Carle.
	<a href="http://www.net.in.tum.de/fileadmin/bibtex/publications/papers/diekmann2015mansdnnfv.pdf">Demonstrating
	topoS: Theorem-prover-based synthesis of secure network configurations.</a>
	In 2nd International Workshop on Management of SDN and NFV Systems, manSDN/NFV, Barcelona, Spain, November 2015.</li>
	<li>C. Diekmann, S.-A. Posselt, H. Niedermayer, H. Kinkelin, O. Hanka, and G. Carle.
	<a href="http://www.net.in.tum.de/pub/diekmann/forte14.pdf">Verifying Security Policies using Host Attributes.</a>
	In FORTE, 34th IFIP International Conference on Formal Techniques for Distributed Objects,
	Components and Systems, Berlin, Germany, June 2014.</li>
	<li>C. Diekmann, L. Hupel, and G. Carle. Directed Security Policies:
	<a href="http://rvg.web.cse.unsw.edu.au/eptcs/paper.cgi?ESSS2014.3">A Stateful Network Implementation.</a>
	In J. Pang and Y. Liu, editors, Engineering Safety and Security Systems,
	volume 150 of Electronic Proceedings in Theoretical Computer Science,
	pages 20-34, Singapore, May 2014. Open Publishing Association.</li>
	</ul>
	extra-history =
	Change history:
	[2015-04-14]:
	Added Distributed WebApp example and improved graphviz visualization
	(revision 4dde08ca2ab8)<br>
	notify = diekmann@net.in.tum.de

	[Abstract_Completeness]
	title = Abstract Completeness
	author = Jasmin Christian Blanchette <http://www21.in.tum.de/~blanchet>, Andrei Popescu <http://www21.in.tum.de/~popescua>, Dmitriy Traytel <http://www21.in.tum.de/~traytel>
	date = 2014-04-16
	topic = Logic
	abstract = A formalization of an abstract property of possibly infinite derivation trees (modeled by a codatatype), representing the core of a proof (in Beth/Hintikka style) of the first-order logic completeness theorem, independent of the concrete syntax or inference rules. This work is described in detail in the IJCAR 2014 publication by the authors.
	The abstract proof can be instantiated for a wide range of Gentzen and tableau systems as well as various flavors of FOL---e.g., with or without predicates, equality, or sorts. Here, we give only a toy example instantiation with classical propositional logic. A more serious instance---many-sorted FOL with equality---is described elsewhere [Blanchette and Popescu, FroCoS 2013].
	notify = traytel@in.tum.de

	[Pop_Refinement]
	title = Pop-Refinement
	author = Alessandro Coglio <http://www.kestrel.edu/~coglio>
	date = 2014-07-03
	topic = Computer Science/Programming Languages/Misc
	abstract = Pop-refinement is an approach to stepwise refinement, carried out inside an interactive theorem prover by constructing a monotonically decreasing sequence of predicates over deeply embedded target programs. The sequence starts with a predicate that characterizes the possible implementations, and ends with a predicate that characterizes a unique program in explicit syntactic form. Pop-refinement enables more requirements (e.g. program-level and non-functional) to be captured in the initial specification and preserved through refinement. Security requirements expressed as hyperproperties (i.e. predicates over sets of traces) are always preserved by pop-refinement, unlike the popular notion of refinement as trace set inclusion. Two simple examples in Isabelle/HOL are presented, featuring program-level requirements, non-functional requirements, and hyperproperties.
	notify = coglio@kestrel.edu

	[VectorSpace]
	title = Vector Spaces
	author = Holden Lee <mailto:holdenl@princeton.edu>
	date = 2014-08-29
	topic = Mathematics/Algebra
	abstract = This formalisation of basic linear algebra is based completely on locales, building off HOL-Algebra. It includes basic definitions: linear combinations, span, linear independence; linear transformations; interpretation of function spaces as vector spaces; the direct sum of vector spaces, sum of subspaces; the replacement theorem; existence of bases in finite-dimensional; vector spaces, definition of dimension; the rank-nullity theorem. Some concepts are actually defined and proved for modules as they also apply there. Infinite-dimensional vector spaces are supported, but dimension is only supported for finite-dimensional vector spaces. The proofs are standard; the proofs of the replacement theorem and rank-nullity theorem roughly follow the presentation in Linear Algebra by Friedberg, Insel, and Spence. The rank-nullity theorem generalises the existing development in the Archive of Formal Proof (originally using type classes, now using a mix of type classes and locales).
	notify = holdenl@princeton.edu

	[Special_Function_Bounds]
	title = Real-Valued Special Functions: Upper and Lower Bounds
	author = Lawrence C. Paulson <http://www.cl.cam.ac.uk/~lp15/>
	date = 2014-08-29
	topic = Mathematics/Analysis
	abstract = This development proves upper and lower bounds for several familiar real-valued functions. For sin, cos, exp and sqrt, it defines and verifies infinite families of upper and lower bounds, mostly based on Taylor series expansions. For arctan, ln and exp, it verifies a finite collection of upper and lower bounds, originally obtained from the functions' continued fraction expansions using the computer algebra system Maple. A common theme in these proofs is to take the difference between a function and its approximation, which should be zero at one point, and then consider the sign of the derivative. The immediate purpose of this development is to verify axioms used by MetiTarski, an automatic theorem prover for real-valued special functions. Crucial to MetiTarski's operation is the provision of upper and lower bounds for each function of interest.
	notify = lp15@cam.ac.uk

	[Landau_Symbols]
	title = Landau Symbols
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	date = 2015-07-14
	topic = Mathematics/Analysis
	abstract = This entry provides Landau symbols to describe and reason about the asymptotic growth of functions for sufficiently large inputs. A number of simplification procedures are provided for additional convenience: cancelling of dominated terms in sums under a Landau symbol, cancelling of common factors in products, and a decision procedure for Landau expressions containing products of powers of functions like x, ln(x), ln(ln(x)) etc.
	notify = eberlm@in.tum.de

	[Error_Function]
	title = The Error Function
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Analysis
	date = 2018-02-06
	notify = eberlm@in.tum.de
	abstract =
	<p> This entry provides the definitions and basic properties of
	the complex and real error function erf and the complementary error
	function erfc. Additionally, it gives their full asymptotic
	expansions. </p>

	[Akra_Bazzi]
	title = The Akra-Bazzi theorem and the Master theorem
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	date = 2015-07-14
	topic = Mathematics/Analysis
	abstract = This article contains a formalisation of the Akra-Bazzi method
	based on a proof by Leighton. It is a generalisation of the well-known
	Master Theorem for analysing the complexity of Divide & Conquer algorithms.
	We also include a generalised version of the Master theorem based on the
	Akra-Bazzi theorem, which is easier to apply than the Akra-Bazzi theorem
	itself.
	<p>
	Some proof methods that facilitate applying the Master theorem are also
	included. For a more detailed explanation of the formalisation and the
	proof methods, see the accompanying paper (publication forthcoming).
	notify = eberlm@in.tum.de

	[Dirichlet_Series]
	title = Dirichlet Series
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Number Theory
	date = 2017-10-12
	notify = eberlm@in.tum.de
	abstract =
	This entry is a formalisation of much of Chapters 2, 3, and 11 of
	Apostol's “Introduction to Analytic Number
	Theory”. This includes: <ul> <li>Definitions and
	basic properties for several number-theoretic functions (Euler's
	φ, Möbius μ, Liouville's λ,
	the divisor function σ, von Mangoldt's
	Λ)</li> <li>Executable code for most of these
	functions, the most efficient implementations using the factoring
	algorithm by Thiemann <i>et al.</i></li>
	<li>Dirichlet products and formal Dirichlet series</li>
	<li>Analytic results connecting convergent formal Dirichlet
	series to complex functions</li> <li>Euler product
	expansions</li> <li>Asymptotic estimates of
	number-theoretic functions including the density of squarefree
	integers and the average number of divisors of a natural
	number</li> </ul> These results are useful as a basis for
	developing more number-theoretic results, such as the Prime Number
	Theorem.

	[Zeta_Function]
	title = The Hurwitz and Riemann ζ Functions
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Number Theory, Mathematics/Analysis
	date = 2017-10-12
	notify = eberlm@in.tum.de
	abstract =
	<p> This entry builds upon the results about formal and analytic
	Dirichlet series to define the Hurwitz ζ function and, based
	on that, the Riemann ζ function. This is done by first
	defining them for &real;(<i>z</i>) > 1 and then
	successively extending the domain to the left using the
	Euler–MacLaurin formula. </p> <p> Some basic
	results about these functions are also shown, such as their
	analyticity on ℂ∖{1}, that they
	have a simple pole with residue 1 at 1, their relation to the
	Γ function, and the special values at negative integers and
	positive even integers – including the famous ζ(-1)
	= -1/12 and ζ(2) = π²/6. </p> <p>
	Lastly, the entry also contains Euler's analytic proof of the
	infinitude of primes, based on the fact that
	ζ(<i>s</i>) has a pole at <i>s</i> =
	1. </p>

	[Linear_Recurrences]
	title = Linear Recurrences
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Analysis
	date = 2017-10-12
	notify = eberlm@in.tum.de
	abstract =
	<p> Linear recurrences with constant coefficients are an
	interesting class of recurrence equations that can be solved
	explicitly. The most famous example are certainly the Fibonacci
	numbers with the equation <i>f</i>(<i>n</i>) =
	<i>f</i>(<i>n</i>-1) +
	<i>f</i>(<i>n</i> - 2) and the quite
	non-obvious closed form
	(<i>φ</i><sup><i>n</i></sup>
	-
	(-<i>φ</i>)<sup>-<i>n</i></sup>)
	/ √<span style="text-decoration:
	overline">5</span> where φ is the golden ratio.
	</p> <p> In this work, I build on existing tools in
	Isabelle – such as formal power series and polynomial
	factorisation algorithms – to develop a theory of these
	recurrences and derive a fully executable solver for them that can be
	exported to programming languages like Haskell. </p>

	[Cartan_FP]
	title = The Cartan Fixed Point Theorems
	author = Lawrence C. Paulson <http://www.cl.cam.ac.uk/~lp15/>
	date = 2016-03-08
	topic = Mathematics/Analysis
	abstract =
	The Cartan fixed point theorems concern the group of holomorphic
	automorphisms on a connected open set of C<sup>n</sup>. Ciolli et al.
	have formalised the one-dimensional case of these theorems in HOL
	Light. This entry contains their proofs, ported to Isabelle/HOL. Thus
	it addresses the authors' remark that "it would be important to write
	a formal proof in a language that can be read by both humans and
	machines".
	notify = lp15@cam.ac.uk

	[Gauss_Jordan]
	title = Gauss-Jordan Algorithm and Its Applications
	author = Jose Divasón <http://www.unirioja.es/cu/jodivaso>, Jesús Aransay <http://www.unirioja.es/cu/jearansa>
	topic = Computer Science/Algorithms
	date = 2014-09-03
	abstract = The Gauss-Jordan algorithm states that any matrix over a field can be transformed by means of elementary row operations to a matrix in reduced row echelon form. The formalization is based on the Rank Nullity Theorem entry of the AFP and on the HOL-Multivariate-Analysis session of Isabelle, where matrices are represented as functions over finite types. We have set up the code generator to make this representation executable. In order to improve the performance, a refinement to immutable arrays has been carried out. We have formalized some of the applications of the Gauss-Jordan algorithm. Thanks to this development, the following facts can be computed over matrices whose elements belong to a field: Ranks, Determinants, Inverses, Bases and dimensions and Solutions of systems of linear equations. Code can be exported to SML and Haskell.
	notify = jose.divasonm@unirioja.es, jesus-maria.aransay@unirioja.es

	[Echelon_Form]
	title = Echelon Form
	author = Jose Divasón <http://www.unirioja.es/cu/jodivaso>, Jesús Aransay <http://www.unirioja.es/cu/jearansa>
	topic = Computer Science/Algorithms, Mathematics/Algebra
	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.
	notify = jose.divasonm@unirioja.es, jesus-maria.aransay@unirioja.es

	[QR_Decomposition]
	title = QR Decomposition
	author = Jose Divasón <http://www.unirioja.es/cu/jodivaso>, Jesús Aransay <http://www.unirioja.es/cu/jearansa>
	topic = Computer Science/Algorithms, Mathematics/Algebra
	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.
	extra-history =
	Change history:
	[2015-06-18]: The second part of the Fundamental Theorem of Linear Algebra has been generalized to more general inner product spaces.
	notify = jose.divasonm@unirioja.es, jesus-maria.aransay@unirioja.es

	[Hermite]
	title = Hermite Normal Form
	author = Jose Divasón <http://www.unirioja.es/cu/jodivaso>, Jesús Aransay <http://www.unirioja.es/cu/jearansa>
	topic = Computer Science/Algorithms, Mathematics/Algebra
	date = 2015-07-07
	abstract = Hermite Normal Form is a canonical matrix analogue of Reduced Echelon Form, but involving matrices over more general rings. In this work we formalise an algorithm to compute the Hermite Normal Form of a matrix by means of elementary row operations, taking advantage of the Echelon Form AFP entry. We have proven the correctness of such an algorithm and refined it to immutable arrays. Furthermore, we have also formalised the uniqueness of the Hermite Normal Form of a matrix. Code can be exported and some examples of execution involving integer matrices and polynomial matrices are presented as well.
	notify = jose.divasonm@unirioja.es, jesus-maria.aransay@unirioja.es

	[Imperative_Insertion_Sort]
	title = Imperative Insertion Sort
	author = Christian Sternagel <mailto:c.sternagel@gmail.com>
	date = 2014-09-25
	topic = Computer Science/Algorithms
	abstract = The insertion sort algorithm of Cormen et al. (Introduction to Algorithms) is expressed in Imperative HOL and proved to be correct and terminating. For this purpose we also provide a theory about imperative loop constructs with accompanying induction/invariant rules for proving partial and total correctness. Furthermore, the formalized algorithm is fit for code generation.
	notify = lp15@cam.ac.uk

	[Stream_Fusion_Code]
	title = Stream Fusion in HOL with Code Generation
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>, Alexandra Maximova <mailto:amaximov@student.ethz.ch>
	date = 2014-10-10
	topic = Computer Science/Functional Programming
	abstract = Stream Fusion is a system for removing intermediate list data structures from functional programs, in particular Haskell. This entry adapts stream fusion to Isabelle/HOL and its code generator. We define stream types for finite and possibly infinite lists and stream versions for most of the fusible list functions in the theories List and Coinductive_List, and prove them correct with respect to the conversion functions between lists and streams. The Stream Fusion transformation itself is implemented as a simproc in the preprocessor of the code generator. [Brian Huffman's <a href="http://isa-afp.org/entries/Stream-Fusion.html">AFP entry</a> formalises stream fusion in HOLCF for the domain of lazy lists to prove the GHC compiler rewrite rules correct. In contrast, this work enables Isabelle's code generator to perform stream fusion itself. To that end, it covers both finite and coinductive lists from the HOL library and the Coinductive entry. The fusible list functions require specification and proof principles different from Huffman's.]
	notify = mail@andreas-lochbihler.de

	[Case_Labeling]
	title = Generating Cases from Labeled Subgoals
	author = Lars Noschinski <http://www21.in.tum.de/~noschinl/>
	date = 2015-07-21
	topic = Tools, Computer Science/Programming Languages/Misc
	abstract =
	Isabelle/Isar provides named cases to structure proofs. This article
	contains an implementation of a proof method <tt>casify</tt>, which can
	be used to easily extend proof tools with support for named cases. Such
	a proof tool must produce labeled subgoals, which are then interpreted
	by <tt>casify</tt>.
	<p>
	As examples, this work contains verification condition generators
	producing named cases for three languages: The Hoare language from
	<tt>HOL/Library</tt>, a monadic language for computations with failure
	(inspired by the AutoCorres tool), and a language of conditional
	expressions. These VCGs are demonstrated by a number of example programs.
	notify = noschinl@in.tum.de

	[DPT-SAT-Solver]
	title = A Fast SAT Solver for Isabelle in Standard ML
	topic = Tools
	author = Armin Heller <>
	date = 2009-12-09
	abstract = This contribution contains a fast SAT solver for Isabelle written in Standard ML. By loading the theory <tt>DPT_SAT_Solver</tt>, the SAT solver installs itself (under the name ``dptsat'') and certain Isabelle tools like Refute will start using it automatically. This is a port of the DPT (Decision Procedure Toolkit) SAT Solver written in OCaml.
	notify = jasmin.blanchette@gmail.com

	[Rep_Fin_Groups]
	title = Representations of Finite Groups
	topic = Mathematics/Algebra
	author = Jeremy Sylvestre <http://ualberta.ca/~jsylvest/>
	date = 2015-08-12
	abstract = We provide a formal framework for the theory of representations of finite groups, as modules over the group ring. Along the way, we develop the general theory of groups (relying on the group_add class for the basics), modules, and vector spaces, to the extent required for theory of group representations. We then provide formal proofs of several important introductory theorems in the subject, including Maschke's theorem, Schur's lemma, and Frobenius reciprocity. We also prove that every irreducible representation is isomorphic to a submodule of the group ring, leading to the fact that for a finite group there are only finitely many isomorphism classes of irreducible representations. In all of this, no restriction is made on the characteristic of the ring or field of scalars until the definition of a group representation, and then the only restriction made is that the characteristic must not divide the order of the group.
	notify = jsylvest@ualberta.ca

	[Noninterference_Inductive_Unwinding]
	title = The Inductive Unwinding Theorem for CSP Noninterference Security
	topic = Computer Science/Security
	author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
	date = 2015-08-18
	abstract =
	<p>
	The necessary and sufficient condition for CSP noninterference security stated by the Ipurge Unwinding Theorem is expressed in terms of a pair of event lists varying over the set of process traces. This does not render it suitable for the subsequent application of rule induction in the case of a process defined inductively, since rule induction may rather be applied to a single variable ranging over an inductively defined set.
	</p><p>
	Starting from the Ipurge Unwinding Theorem, this paper derives a necessary and sufficient condition for CSP noninterference security that involves a single event list varying over the set of process traces, and is thus suitable for rule induction; hence its name, Inductive Unwinding Theorem. Similarly to the Ipurge Unwinding Theorem, the new theorem only requires to consider individual accepted and refused events for each process trace, and applies to the general case of a possibly intransitive noninterference policy. Specific variants of this theorem are additionally proven for deterministic processes and trace set processes.
	</p>
	notify = pasquale.noce.lavoro@gmail.com

	[Password_Authentication_Protocol]
	title = Verification of a Diffie-Hellman Password-based Authentication Protocol by Extending the Inductive Method
	author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
	topic = Computer Science/Security
	date = 2017-01-03
	notify = pasquale.noce.lavoro@gmail.com
	abstract =
	This paper constructs a formal model of a Diffie-Hellman
	password-based authentication protocol between a user and a smart
	card, and proves its security. The protocol provides for the dispatch
	of the user's password to the smart card on a secure messaging
	channel established by means of Password Authenticated Connection
	Establishment (PACE), where the mapping method being used is Chip
	Authentication Mapping. By applying and suitably extending
	Paulson's Inductive Method, this paper proves that the protocol
	establishes trustworthy secure messaging channels, preserves the
	secrecy of users' passwords, and provides an effective mutual
	authentication service. What is more, these security properties turn
	out to hold independently of the secrecy of the PACE authentication
	key.

	[Jordan_Normal_Form]
	title = Matrices, Jordan Normal Forms, and Spectral Radius Theory
	topic = Mathematics/Algebra
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>, Akihisa Yamada <mailto:akihisa.yamada@uibk.ac.at>
	contributors = Alexander Bentkamp <mailto:bentkamp@gmail.com>
	date = 2015-08-21
	abstract =
	<p>
	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.
	</p><p>
	To formally prove this result we first studied the growth rates of matrices in Jordan normal form, and prove the result that every complex matrix has a Jordan normal form using a constructive prove via Schur decomposition.
	</p><p>
	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.
	</p><p>
	All the results have been applied to improve CeTA, our certifier to validate termination and complexity proof certificates.
	</p>
	extra-history =
	Change history:
	[2016-01-07]: Added Schur-decomposition, Gram-Schmidt orthogonalization, uniqueness of Jordan normal forms<br/>
	[2018-04-17]: Integrated lemmas from deep-learning AFP-entry of Alexander Bentkamp
	notify = rene.thiemann@uibk.ac.at, ayamada@trs.cm.is.nagoya-u.ac.jp

	[LTL_to_DRA]
	title = Converting Linear Temporal Logic to Deterministic (Generalized) Rabin Automata
	topic = Computer Science/Automata and Formal Languages
	author = Salomon Sickert <mailto:sickert@in.tum.de>
	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.
	extra-history =
	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.<br>
	[2016-03-24]: Make use of the LTL entry and include the simplifier.
	notify = sickert@in.tum.de

	[Timed_Automata]
	title = Timed Automata
	author = Simon Wimmer <http://in.tum.de/~wimmers>
	date = 2016-03-08
	topic = Computer Science/Automata and Formal Languages
	abstract =
	Timed automata are a widely used formalism for modeling real-time
	systems, which is employed in a class of successful model checkers
	such as UPPAAL [LPY97], HyTech [HHWt97] or Kronos [Yov97]. This work
	formalizes the theory for the subclass of diagonal-free timed
	automata, which is sufficient to model many interesting problems. We
	first define the basic concepts and semantics of diagonal-free timed
	automata. Based on this, we prove two types of decidability results
	for the language emptiness problem. The first is the classic result
	of Alur and Dill [AD90, AD94], which uses a finite partitioning of
	the state space into so-called `regions`. Our second result focuses
	on an approach based on `Difference Bound Matrices (DBMs)`, which is
	practically used by model checkers. We prove the correctness of the
	basic forward analysis operations on DBMs. One of these operations is
	the Floyd-Warshall algorithm for the all-pairs shortest paths problem.
	To obtain a finite search space, a widening operation has to be used
	for this kind of analysis. We use Patricia Bouyer's [Bou04] approach
	to prove that this widening operation is correct in the sense that
	DBM-based forward analysis in combination with the widening operation
	also decides language emptiness. The interesting property of this
	proof is that the first decidability result is reused to obtain the
	second one.
	notify = wimmers@in.tum.de

	[Parity_Game]
	title = Positional Determinacy of Parity Games
	author = Christoph Dittmann <http://logic.las.tu-berlin.de/Members/Dittmann/>
	date = 2015-11-02
	topic = Computer Science/Games
	abstract =
	We present a formalization of parity games (a two-player game on
	directed graphs) and a proof of their positional determinacy in
	Isabelle/HOL. This proof works for both finite and infinite games.
	notify =

	[Ergodic_Theory]
	title = Ergodic Theory
	author = Sebastien Gouezel <mailto:sebastien.gouezel@univ-rennes1.fr>
	date = 2015-12-01
	topic = Mathematics/Probability Theory
	abstract = Ergodic theory is the branch of mathematics that studies the behaviour of measure preserving transformations, in finite or infinite measure. It interacts both with probability theory (mainly through measure theory) and with geometry as a lot of interesting examples are from geometric origin. We implement the first definitions and theorems of ergodic theory, including notably Poicaré recurrence theorem for finite measure preserving systems (together with the notion of conservativity in general), induced maps, Kac's theorem, Birkhoff theorem (arguably the most important theorem in ergodic theory), and variations around it such as conservativity of the corresponding skew product, or Atkinson lemma.
	notify = sebastien.gouezel@univ-rennes1.fr, hoelzl@in.tum.de

	[Latin_Square]
	title = Latin Square
	author = Alexander Bentkamp <mailto:bentkamp@gmail.com>
	date = 2015-12-02
	topic = Mathematics/Combinatorics
	abstract =
	A Latin Square is a n x n table filled with integers from 1 to n where each number appears exactly once in each row and each column. A Latin Rectangle is a partially filled n x n table with r filled rows and n-r empty rows, such that each number appears at most once in each row and each column. The main result of this theory is that any Latin Rectangle can be completed to a Latin Square.
	notify = bentkamp@gmail.com

	[Deep_Learning]
	title = Expressiveness of Deep Learning
	author = Alexander Bentkamp <mailto:bentkamp@gmail.com>
	date = 2016-11-10
	topic = Computer Science/Algorithms
	abstract =
	Deep learning has had a profound impact on computer science in recent years, with applications to search engines, image recognition and language processing, bioinformatics, and more. Recently, Cohen et al. provided theoretical evidence for the superiority of deep learning over shallow learning. This formalization of their work simplifies and generalizes the original proof, while working around the limitations of the Isabelle type system. To support the formalization, I developed reusable libraries of formalized mathematics, including results about the matrix rank, the Lebesgue measure, and multivariate polynomials, as well as a library for tensor analysis.
	notify = bentkamp@gmail.com

	[Applicative_Lifting]
	title = Applicative Lifting
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>, Joshua Schneider <>
	date = 2015-12-22
	topic = Computer Science/Functional Programming
	abstract = Applicative functors augment computations with effects by lifting function application to types which model the effects. As the structure of the computation cannot depend on the effects, applicative expressions can be analysed statically. This allows us to lift universally quantified equations to the effectful types, as observed by Hinze. Thus, equational reasoning over effectful computations can be reduced to pure types.
	</p><p>
	This entry provides a package for registering applicative functors and two proof methods for lifting of equations over applicative functors. The first method normalises applicative expressions according to the laws of applicative functors. This way, equations whose two sides contain the same list of variables can be lifted to every applicative functor.
	</p><p>
	To lift larger classes of equations, the second method exploits a number of additional properties (e.g., commutativity of effects) provided the properties have been declared for the concrete applicative functor at hand upon registration.
	</p><p>
	We declare several types from the Isabelle library as applicative functors and illustrate the use of the methods with two examples: the lifting of the arithmetic type class hierarchy to streams and the verification of a relabelling function on binary trees. We also formalise and verify the normalisation algorithm used by the first proof method.
	</p>
	extra-history =
	Change history:
	[2016-03-03]: added formalisation of lifting with combinators<br>
	[2016-06-10]:
	implemented automatic derivation of lifted combinator reductions;
	support arbitrary lifted relations using relators;
	improved compatibility with locale interpretation
	(revision ec336f354f37)<br>
	notify = mail@andreas-lochbihler.de

	[Stern_Brocot]
	title = The Stern-Brocot Tree
	author = Peter Gammie <http://peteg.org>, Andreas Lochbihler <http://www.andreas-lochbihler.de>
	date = 2015-12-22
	topic = Mathematics/Number Theory
	abstract = The Stern-Brocot tree contains all rational numbers exactly once and in their lowest terms. We formalise the Stern-Brocot tree as a coinductive tree using recursive and iterative specifications, which we have proven equivalent, and show that it indeed contains all the numbers as stated. Following Hinze, we prove that the Stern-Brocot tree can be linearised looplessly into Stern's diatonic sequence (also known as Dijkstra's fusc function) and that it is a permutation of the Bird tree.
	</p><p>
	The reasoning stays at an abstract level by appealing to the uniqueness of solutions of guarded recursive equations and lifting algebraic laws point-wise to trees and streams using applicative functors.
	</p>
	notify = mail@andreas-lochbihler.de

	[Algebraic_Numbers]
	title = Algebraic Numbers in Isabelle/HOL
	topic = Mathematics/Algebra
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>, Akihisa Yamada <mailto:akihisa.yamada@uibk.ac.at>, Sebastiaan Joosten <mailto:sebastiaan.joosten@uibk.ac.at>
	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.
	</p><p>
	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.
	</p>
	extra-history =
	Change history:
	[2016-01-29]: Split off Polynomial Interpolation and Polynomial Factorization<br>
	[2017-04-16]: Use certified Berlekamp-Zassenhaus factorization, use subresultant algorithm for computing resultants, improved bisection algorithm
	notify = rene.thiemann@uibk.ac.at, ayamada@trs.cm.is.nagoya-u.ac.jp, sebastiaan.joosten@uibk.ac.at

	[Polynomial_Interpolation]
	title = Polynomial Interpolation
	topic = Mathematics/Algebra
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>, Akihisa Yamada <mailto:akihisa.yamada@uibk.ac.at>
	date = 2016-01-29
	abstract =
	We formalized three algorithms for polynomial interpolation over arbitrary
	fields: Lagrange's explicit expression, the recursive algorithm of Neville
	and Aitken, and the Newton interpolation in combination with an efficient
	implementation of divided differences. Variants of these algorithms for
	integer polynomials are also available, where sometimes the interpolation
	can fail; e.g., there is no linear integer polynomial <i>p</i> such that
	<i>p(0) = 0</i> and <i>p(2) = 1</i>. Moreover, for the Newton interpolation
	for integer polynomials, we proved that all intermediate results that are
	computed during the algorithm must be integers. This admits an early
	failure detection in the implementation. Finally, we proved the uniqueness
	of polynomial interpolation.
	<p>
	The development also contains improved code equations to speed up the
	division of integers in target languages.
	notify = rene.thiemann@uibk.ac.at, ayamada@trs.cm.is.nagoya-u.ac.jp

	[Polynomial_Factorization]
	title = Polynomial Factorization
	topic = Mathematics/Algebra
	author = René Thiemann <mailto:rene.thiemann@uibk.ac.at>, Akihisa Yamada <mailto:akihisa.yamada@uibk.ac.at>
	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.
	<p>
	As side products, we developed division algorithms for polynomials over integral domains,
	as well as primality-testing and prime-factorization algorithms for integers.
	notify = rene.thiemann@uibk.ac.at, ayamada@trs.cm.is.nagoya-u.ac.jp

	[Perron_Frobenius]
	title = Perron-Frobenius Theorem for Spectral Radius Analysis
	author = Jose Divasón <http://www.unirioja.es/cu/jodivaso>, Ondřej Kunčar <http://www21.in.tum.de/~kuncar/>, René Thiemann <mailto:rene.thiemann@uibk.ac.at>, Akihisa Yamada <mailto:akihisa.yamada@uibk.ac.at>
	notify = rene.thiemann@uibk.ac.at
	date = 2016-05-20
	topic = Mathematics/Algebra
	abstract =
	<p>The spectral radius of a matrix A is the maximum norm of all
	eigenvalues of A. In previous work we already formalized that for a
	complex matrix A, the values in A<sup>n</sup> grow polynomially in n
	if and only if the spectral radius is at most one. One problem with
	the above characterization is the determination of all
	<em>complex</em> eigenvalues. In case A contains only non-negative
	real values, a simplification is possible with the help of the
	Perron–Frobenius theorem, which tells us that it suffices to consider only
	the <em>real</em> eigenvalues of A, i.e., applying Sturm's method can
	decide the polynomial growth of A<sup>n</sup>. </p><p> We formalize
	the Perron–Frobenius theorem based on a proof via Brouwer's fixpoint
	theorem, which is available in the HOL multivariate analysis (HMA)
	library. Since the results on the spectral radius is based on matrices
	in the Jordan normal form (JNF) library, we further develop a
	connection which allows us to easily transfer theorems between HMA and
	JNF. With this connection we derive the combined result: if A is a
	non-negative real matrix, and no real eigenvalue of A is strictly
	larger than one, then A<sup>n</sup> is polynomially bounded in n. </p>
	extra-history =
	Change history:
	[2017-10-18]:
	added Perron-Frobenius theorem for irreducible matrices with generalization
	(revision bda1f1ce8a1c)<br/>
	[2018-05-17]:
	prove conjecture of CPP'18 paper: Jordan blocks of spectral radius have maximum size
	(revision ffdb3794e5d5)

	[Stochastic_Matrices]
	title = Stochastic Matrices and the Perron-Frobenius Theorem
	author = René Thiemann <http://cl-informatik.uibk.ac.at/~thiemann>
	topic = Mathematics/Algebra, Computer Science/Automata and Formal Languages
	date = 2017-11-22
	notify = rene.thiemann@uibk.ac.at
	abstract =
	Stochastic matrices are a convenient way to model discrete-time and
	finite state Markov chains. The Perron–Frobenius theorem
	tells us something about the existence and uniqueness of non-negative
	eigenvectors of a stochastic matrix. In this entry, we formalize
	stochastic matrices, link the formalization to the existing AFP-entry
	on Markov chains, and apply the Perron–Frobenius theorem to
	prove that stationary distributions always exist, and they are unique
	if the stochastic matrix is irreducible.

	[Formal_SSA]
	title = Verified Construction of Static Single Assignment Form
	author = Sebastian Ullrich <mailto:sebasti@nullri.ch>, Denis Lohner <http://pp.ipd.kit.edu/person.php?id=88>
	date = 2016-02-05
	topic = Computer Science/Algorithms, Computer Science/Programming Languages/Transformations
	abstract =
	<p>
	We define a functional variant of the static single assignment (SSA)
	form construction algorithm described by <a
	href="https://doi.org/10.1007/978-3-642-37051-9_6">Braun et al.</a>,
	which combines simplicity and efficiency. The definition is based on a
	general, abstract control flow graph representation using Isabelle locales.
	</p>
	<p>
	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.
	</p>
	<p>
	Furthermore, we use a generic instantiation based on typedefs in order
	to extract OCaml code and replace the unverified SSA construction
	algorithm of the <a href="https://doi.org/10.1145/2579080">CompCertSSA
	project</a> with it.
	</p>
	<p>
	A more detailed description of the verified SSA construction can be found
	in the paper <a href="https://doi.org/10.1145/2892208.2892211">Verified
	Construction of Static Single Assignment Form</a>, CC 2016.
	</p>
	notify = denis.lohner@kit.edu

	[Minimal_SSA]
	title = Minimal Static Single Assignment Form
	author = Max Wagner <mailto:max@trollbu.de>, Denis Lohner <http://pp.ipd.kit.edu/person.php?id=88>
	topic = Computer Science/Programming Languages/Transformations
	date = 2017-01-17
	notify = denis.lohner@kit.edu
	abstract =
	<p>This formalization is an extension to <a
	href="https://www.isa-afp.org/entries/Formal_SSA.html">"Verified
	Construction of Static Single Assignment Form"</a>. In
	their work, the authors have shown that <a
	href="https://doi.org/10.1007/978-3-642-37051-9_6">Braun
	et al.'s static single assignment (SSA) construction
	algorithm</a> produces minimal SSA form for input programs with
	a reducible control flow graph (CFG). However Braun et al. also
	proposed an extension to their algorithm that they claim produces
	minimal SSA form even for irreducible CFGs.<br> In this
	formalization we support that claim by giving a mechanized proof.
	</p>
	<p>As the extension of Braun et al.'s algorithm
	aims for removing so-called redundant strongly connected components of
	phi functions, we show that this suffices to guarantee minimality
	according to <a href="https://doi.org/10.1145/115372.115320">Cytron et
	al.</a>.</p>

	[PropResPI]
	title = Propositional Resolution and Prime Implicates Generation
	author = Nicolas Peltier <http://membres-lig.imag.fr/peltier/>
	notify = Nicolas.Peltier@imag.fr
	date = 2016-03-11
	topic = Logic
	abstract =
	We provide formal proofs in Isabelle-HOL (using mostly structured Isar
	proofs) of the soundness and completeness of the Resolution rule in
	propositional logic. The completeness proofs take into account the
	usual redundancy elimination rules (tautology elimination and
	subsumption), and several refinements of the Resolution rule are
	considered: ordered resolution (with selection functions), positive
	and negative resolution, semantic resolution and unit resolution (the
	latter refinement is complete only for clause sets that are Horn-
	renamable). We also define a concrete procedure for computing
	saturated sets and establish its soundness and completeness. The
	clause sets are not assumed to be finite, so that the results can be
	applied to formulas obtained by grounding sets of first-order clauses
	(however, a total ordering among atoms is assumed to be given).
	Next, we show that the unrestricted Resolution rule is deductive-
	complete, in the sense that it is able to generate all (prime)
	implicates of any set of propositional clauses (i.e., all entailment-
	minimal, non-valid, clausal consequences of the considered set). The
	generation of prime implicates is an important problem, with many
	applications in artificial intelligence and verification (for
	abductive reasoning, knowledge compilation, diagnosis, debugging
	etc.). We also show that implicates can be computed in an incremental
	way, by fixing an ordering among all the atoms in the considered sets
	and resolving upon these atoms one by one in the considered order
	(with no backtracking). This feature is critical for the efficient
	computation of prime implicates. Building on these results, we provide
	a procedure for computing such implicates and establish its soundness
	and completeness.

	[SuperCalc]
	title = A Variant of the Superposition Calculus
	author = Nicolas Peltier <http://membres-lig.imag.fr/peltier/>
	notify = Nicolas.Peltier@imag.fr
	date = 2016-09-06
	topic = Logic
	abstract =
	We provide a formalization of a variant of the superposition
	calculus, together with formal proofs of soundness and refutational
	completeness (w.r.t. the usual redundancy criteria based on clause
	ordering). This version of the calculus uses all the standard
	restrictions of the superposition rules, together with the following
	refinement, inspired by the basic superposition calculus: each clause
	is associated with a set of terms which are assumed to be in normal
	form -- thus any application of the replacement rule on these terms is
	blocked. The set is initially empty and terms may be added or removed
	at each inference step. The set of terms that are assumed to be in
	normal form includes any term introduced by previous unifiers as well
	as any term occurring in the parent clauses at a position that is
	smaller (according to some given ordering on positions) than a
	previously replaced term. The standard superposition calculus
	corresponds to the case where the set of irreducible terms is always
	empty.

	[Nominal2]
	title = Nominal 2
	author = Christian Urban <http://www.inf.kcl.ac.uk/staff/urbanc/>, Stefan Berghofer <http://www.in.tum.de/~berghofe>, Cezary Kaliszyk <http://cl-informatik.uibk.ac.at/users/cek/>
	date = 2013-02-21
	topic = Tools
	abstract =
	<p>Dealing with binders, renaming of bound variables, capture-avoiding
	substitution, etc., is very often a major problem in formal
	proofs, especially in proofs by structural and rule
	induction. Nominal Isabelle is designed to make such proofs easy to
	formalise: it provides an infrastructure for declaring nominal
	datatypes (that is alpha-equivalence classes) and for defining
	functions over them by structural recursion. It also provides
	induction principles that have Barendregt’s variable convention
	already built in.
	</p><p>
	This entry can be used as a more advanced replacement for
	HOL/Nominal in the Isabelle distribution.
	</p>
	notify = christian.urban@kcl.ac.uk

	[First_Welfare_Theorem]
	title = Microeconomics and the First Welfare Theorem
	author = Julian Parsert <mailto:julian.parsert@gmail.com>, Cezary Kaliszyk<http://cl-informatik.uibk.ac.at/users/cek/>
	topic = Mathematics/Economics
	license = LGPL
	date = 2017-09-01
	notify = julian.parsert@uibk.ac.at, cezary.kaliszyk@uibk.ac.at
	abstract =
	Economic activity has always been a fundamental part of society. Due
	to modern day politics, economic theory has gained even more influence
	on our lives. Thus we want models and theories to be as precise as
	possible. This can be achieved using certification with the help of
	formal proof technology. Hence we will use Isabelle/HOL to construct
	two economic models, that of the the pure exchange economy and a
	version of the Arrow-Debreu Model. We will prove that the
	<i>First Theorem of Welfare Economics</i> holds within
	both. The theorem is the mathematical formulation of Adam Smith's
	famous <i>invisible hand</i> and states that a group of
	self-interested and rational actors will eventually achieve an
	efficient allocation of goods and services.
	extra-history =
	Change history:
	[2018-06-17]: Added some lemmas and a theory file, also introduced Microeconomics folder.
	<br>

	[Noninterference_Sequential_Composition]
	title = Conservation of CSP Noninterference Security under Sequential Composition
	author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
	date = 2016-04-26
	topic = Computer Science/Security, Computer Science/Concurrency/Process Calculi
	abstract =
	<p>In his outstanding work on Communicating Sequential Processes, Hoare
	has defined two fundamental binary operations allowing to compose the
	input processes into another, typically more complex, process:
	sequential composition and concurrent composition. Particularly, the
	output of the former operation is a process that initially behaves
	like the first operand, and then like the second operand once the
	execution of the first one has terminated successfully, as long as it
	does.</p>
	<p>This paper formalizes Hoare's definition of sequential
	composition and proves, in the general case of a possibly intransitive
	policy, that CSP noninterference security is conserved under this
	operation, provided that successful termination cannot be affected by
	confidential events and cannot occur as an alternative to other events
	in the traces of the first operand. Both of these assumptions are
	shown, by means of counterexamples, to be necessary for the theorem to
	hold.</p>
	notify = pasquale.noce.lavoro@gmail.com

	[Noninterference_Concurrent_Composition]
	title = Conservation of CSP Noninterference Security under Concurrent Composition
	author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
	notify = pasquale.noce.lavoro@gmail.com
	date = 2016-06-13
	topic = Computer Science/Security, Computer Science/Concurrency/Process Calculi
	abstract =
	<p>In his outstanding work on Communicating Sequential Processes,
	Hoare has defined two fundamental binary operations allowing to
	compose the input processes into another, typically more complex,
	process: sequential composition and concurrent composition.
	Particularly, the output of the latter operation is a process in which
	any event not shared by both operands can occur whenever the operand
	that admits the event can engage in it, whereas any event shared by
	both operands can occur just in case both can engage in it.</p>
	<p>This paper formalizes Hoare's definition of concurrent composition
	and proves, in the general case of a possibly intransitive policy,
	that CSP noninterference security is conserved under this operation.
	This result, along with the previous analogous one concerning
	sequential composition, enables the construction of more and more
	complex processes enforcing noninterference security by composing,
	sequentially or concurrently, simpler secure processes, whose security
	can in turn be proven using either the definition of security, or
	unwinding theorems.</p>

	[ROBDD]
	title = Algorithms for Reduced Ordered Binary Decision Diagrams
	author = Julius Michaelis <http://liftm.de>, Maximilian Haslbeck <https://home.in.tum.de/~haslbecm/>, Peter Lammich <http://www21.in.tum.de/~lammich>, Lars Hupel <https://www21.in.tum.de/~hupel/>
	date = 2016-04-27
	topic = Computer Science/Algorithms, Computer Science/Data Structures
	abstract =
	We present a verified and executable implementation of ROBDDs in
	Isabelle/HOL. Our implementation relates pointer-based computation in
	the Heap monad to operations on an abstract definition of boolean
	functions. Internally, we implemented the if-then-else combinator in a
	recursive fashion, following the Shannon decomposition of the argument
	functions. The implementation mixes and adapts known techniques and is
	built with efficiency in mind.
	notify = bdd@liftm.de, haslbecm@in.tum.de

	[No_FTL_observers]
	title = No Faster-Than-Light Observers
	author = Mike Stannett <mailto:m.stannett@sheffield.ac.uk>, István Németi <http://www.renyi.hu/~nemeti/>
	date = 2016-04-28
	topic = Mathematics/Physics
	abstract =
	We provide a formal proof within First Order Relativity Theory that no
	observer can travel faster than the speed of light. Originally
	reported in Stannett & Németi (2014) "Using Isabelle/HOL to verify
	first-order relativity theory", Journal of Automated Reasoning 52(4),
	pp. 361-378.
	notify = m.stannett@sheffield.ac.uk

	[Groebner_Bases]
	title = Gröbner Bases Theory
	author = Fabian Immler <http://www21.in.tum.de/~immler>, Alexander Maletzky <https://risc.jku.at/m/alexander-maletzky/>
	date = 2016-05-02
	topic = Mathematics/Algebra, Computer Science/Algorithms
	abstract =
	This formalization is concerned with the theory of Gröbner bases in
	(commutative) multivariate polynomial rings over fields, originally
	developed by Buchberger in his 1965 PhD thesis. Apart from the
	statement and proof of the main theorem of the theory, the
	formalization also implements Buchberger's algorithm for actually
	computing Gröbner bases as a tail-recursive function, thus allowing to
	effectively decide ideal membership in finitely generated polynomial
	ideals. Furthermore, all functions can be executed on a concrete
	representation of multivariate polynomials as association lists.
	extra-history =
	Change history:
	[2019-04-18]: Specialized Gröbner bases to less abstract representation of polynomials, where
	power-products are represented as polynomial mappings.<br>
	notify = alexander.maletzky@risc.jku.at

	+[Nullstellensatz]
	+title = Hilbert's Nullstellensatz
	+author = Alexander Maletzky <https://risc.jku.at/m/alexander-maletzky/>
	+topic = Mathematics/Algebra, Mathematics/Geometry
	+date = 2019-06-16
	+notify = alexander.maletzky@risc-software.at
	+abstract =
	+ This entry formalizes Hilbert's Nullstellensatz, an important
	+ theorem in algebraic geometry that can be viewed as the generalization
	+ of the Fundamental Theorem of Algebra to multivariate polynomials: If
	+ a set of (multivariate) polynomials over an algebraically closed field
	+ has no common zero, then the ideal it generates is the entire
	+ polynomial ring. The formalization proves several equivalent versions
	+ of this celebrated theorem: the weak Nullstellensatz, the strong
	+ Nullstellensatz (connecting algebraic varieties and radical ideals),
	+ and the field-theoretic Nullstellensatz. The formalization follows
	+ Chapter 4.1. of <a
	+ href="https://link.springer.com/book/10.1007/978-0-387-35651-8">Ideals,
	+ Varieties, and Algorithms</a> by Cox, Little and O'Shea.
	+
	[Bell_Numbers_Spivey]
	title = Spivey's Generalized Recurrence for Bell Numbers
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	date = 2016-05-04
	topic = Mathematics/Combinatorics
	abstract =
	This entry defines the Bell numbers as the cardinality of set partitions for
	a carrier set of given size, and derives Spivey's generalized recurrence
	relation for Bell numbers following his elegant and intuitive combinatorial
	proof.
	<p>
	As the set construction for the combinatorial proof requires construction of
	three intermediate structures, the main difficulty of the formalization is
	handling the overall combinatorial argument in a structured way.
	The introduced proof structure allows us to compose the combinatorial argument
	from its subparts, and supports to keep track how the detailed proof steps are
	related to the overall argument. To obtain this structure, this entry uses set
	monad notation for the set construction's definition, introduces suitable
	predicates and rules, and follows a repeating structure in its Isar proof.
	notify = lukas.bulwahn@gmail.com

	[Randomised_Social_Choice]
	title = Randomised Social Choice Theory
	author = Manuel Eberl <mailto:eberlm@in.tum.de>
	date = 2016-05-05
	topic = Mathematics/Economics
	abstract =
	This work contains a formalisation of basic Randomised Social Choice,
	including Stochastic Dominance and Social Decision Schemes (SDSs)
	along with some of their most important properties (Anonymity,
	Neutrality, ex-post- and SD-Efficiency, SD-Strategy-Proofness) and two
	particular SDSs – Random Dictatorship and Random Serial Dictatorship
	(with proofs of the properties that they satisfy). Many important
	properties of these concepts are also proven – such as the two
	equivalent characterisations of Stochastic Dominance and the fact that
	SD-efficiency of a lottery only depends on the support. The entry
	also provides convenient commands to define Preference Profiles, prove
	their well-formedness, and automatically derive restrictions that
	sufficiently nice SDSs need to satisfy on the defined profiles.
	Currently, the formalisation focuses on weak preferences and
	Stochastic Dominance, but it should be easy to extend it to other
	domains – such as strict preferences – or other lottery extensions –
	such as Bilinear Dominance or Pairwise Comparison.
	notify = eberlm@in.tum.de

	[SDS_Impossibility]
	title = The Incompatibility of SD-Efficiency and SD-Strategy-Proofness
	author = Manuel Eberl <mailto:eberlm@in.tum.de>
	date = 2016-05-04
	topic = Mathematics/Economics
	abstract =
	This formalisation contains the proof that there is no anonymous and
	neutral Social Decision Scheme for at least four voters and
	alternatives that fulfils both SD-Efficiency and SD-Strategy-
	Proofness. The proof is a fully structured and quasi-human-redable
	one. It was derived from the (unstructured) SMT proof of the case for
	exactly four voters and alternatives by Brandl et al. Their proof
	relies on an unverified translation of the original problem to SMT,
	and the proof that lifts the argument for exactly four voters and
	alternatives to the general case is also not machine-checked. In this
	Isabelle proof, on the other hand, all of these steps are fully
	proven and machine-checked. This is particularly important seeing as a
	previously published informal proof of a weaker statement contained a
	mistake in precisely this lifting step.
	notify = eberlm@in.tum.de

	[Median_Of_Medians_Selection]
	title = The Median-of-Medians Selection Algorithm
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Computer Science/Algorithms
	date = 2017-12-21
	notify = eberlm@in.tum.de
	abstract =
	<p>This entry provides an executable functional implementation
	of the Median-of-Medians algorithm for selecting the
	<em>k</em>-th smallest element of an unsorted list
	deterministically in linear time. The size bounds for the recursive
	call that lead to the linear upper bound on the run-time of the
	algorithm are also proven. </p>

	[Mason_Stothers]
	title = The Mason–Stothers Theorem
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Algebra
	date = 2017-12-21
	notify = eberlm@in.tum.de
	abstract =
	<p>This article provides a formalisation of Snyder’s simple and
	elegant proof of the Mason–Stothers theorem, which is the
	polynomial analogue of the famous abc Conjecture for integers.
	Remarkably, Snyder found this very elegant proof when he was still a
	high-school student.</p> <p>In short, the statement of the
	theorem is that three non-zero coprime polynomials
	<em>A</em>, <em>B</em>, <em>C</em>
	over a field which sum to 0 and do not all have vanishing derivatives
	fulfil max{deg(<em>A</em>), deg(<em>B</em>),
	deg(<em>C</em>)} < deg(rad(<em>ABC</em>))
	where the rad(<em>P</em>) denotes the
	<em>radical</em> of <em>P</em>,
	i. e. the product of all unique irreducible factors of
	<em>P</em>.</p> <p>This theorem also implies a
	kind of polynomial analogue of Fermat’s Last Theorem for polynomials:
	except for trivial cases,
	<em>A<sup>n</sup></em> +
	<em>B<sup>n</sup></em> +
	<em>C<sup>n</sup></em> = 0 implies
	n ≤ 2 for coprime polynomials
	<em>A</em>, <em>B</em>, <em>C</em>
	over a field.</em></p>

	[FLP]
	title = A Constructive Proof for FLP
	author = Benjamin Bisping <mailto:benjamin.bisping@campus.tu-berlin.de>, Paul-David Brodmann <mailto:p.brodmann@tu-berlin.de>, Tim Jungnickel <mailto:tim.jungnickel@tu-berlin.de>, Christina Rickmann <mailto:c.rickmann@tu-berlin.de>, Henning Seidler <mailto:henning.seidler@mailbox.tu-berlin.de>, Anke Stüber <mailto:anke.stueber@campus.tu-berlin.de>, Arno Wilhelm-Weidner <mailto:arno.wilhelm-weidner@tu-berlin.de>, Kirstin Peters <mailto:kirstin.peters@tu-berlin.de>, Uwe Nestmann <https://www.mtv.tu-berlin.de/nestmann/>
	date = 2016-05-18
	topic = Computer Science/Concurrency
	abstract =
	The impossibility of distributed consensus with one faulty process is
	a result with important consequences for real world distributed
	systems e.g., commits in replicated databases. Since proofs are not
	immune to faults and even plausible proofs with a profound formalism
	can conclude wrong results, we validate the fundamental result named
	FLP after Fischer, Lynch and Paterson.
	We present a formalization of distributed systems
	and the aforementioned consensus problem. Our proof is based on Hagen
	Völzer's paper "A constructive proof for FLP". In addition to the
	enhanced confidence in the validity of Völzer's proof, we contribute
	the missing gaps to show the correctness in Isabelle/HOL. We clarify
	the proof details and even prove fairness of the infinite execution
	that contradicts consensus. Our Isabelle formalization can also be
	reused for further proofs of properties of distributed systems.
	notify = henning.seidler@mailbox.tu-berlin.de

	[IMAP-CRDT]
	title = The IMAP CmRDT
	author = Tim Jungnickel <mailto:tim.jungnickel@tu-berlin.de>, Lennart Oldenburg <>, Matthias Loibl <>
	topic = Computer Science/Algorithms, Computer Science/Data Structures
	date = 2017-11-09
	notify = tim.jungnickel@tu-berlin.de
	abstract =
	We provide our Isabelle/HOL formalization of a Conflict-free
	Replicated Datatype for Internet Message Access Protocol commands.
	We show that Strong Eventual Consistency (SEC) is guaranteed
	by proving the commutativity of concurrent operations. We base our
	formalization on the recently proposed "framework for
	establishing Strong Eventual Consistency for Conflict-free Replicated
	Datatypes" (AFP.CRDT) from Gomes et al. Hence, we provide an
	additional example of how the recently proposed framework can be used
	to design and prove CRDTs.

	[Incredible_Proof_Machine]
	title = The meta theory of the Incredible Proof Machine
	author = Joachim Breitner <http://pp.ipd.kit.edu/~breitner>, Denis Lohner <http://pp.ipd.kit.edu/person.php?id=88>
	date = 2016-05-20
	topic = Logic
	abstract =
	The <a href="http://incredible.pm">Incredible Proof Machine</a> is an
	interactive visual theorem prover which represents proofs as port
	graphs. We model this proof representation in Isabelle, and prove that
	it is just as powerful as natural deduction.
	notify = mail@joachim-breitner.de

	[Word_Lib]
	title = Finite Machine Word Library
	author = Joel Beeren<>, Matthew Fernandez<>, Xin Gao<>, Gerwin Klein <http://www.cse.unsw.edu.au/~kleing/>, Rafal Kolanski<>, Japheth Lim<>, Corey Lewis<>, Daniel Matichuk<>, Thomas Sewell<>
	notify = kleing@unsw.edu.au
	date = 2016-06-09
	topic = Computer Science/Data Structures
	abstract =
	This entry contains an extension to the Isabelle library for
	fixed-width machine words. In particular, the entry adds quickcheck setup
	for words, printing as hexadecimals, additional operations, reasoning
	about alignment, signed words, enumerations of words, normalisation of
	word numerals, and an extensive library of properties about generic
	fixed-width words, as well as an instantiation of many of these to the
	commonly used 32 and 64-bit bases.

	[Catalan_Numbers]
	title = Catalan Numbers
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	notify = eberlm@in.tum.de
	date = 2016-06-21
	topic = Mathematics/Combinatorics
	abstract =
	<p>In this work, we define the Catalan numbers <em>C<sub>n</sub></em>
	and prove several equivalent definitions (including some closed-form
	formulae). We also show one of their applications (counting the number
	of binary trees of size <em>n</em>), prove the asymptotic growth
	approximation <em>C<sub>n</sub> &sim; 4<sup>n</sup> / (√<span
	style="text-decoration: overline">π</span> ·
	n<sup>1.5</sup>)</em>, and provide reasonably efficient executable
	code to compute them.</p> <p>The derivation of the closed-form
	formulae uses algebraic manipulations of the ordinary generating
	function of the Catalan numbers, and the asymptotic approximation is
	then done using generalised binomial coefficients and the Gamma
	function. Thanks to these highly non-elementary mathematical tools,
	the proofs are very short and simple.</p>

	[Fisher_Yates]
	title = Fisher–Yates shuffle
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	notify = eberlm@in.tum.de
	date = 2016-09-30
	topic = Computer Science/Algorithms
	abstract =
	<p>This work defines and proves the correctness of the Fisher–Yates
	algorithm for shuffling – i.e. producing a random permutation – of a
	list. The algorithm proceeds by traversing the list and in
	each step swapping the current element with a random element from the
	remaining list.</p>

	[Bertrands_Postulate]
	title = Bertrand's postulate
	author = Julian Biendarra<>, Manuel Eberl <https://www21.in.tum.de/~eberlm>
	contributors = Lawrence C. Paulson <http://www.cl.cam.ac.uk/~lp15/>
	topic = Mathematics/Number Theory
	date = 2017-01-17
	notify = eberlm@in.tum.de
	abstract =
	<p>Bertrand's postulate is an early result on the
	distribution of prime numbers: For every positive integer n, there
	exists a prime number that lies strictly between n and 2n.
	The proof is ported from John Harrison's formalisation
	in HOL Light. It proceeds by first showing that the property is true
	for all n greater than or equal to 600 and then showing that it also
	holds for all n below 600 by case distinction. </p>

	[Rewriting_Z]
	title = The Z Property
	author = Bertram Felgenhauer<>, Julian Nagele<>, Vincent van Oostrom<>, Christian Sternagel<>
	notify = bertram.felgenhauer@uibk.ac.at, julian.nagele@uibk.ac.at, c.sternagel@gmail.com
	date = 2016-06-30
	topic = Logic/Rewriting
	abstract =
	We formalize the Z property introduced by Dehornoy and van Oostrom.
	First we show that for any abstract rewrite system, Z implies
	confluence. Then we give two examples of proofs using Z: confluence of
	lambda-calculus with respect to beta-reduction and confluence of
	combinatory logic.

	[Resolution_FOL]
	title = The Resolution Calculus for First-Order Logic
	author = Anders Schlichtkrull <https://people.compute.dtu.dk/andschl>
	notify = andschl@dtu.dk
	date = 2016-06-30
	topic = Logic
	abstract =
	This theory is a formalization of the resolution calculus for
	first-order logic. It is proven sound and complete. The soundness
	proof uses the substitution lemma, which shows a correspondence
	between substitutions and updates to an environment. The completeness
	proof uses semantic trees, i.e. trees whose paths are partial Herbrand
	interpretations. It employs Herbrand's theorem in a formulation which
	states that an unsatisfiable set of clauses has a finite closed
	semantic tree. It also uses the lifting lemma which lifts resolution
	derivation steps from the ground world up to the first-order world.
	The theory is presented in a paper in the Journal of Automated Reasoning
	[Sch18] which extends a paper presented at the International Conference
	on Interactive Theorem Proving [Sch16]. An earlier version was
	presented in an MSc thesis [Sch15]. The formalization mostly follows
	textbooks by Ben-Ari [BA12], Chang and Lee [CL73], and Leitsch [Lei97].
	The theory is part of the IsaFoL project [IsaFoL]. <p>
	<a name="Sch18"></a>[Sch18] Anders Schlichtkrull. "Formalization of the
	Resolution Calculus for First-Order Logic". Journal of Automated
	Reasoning, 2018.<br> <a name="Sch16"></a>[Sch16] Anders
	Schlichtkrull. "Formalization of the Resolution Calculus for First-Order
	Logic". In: ITP 2016. Vol. 9807. LNCS. Springer, 2016.<br>
	<a name="Sch15"></a>[Sch15] Anders Schlichtkrull. <a href="https://people.compute.dtu.dk/andschl/Thesis.pdf">
	"Formalization of Resolution Calculus in Isabelle"</a>.
	<a href="https://people.compute.dtu.dk/andschl/Thesis.pdf">https://people.compute.dtu.dk/andschl/Thesis.pdf</a>.
	MSc thesis. Technical University of Denmark, 2015.<br>
	<a name="BA12"></a>[BA12] Mordechai Ben-Ari. <i>Mathematical Logic for
	Computer Science</i>. 3rd. Springer, 2012.<br> <a
	name="CL73"></a>[CL73] Chin-Liang Chang and Richard Char-Tung Lee.
	<i>Symbolic Logic and Mechanical Theorem Proving</i>. 1st. Academic
	Press, Inc., 1973.<br> <a name="Lei97"></a>[Lei97] Alexander
	Leitsch. <i>The Resolution Calculus</i>. Texts in theoretical computer
	science. Springer, 1997.<br> <a name="IsaFoL"></a>[IsaFoL]
	IsaFoL authors. <a href="https://bitbucket.org/jasmin_blanchette/isafol">
	IsaFoL: Isabelle Formalization of Logic</a>.
	<a href="https://bitbucket.org/jasmin_blanchette/isafol">https://bitbucket.org/jasmin_blanchette/isafol</a>.
	extra-history =
	Change history:
	[2018-01-24]: added several new versions of the soundness and completeness theorems as described in the paper [Sch18]. <br>
	[2018-03-20]: added a concrete instance of the unification and completeness theorems using the First-Order Terms AFP-entry from IsaFoR as described in the papers [Sch16] and [Sch18].

	[Surprise_Paradox]
	title = Surprise Paradox
	author = Joachim Breitner <http://pp.ipd.kit.edu/~breitner>
	notify = mail@joachim-breitner.de
	date = 2016-07-17
	topic = Logic
	abstract =
	In 1964, Fitch showed that the paradox of the surprise hanging can be
	resolved by showing that the judge’s verdict is inconsistent. His
	formalization builds on Gödel’s coding of provability. In this
	theory, we reproduce his proof in Isabelle, building on Paulson’s
	formalisation of Gödel’s incompleteness theorems.

	[Ptolemys_Theorem]
	title = Ptolemy's Theorem
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	notify = lukas.bulwahn@gmail.com
	date = 2016-08-07
	topic = Mathematics/Geometry
	abstract =
	This entry provides an analytic proof to Ptolemy's Theorem using
	polar form transformation and trigonometric identities.
	In this formalization, we use ideas from John Harrison's HOL Light
	formalization and the proof sketch on the Wikipedia entry of Ptolemy's Theorem.
	This theorem is the 95th theorem of the Top 100 Theorems list.

	[Falling_Factorial_Sum]
	title = The Falling Factorial of a Sum
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	topic = Mathematics/Combinatorics
	date = 2017-12-22
	notify = lukas.bulwahn@gmail.com
	abstract =
	This entry shows that the falling factorial of a sum can be computed
	with an expression using binomial coefficients and the falling
	factorial of its summands. The entry provides three different proofs:
	a combinatorial proof, an induction proof and an algebraic proof using
	the Vandermonde identity. The three formalizations try to follow
	their informal presentations from a Mathematics Stack Exchange page as
	close as possible. The induction and algebraic formalization end up to
	be very close to their informal presentation, whereas the
	combinatorial proof first requires the introduction of list
	interleavings, and significant more detail than its informal
	presentation.

	[InfPathElimination]
	title = Infeasible Paths Elimination by Symbolic Execution Techniques: Proof of Correctness and Preservation of Paths
	author = Romain Aissat<>, Frederic Voisin<>, Burkhart Wolff <mailto:wolff@lri.fr>
	notify = wolff@lri.fr
	date = 2016-08-18
	topic = Computer Science/Programming Languages/Static Analysis
	abstract =
	TRACER is a tool for verifying safety properties of sequential C
	programs. TRACER attempts at building a finite symbolic execution
	graph which over-approximates the set of all concrete reachable states
	and the set of feasible paths. We present an abstract framework for
	TRACER and similar CEGAR-like systems. The framework provides 1) a
	graph- transformation based method for reducing the feasible paths in
	control-flow graphs, 2) a model for symbolic execution, subsumption,
	predicate abstraction and invariant generation. In this framework we
	formally prove two key properties: correct construction of the
	symbolic states and preservation of feasible paths. The framework
	focuses on core operations, leaving to concrete prototypes to “fit in”
	heuristics for combining them. The accompanying paper (published in
	ITP 2016) can be found at
	https://www.lri.fr/∼wolff/papers/conf/2016-itp-InfPathsNSE.pdf.

	[Stirling_Formula]
	title = Stirling's formula
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	notify = eberlm@in.tum.de
	date = 2016-09-01
	topic = Mathematics/Analysis
	abstract =
	This work contains a proof of Stirling's formula both for the
	factorial n! &sim; √<span style="text-decoration:
	overline">2πn</span> (n/e)<sup>n</sup> on natural numbers and the
	real Gamma function Γ(x) &sim; √<span
	style="text-decoration: overline">2π/x</span> (x/e)<sup>x</sup>.
	The proof is based on work by <a
	href="http://www.maths.lancs.ac.uk/~jameson/stirlgamma.pdf">Graham
	Jameson</a>.

	[Lp]
	title = Lp spaces
	author = Sebastien Gouezel <http://www.math.sciences.univ-nantes.fr/~gouezel/>
	notify = sebastien.gouezel@univ-rennes1.fr
	date = 2016-10-05
	topic = Mathematics/Analysis
	abstract =
	Lp is the space of functions whose p-th power is integrable. It is one of the most fundamental Banach spaces that is used in analysis and probability. We develop a framework for function spaces, and then implement the Lp spaces in this framework using the existing integration theory in Isabelle/HOL. Our development contains most fundamental properties of Lp spaces, notably the Hölder and Minkowski inequalities, completeness of Lp, duality, stability under almost sure convergence, multiplication of functions in Lp and Lq, stability under conditional expectation.

	[Berlekamp_Zassenhaus]
	title = The Factorization Algorithm of Berlekamp and Zassenhaus
	author = Jose Divasón <http://www.unirioja.es/cu/jodivaso>, Sebastiaan Joosten <mailto:sebastiaan.joosten@uibk.ac.at>, René Thiemann <mailto:rene.thiemann@uibk.ac.at>, Akihisa Yamada <mailto:akihisa.yamada@uibk.ac.at>
	notify = rene.thiemann@uibk.ac.at
	date = 2016-10-14
	topic = Mathematics/Algebra
	abstract =
	<p>We formalize the Berlekamp-Zassenhaus algorithm for factoring
	square-free integer polynomials in Isabelle/HOL. We further adapt an
	existing formalization of Yun’s square-free factorization algorithm to
	integer polynomials, and thus provide an efficient and certified
	factorization algorithm for arbitrary univariate polynomials.
	</p>
	<p>The algorithm first performs a factorization in the prime field GF(p) and
	then performs computations in the integer ring modulo p^k, where both
	p and k are determined at runtime. Since a natural modeling of these
	structures via dependent types is not possible in Isabelle/HOL, we
	formalize the whole algorithm using Isabelle’s recent addition of
	local type definitions.
	</p>
	<p>Through experiments we verify that our algorithm factors polynomials of degree
	100 within seconds.
	</p>

	[Allen_Calculus]
	title = Allen's Interval Calculus
	author = Fadoua Ghourabi <>
	notify = fadouaghourabi@gmail.com
	date = 2016-09-29
	topic = Logic, Mathematics/Algebra
	abstract =
	Allen’s interval calculus is a qualitative temporal representation of
	time events. Allen introduced 13 binary relations that describe all
	the possible arrangements between two events, i.e. intervals with
	non-zero finite length. The compositions are pertinent to
	reasoning about knowledge of time. In particular, a consistency
	problem of relation constraints is commonly solved with a guideline
	from these compositions. We formalize the relations together with an
	axiomatic system. We proof the validity of the 169 compositions of
	these relations. We also define nests as the sets of intervals that
	share a meeting point. We prove that nests give the ordering
	properties of points without introducing a new datatype for points.
	[1] J.F. Allen. Maintaining Knowledge about Temporal Intervals. In
	Commun. ACM, volume 26, pages 832–843, 1983. [2] J. F. Allen and P. J.
	Hayes. A Common-sense Theory of Time. In Proceedings of the 9th
	International Joint Conference on Artificial Intelligence (IJCAI’85),
	pages 528–531, 1985.


	[Source_Coding_Theorem]
	title = Source Coding Theorem
	author = Quentin Hibon <mailto:qh225@cl.cam.ac.uk>, Lawrence C. Paulson <mailto:lp15@cam.ac.uk>
	notify = qh225@cl.cam.ac.uk
	date = 2016-10-19
	topic = Mathematics/Probability Theory
	abstract =
	This document contains a proof of the necessary condition on the code
	rate of a source code, namely that this code rate is bounded by the
	entropy of the source. This represents one half of Shannon's source
	coding theorem, which is itself an equivalence.

	[Buffons_Needle]
	title = Buffon's Needle Problem
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Probability Theory, Mathematics/Geometry
	date = 2017-06-06
	notify = eberlm@in.tum.de
	abstract =
	In the 18th century, Georges-Louis Leclerc, Comte de Buffon posed and
	later solved the following problem, which is often called the first
	problem ever solved in geometric probability: Given a floor divided
	into vertical strips of the same width, what is the probability that a
	needle thrown onto the floor randomly will cross two strips? This
	entry formally defines the problem in the case where the needle's
	position is chosen uniformly at random in a single strip around the
	origin (which is equivalent to larger arrangements due to symmetry).
	It then provides proofs of the simple solution in the case where the
	needle's length is no greater than the width of the strips and
	the more complicated solution in the opposite case.

	[SPARCv8]
	title = A formal model for the SPARCv8 ISA and a proof of non-interference for the LEON3 processor
	author = Zhe Hou <mailto:zhe.hou@ntu.edu.sg>, David Sanan <mailto:sanan@ntu.edu.sg>, Alwen Tiu <mailto:ATiu@ntu.edu.sg>, Yang Liu <mailto:yangliu@ntu.edu.sg>
	notify = zhe.hou@ntu.edu.sg, sanan@ntu.edu.sg
	date = 2016-10-19
	topic = Computer Science/Security, Computer Science/Hardware
	abstract =
	We formalise the SPARCv8 instruction set architecture (ISA) which is
	used in processors such as LEON3. Our formalisation can be specialised
	to any SPARCv8 CPU, here we use LEON3 as a running example. Our model
	covers the operational semantics for all the instructions in the
	integer unit of the SPARCv8 architecture and it supports Isabelle code
	export, which effectively turns the Isabelle model into a SPARCv8 CPU
	simulator. We prove the language-based non-interference property for
	the LEON3 processor. Our model is based on deterministic monad, which
	is a modified version of the non-deterministic monad from NICTA/l4v.

	[Separata]
	title = Separata: Isabelle tactics for Separation Algebra
	author = Zhe Hou <mailto:zhe.hou@ntu.edu.sg>, David Sanan <mailto:sanan@ntu.edu.sg>, Alwen Tiu <mailto:ATiu@ntu.edu.sg>, Rajeev Gore <mailto:rajeev.gore@anu.edu.au>, Ranald Clouston <mailto:ranald.clouston@cs.au.dk>
	notify = zhe.hou@ntu.edu.sg
	date = 2016-11-16
	topic = Computer Science/Programming Languages/Logics, Tools
	abstract =
	We bring the labelled sequent calculus $LS_{PASL}$ for propositional
	abstract separation logic to Isabelle. The tactics given here are
	directly applied on an extension of the Separation Algebra in the AFP.
	In addition to the cancellative separation algebra, we further
	consider some useful properties in the heap model of separation logic,
	such as indivisible unit, disjointness, and cross-split. The tactics
	are essentially a proof search procedure for the calculus $LS_{PASL}$.
	We wrap the tactics in an Isabelle method called separata, and give a
	few examples of separation logic formulae which are provable by
	separata.

	[LOFT]
	title = LOFT — Verified Migration of Linux Firewalls to SDN
	author = Julius Michaelis <http://liftm.de>, Cornelius Diekmann <http://net.in.tum.de/~diekmann>
	notify = isabelleopenflow@liftm.de
	date = 2016-10-21
	topic = Computer Science/Networks
	abstract =
	We present LOFT — Linux firewall OpenFlow Translator, a system that
	transforms the main routing table and FORWARD chain of iptables of a
	Linux-based firewall into a set of static OpenFlow rules. Our
	implementation is verified against a model of a simplified Linux-based
	router and we can directly show how much of the original functionality
	is preserved.

	[Stable_Matching]
	title = Stable Matching
	author = Peter Gammie <http://peteg.org>
	notify = peteg42@gmail.com
	date = 2016-10-24
	topic = Mathematics/Economics
	abstract =
	We mechanize proofs of several results from the matching with
	contracts literature, which generalize those of the classical
	two-sided matching scenarios that go by the name of stable marriage.
	Our focus is on game theoretic issues. Along the way we develop
	executable algorithms for computing optimal stable matches.

	[Modal_Logics_for_NTS]
	title = Modal Logics for Nominal Transition Systems
	author = Tjark Weber <mailto:tjark.weber@it.uu.se>, Lars-Henrik Eriksson <mailto:lhe@it.uu.se>, Joachim Parrow <mailto:joachim.parrow@it.uu.se>, Johannes Borgström <mailto:johannes.borgstrom@it.uu.se>, Ramunas Gutkovas <mailto:ramunas.gutkovas@it.uu.se>
	notify = tjark.weber@it.uu.se
	date = 2016-10-25
	topic = Computer Science/Concurrency/Process Calculi, Logic
	abstract =
	We formalize a uniform semantic substrate for a wide variety of
	process calculi where states and action labels can be from arbitrary
	nominal sets. A Hennessy-Milner logic for these systems is defined,
	and proved adequate for bisimulation equivalence. A main novelty is
	the construction of an infinitary nominal data type to model formulas
	with (finitely supported) infinite conjunctions and actions that may
	contain binding names. The logic is generalized to treat different
	bisimulation variants such as early, late and open in a systematic
	way.
	extra-history =
	Change history:
	[2017-01-29]:
	Formalization of weak bisimilarity added
	(revision c87cc2057d9c)

	[Abs_Int_ITP2012]
	title = Abstract Interpretation of Annotated Commands
	author = Tobias Nipkow <http://www21.in.tum.de/~nipkow>
	notify = nipkow@in.tum.de
	date = 2016-11-23
	topic = Computer Science/Programming Languages/Static Analysis
	abstract =
	This is the Isabelle formalization of the material decribed in the
	eponymous <a href="https://doi.org/10.1007/978-3-642-32347-8_9">ITP 2012 paper</a>.
	It develops a generic abstract interpreter for a
	while-language, including widening and narrowing. The collecting
	semantics and the abstract interpreter operate on annotated commands:
	the program is represented as a syntax tree with the semantic
	information directly embedded, without auxiliary labels. The aim of
	the formalization is simplicity, not efficiency or
	precision. This is motivated by the inclusion of the material in a
	theorem prover based course on semantics. A similar (but more
	polished) development is covered in the book
	<a href="https://doi.org/10.1007/978-3-319-10542-0">Concrete Semantics</a>.

	[Complx]
	title = COMPLX: A Verification Framework for Concurrent Imperative Programs
	author = Sidney Amani<>, June Andronick<>, Maksym Bortin<>, Corey Lewis<>, Christine Rizkallah<>, Joseph Tuong<>
	notify = sidney.amani@data61.csiro.au, corey.lewis@data61.csiro.au
	date = 2016-11-29
	topic = Computer Science/Programming Languages/Logics, Computer Science/Programming Languages/Language Definitions
	abstract =
	We propose a concurrency reasoning framework for imperative programs,
	based on the Owicki-Gries (OG) foundational shared-variable
	concurrency method. Our framework combines the approaches of
	Hoare-Parallel, a formalisation of OG in Isabelle/HOL for a simple
	while-language, and Simpl, a generic imperative language embedded in
	Isabelle/HOL, allowing formal reasoning on C programs. We define the
	Complx language, extending the syntax and semantics of Simpl with
	support for parallel composition and synchronisation. We additionally
	define an OG logic, which we prove sound w.r.t. the semantics, and a
	verification condition generator, both supporting involved low-level
	imperative constructs such as function calls and abrupt termination.
	We illustrate our framework on an example that features exceptions,
	guards and function calls. We aim to then target concurrent operating
	systems, such as the interruptible eChronos embedded operating system
	for which we already have a model-level OG proof using Hoare-Parallel.
	extra-history =
	Change history:
	[2017-01-13]:
	Improve VCG for nested parallels and sequential sections
	(revision 30739dbc3dcb)

	[Paraconsistency]
	title = Paraconsistency
	author = Anders Schlichtkrull <https://people.compute.dtu.dk/andschl>, Jørgen Villadsen <https://people.compute.dtu.dk/jovi/>
	topic = Logic
	date = 2016-12-07
	notify = andschl@dtu.dk, jovi@dtu.dk
	abstract =
	Paraconsistency is about handling inconsistency in a coherent way. In
	classical and intuitionistic logic everything follows from an
	inconsistent theory. A paraconsistent logic avoids the explosion.
	Quite a few applications in computer science and engineering are
	discussed in the Intelligent Systems Reference Library Volume 110:
	Towards Paraconsistent Engineering (Springer 2016). We formalize a
	paraconsistent many-valued logic that we motivated and described in a
	special issue on logical approaches to paraconsistency (Journal of
	Applied Non-Classical Logics 2005). We limit ourselves to the
	propositional fragment of the higher-order logic. The logic is based
	on so-called key equalities and has a countably infinite number of
	truth values. We prove theorems in the logic using the definition of
	validity. We verify truth tables and also counterexamples for
	non-theorems. We prove meta-theorems about the logic and finally we
	investigate a case study.

	[Proof_Strategy_Language]
	title = Proof Strategy Language
	author = Yutaka Nagashima<>
	topic = Tools
	date = 2016-12-20
	notify = Yutaka.Nagashima@data61.csiro.au
	abstract =
	Isabelle includes various automatic tools for finding proofs under
	certain conditions. However, for each conjecture, knowing which
	automation to use, and how to tweak its parameters, is currently
	labour intensive. We have developed a language, PSL, designed to
	capture high level proof strategies. PSL offloads the construction of
	human-readable fast-to-replay proof scripts to automatic search,
	making use of search-time information about each conjecture. Our
	preliminary evaluations show that PSL reduces the labour cost of
	interactive theorem proving. This submission contains the
	implementation of PSL and an example theory file, Example.thy, showing
	how to write poof strategies in PSL.

	[Concurrent_Ref_Alg]
	title = Concurrent Refinement Algebra and Rely Quotients
	author = Julian Fell <mailto:julian.fell@uq.net.au>, Ian J. Hayes <mailto:ian.hayes@itee.uq.edu.au>, Andrius Velykis <http://andrius.velykis.lt>
	topic = Computer Science/Concurrency
	date = 2016-12-30
	notify = Ian.Hayes@itee.uq.edu.au
	abstract =
	The concurrent refinement algebra developed here is designed to
	provide a foundation for rely/guarantee reasoning about concurrent
	programs. The algebra builds on a complete lattice of commands by
	providing sequential composition, parallel composition and a novel
	weak conjunction operator. The weak conjunction operator coincides
	with the lattice supremum providing its arguments are non-aborting,
	but aborts if either of its arguments do. Weak conjunction provides an
	abstract version of a guarantee condition as a guarantee process. We
	distinguish between models that distribute sequential composition over
	non-deterministic choice from the left (referred to as being
	conjunctive in the refinement calculus literature) and those that
	don't. Least and greatest fixed points of monotone functions are
	provided to allow recursion and iteration operators to be added to the
	language. Additional iteration laws are available for conjunctive
	models. The rely quotient of processes <i>c</i> and
	<i>i</i> is the process that, if executed in parallel with
	<i>i</i> implements <i>c</i>. It represents an
	abstract version of a rely condition generalised to a process.

	[FOL_Harrison]
	title = First-Order Logic According to Harrison
	author = Alexander Birch Jensen <https://people.compute.dtu.dk/aleje/>, Anders Schlichtkrull <https://people.compute.dtu.dk/andschl>, Jørgen Villadsen <https://people.compute.dtu.dk/jovi/>
	topic = Logic
	date = 2017-01-01
	notify = aleje@dtu.dk, andschl@dtu.dk, jovi@dtu.dk
	abstract =
	<p>We present a certified declarative first-order prover with equality
	based on John Harrison's Handbook of Practical Logic and
	Automated Reasoning, Cambridge University Press, 2009. ML code
	reflection is used such that the entire prover can be executed within
	Isabelle as a very simple interactive proof assistant. As examples we
	consider Pelletier's problems 1-46.</p>
	<p>Reference: Programming and Verifying a Declarative First-Order
	Prover in Isabelle/HOL. Alexander Birch Jensen, John Bruntse Larsen,
	Anders Schlichtkrull & Jørgen Villadsen. AI Communications 31:281-299
	2018. <a href="https://content.iospress.com/articles/ai-communications/aic764">
	https://content.iospress.com/articles/ai-communications/aic764</a></p>
	<p>See also: Students' Proof Assistant (SPA).
	<a href=https://github.com/logic-tools/spa>
	https://github.com/logic-tools/spa</a></p>
	extra-history =
	Change history:
	[2018-07-21]: Proof of Pelletier's problem 34 (Andrews's Challenge) thanks to Andreas Halkjær From.

	[Bernoulli]
	title = Bernoulli Numbers
	author = Lukas Bulwahn<mailto:lukas.bulwahn@gmail.com>, Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Analysis, Mathematics/Number Theory
	date = 2017-01-24
	notify = eberlm@in.tum.de
	abstract =
	<p>Bernoulli numbers were first discovered in the closed-form
	expansion of the sum 1<sup>m</sup> +
	2<sup>m</sup> + … + n<sup>m</sup>
	for a fixed m and appear in many other places. This entry provides
	three different definitions for them: a recursive one, an explicit
	one, and one through their exponential generating function.</p>
	<p>In addition, we prove some basic facts, e.g. their relation
	to sums of powers of integers and that all odd Bernoulli numbers
	except the first are zero, and some advanced facts like their
	relationship to the Riemann zeta function on positive even
	integers.</p>
	<p>We also prove the correctness of the
	Akiyama–Tanigawa algorithm for computing Bernoulli numbers
	with reasonable efficiency, and we define the periodic Bernoulli
	polynomials (which appear e.g. in the Euler–MacLaurin
	summation formula and the expansion of the log-Gamma function) and
	prove their basic properties.</p>

	[Stone_Relation_Algebras]
	title = Stone Relation Algebras
	author = Walter Guttmann <http://www.cosc.canterbury.ac.nz/walter.guttmann/>
	topic = Mathematics/Algebra
	date = 2017-02-07
	notify = walter.guttmann@canterbury.ac.nz
	abstract =
	We develop Stone relation algebras, which generalise relation algebras
	by replacing the underlying Boolean algebra structure with a Stone
	algebra. We show that finite matrices over extended real numbers form
	an instance. As a consequence, relation-algebraic concepts and methods
	can be used for reasoning about weighted graphs. We also develop a
	fixpoint calculus and apply it to compare different definitions of
	reflexive-transitive closures in semirings.

	[Stone_Kleene_Relation_Algebras]
	title = Stone-Kleene Relation Algebras
	author = Walter Guttmann <http://www.cosc.canterbury.ac.nz/walter.guttmann/>
	topic = Mathematics/Algebra
	date = 2017-07-06
	notify = walter.guttmann@canterbury.ac.nz
	abstract =
	We develop Stone-Kleene relation algebras, which expand Stone relation
	algebras with a Kleene star operation to describe reachability in
	weighted graphs. Many properties of the Kleene star arise as a special
	case of a more general theory of iteration based on Conway semirings
	extended by simulation axioms. This includes several theorems
	representing complex program transformations. We formally prove the
	correctness of Conway's automata-based construction of the Kleene
	star of a matrix. We prove numerous results useful for reasoning about
	weighted graphs.

	[Abstract_Soundness]
	title = Abstract Soundness
	author = Jasmin Christian Blanchette <mailto:jasmin.blanchette@gmail.com>, Andrei Popescu <mailto:uuomul@yahoo.com>, Dmitriy Traytel <mailto:traytel@inf.ethz.ch>
	topic = Logic
	date = 2017-02-10
	notify = jasmin.blanchette@gmail.com
	abstract =
	A formalized coinductive account of the abstract development of
	Brotherston, Gorogiannis, and Petersen [APLAS 2012], in a slightly
	more general form since we work with arbitrary infinite proofs, which
	may be acyclic. This work is described in detail in an article by the
	authors, published in 2017 in the <em>Journal of Automated
	Reasoning</em>. The abstract proof can be instantiated for
	various formalisms, including first-order logic with inductive
	predicates.

	[Differential_Dynamic_Logic]
	title = Differential Dynamic Logic
	author = Brandon Bohrer <mailto:bbohrer@cs.cmu.edu>
	topic = Logic, Computer Science/Programming Languages/Logics
	date = 2017-02-13
	notify = bbohrer@cs.cmu.edu
	abstract =
	We formalize differential dynamic logic, a logic for proving
	properties of hybrid systems. The proof calculus in this formalization
	is based on the uniform substitution principle. We show it is sound
	with respect to our denotational semantics, which provides increased
	confidence in the correctness of the KeYmaera X theorem prover based
	on this calculus. As an application, we include a proof term checker
	embedded in Isabelle/HOL with several example proofs. Published in:
	Brandon Bohrer, Vincent Rahli, Ivana Vukotic, Marcus Völp, André
	Platzer: Formally verified differential dynamic logic. CPP 2017.

	[Elliptic_Curves_Group_Law]
	title = The Group Law for Elliptic Curves
	author = Stefan Berghofer <http://www.in.tum.de/~berghofe>
	topic = Computer Science/Security/Cryptography
	date = 2017-02-28
	notify = berghofe@in.tum.de
	abstract =
	We prove the group law for elliptic curves in Weierstrass form over
	fields of characteristic greater than 2. In addition to affine
	coordinates, we also formalize projective coordinates, which allow for
	more efficient computations. By specializing the abstract
	formalization to prime fields, we can apply the curve operations to
	parameters used in standard security protocols.

	[Example-Submission]
	title = Example Submission
	author = Gerwin Klein <http://www.cse.unsw.edu.au/~kleing/>
	topic = Mathematics/Analysis, Mathematics/Number Theory
	date = 2004-02-25
	notify = kleing@cse.unsw.edu.au
	abstract =
	This is an example submission to the Archive of Formal Proofs. It shows
	submission requirements and explains the structure of a simple typical
	submission.
	extra-no-index = no-index: true

	[CRDT]
	title = A framework for establishing Strong Eventual Consistency for Conflict-free Replicated Datatypes
	author = Victor B. F. Gomes <mailto:vb358@cam.ac.uk>, Martin Kleppmann<mailto:martin.kleppmann@cl.cam.ac.uk>, Dominic P. Mulligan<mailto:dominic.p.mulligan@googlemail.com>, Alastair R. Beresford<mailto:arb33@cam.ac.uk>
	topic = Computer Science/Algorithms/Distributed, Computer Science/Data Structures
	date = 2017-07-07
	notify = vb358@cam.ac.uk, dominic.p.mulligan@googlemail.com
	abstract =
	In this work, we focus on the correctness of Conflict-free Replicated
	Data Types (CRDTs), a class of algorithm that provides strong eventual
	consistency guarantees for replicated data. We develop a modular and
	reusable framework for verifying the correctness of CRDT algorithms.
	We avoid correctness issues that have dogged previous mechanised
	proofs in this area by including a network model in our formalisation,
	and proving that our theorems hold in all possible network behaviours.
	Our axiomatic network model is a standard abstraction that accurately
	reflects the behaviour of real-world computer networks. Moreover, we
	identify an abstract convergence theorem, a property of order
	relations, which provides a formal definition of strong eventual
	consistency. We then obtain the first machine-checked correctness
	theorems for three concrete CRDTs: the Replicated Growable Array, the
	Observed-Remove Set, and an Increment-Decrement Counter.

	[HOLCF-Prelude]
	title = HOLCF-Prelude
	author = Joachim Breitner<mailto:joachim@cis.upenn.edu>, Brian Huffman<>, Neil Mitchell<>, Christian Sternagel<mailto:c.sternagel@gmail.com>
	topic = Computer Science/Functional Programming
	date = 2017-07-15
	notify = c.sternagel@gmail.com, joachim@cis.upenn.edu, hupel@in.tum.de
	abstract =
	The Isabelle/HOLCF-Prelude is a formalization of a large part of
	Haskell's standard prelude in Isabelle/HOLCF. We use it to prove
	the correctness of the Eratosthenes' Sieve, in its
	self-referential implementation commonly used to showcase
	Haskell's laziness; prove correctness of GHC's
	"fold/build" rule and related rewrite rules; and certify a
	number of hints suggested by HLint.

	[Decl_Sem_Fun_PL]
	title = Declarative Semantics for Functional Languages
	author = Jeremy Siek <http://homes.soic.indiana.edu/jsiek/>
	topic = Computer Science/Programming Languages
	date = 2017-07-21
	notify = jsiek@indiana.edu
	abstract =
	We present a semantics for an applied call-by-value lambda-calculus
	that is compositional, extensional, and elementary. We present four
	different views of the semantics: 1) as a relational (big-step)
	semantics that is not operational but instead declarative, 2) as a
	denotational semantics that does not use domain theory, 3) as a
	non-deterministic interpreter, and 4) as a variant of the intersection
	type systems of the Torino group. We prove that the semantics is
	correct by showing that it is sound and complete with respect to
	operational semantics on programs and that is sound with respect to
	contextual equivalence. We have not yet investigated whether it is
	fully abstract. We demonstrate that this approach to semantics is
	useful with three case studies. First, we use the semantics to prove
	correctness of a compiler optimization that inlines function
	application. Second, we adapt the semantics to the polymorphic
	lambda-calculus extended with general recursion and prove semantic
	type soundness. Third, we adapt the semantics to the call-by-value
	lambda-calculus with mutable references.
	<br>
	The paper that accompanies these Isabelle theories is <a href="https://arxiv.org/abs/1707.03762">available on arXiv</a>.

	[DynamicArchitectures]
	title = Dynamic Architectures
	author = Diego Marmsoler <http://marmsoler.com>
	topic = Computer Science/System Description Languages
	date = 2017-07-28
	notify = diego.marmsoler@tum.de
	abstract =
	The architecture of a system describes the system's overall
	organization into components and connections between those components.
	With the emergence of mobile computing, dynamic architectures have
	become increasingly important. In such architectures, components may
	appear or disappear, and connections may change over time. In the
	following we mechanize a theory of dynamic architectures and verify
	the soundness of a corresponding calculus. Therefore, we first
	formalize the notion of configuration traces as a model for dynamic
	architectures. Then, the behavior of single components is formalized
	in terms of behavior traces and an operator is introduced and studied
	to extract the behavior of a single component out of a given
	configuration trace. Then, behavior trace assertions are introduced as
	a temporal specification technique to specify behavior of components.
	Reasoning about component behavior in a dynamic context is formalized
	in terms of a calculus for dynamic architectures. Finally, the
	soundness of the calculus is verified by introducing an alternative
	interpretation for behavior trace assertions over configuration traces
	and proving the rules of the calculus. Since projection may lead to
	finite as well as infinite behavior traces, they are formalized in
	terms of coinductive lists. Thus, our theory is based on
	Lochbihler's formalization of coinductive lists. The theory may
	be applied to verify properties for dynamic architectures.
	extra-history =
	Change history:
	[2018-06-07]: adding logical operators to specify configuration traces (revision 09178f08f050)<br>

	[Stewart_Apollonius]
	title = Stewart's Theorem and Apollonius' Theorem
	author = Lukas Bulwahn <mailto:lukas.bulwahn@gmail.com>
	topic = Mathematics/Geometry
	date = 2017-07-31
	notify = lukas.bulwahn@gmail.com
	abstract =
	This entry formalizes the two geometric theorems, Stewart's and
	Apollonius' theorem. Stewart's Theorem relates the length of
	a triangle's cevian to the lengths of the triangle's two
	sides. Apollonius' Theorem is a specialisation of Stewart's
	theorem, restricting the cevian to be the median. The proof applies
	the law of cosines, some basic geometric facts about triangles and
	then simply transforms the terms algebraically to yield the
	conjectured relation. The formalization in Isabelle can closely follow
	the informal proofs described in the Wikipedia articles of those two
	theorems.

	[LambdaMu]
	title = The LambdaMu-calculus
	author = Cristina Matache <mailto:cris.matache@gmail.com>, Victor B. F. Gomes <mailto:victorborgesfg@gmail.com>, Dominic P. Mulligan <mailto:dominic.p.mulligan@googlemail.com>
	topic = Computer Science/Programming Languages/Lambda Calculi, Logic
	date = 2017-08-16
	notify = victorborgesfg@gmail.com, dominic.p.mulligan@googlemail.com
	abstract =
	The propositions-as-types correspondence is ordinarily presented as
	linking the metatheory of typed λ-calculi and the proof theory of
	intuitionistic logic. Griffin observed that this correspondence could
	be extended to classical logic through the use of control operators.
	This observation set off a flurry of further research, leading to the
	development of Parigots λμ-calculus. In this work, we formalise λμ-
	calculus in Isabelle/HOL and prove several metatheoretical properties
	such as type preservation and progress.

	[Orbit_Stabiliser]
	title = Orbit-Stabiliser Theorem with Application to Rotational Symmetries
	author = Jonas Rädle <mailto:jonas.raedle@tum.de>
	topic = Mathematics/Algebra
	date = 2017-08-20
	notify = jonas.raedle@tum.de
	abstract =
	The Orbit-Stabiliser theorem is a basic result in the algebra of
	groups that factors the order of a group into the sizes of its orbits
	and stabilisers. We formalize the notion of a group action and the
	related concepts of orbits and stabilisers. This allows us to prove
	the orbit-stabiliser theorem. In the second part of this work, we
	formalize the tetrahedral group and use the orbit-stabiliser theorem
	to prove that there are twelve (orientation-preserving) rotations of
	the tetrahedron.

	[PLM]
	title = Representation and Partial Automation of the Principia Logico-Metaphysica in Isabelle/HOL
	author = Daniel Kirchner <mailto:daniel@ekpyron.org>
	topic = Logic/Philosophy
	date = 2017-09-17
	notify = daniel@ekpyron.org
	abstract =
	<p> We present an embedding of the second-order fragment of the
	Theory of Abstract Objects as described in Edward Zalta's
	upcoming work <a
	href="https://mally.stanford.edu/principia.pdf">Principia
	Logico-Metaphysica (PLM)</a> in the automated reasoning
	framework Isabelle/HOL. The Theory of Abstract Objects is a
	metaphysical theory that reifies property patterns, as they for
	example occur in the abstract reasoning of mathematics, as
	<b>abstract objects</b> and provides an axiomatic
	framework that allows to reason about these objects. It thereby serves
	as a fundamental metaphysical theory that can be used to axiomatize
	and describe a wide range of philosophical objects, such as Platonic
	forms or Leibniz' concepts, and has the ambition to function as a
	foundational theory of mathematics. The target theory of our embedding
	as described in chapters 7-9 of PLM employs a modal relational type
	theory as logical foundation for which a representation in functional
	type theory is <a
	href="https://mally.stanford.edu/Papers/rtt.pdf">known to
	be challenging</a>. </p> <p> Nevertheless we arrive
	at a functioning representation of the theory in the functional logic
	of Isabelle/HOL based on a semantical representation of an Aczel-model
	of the theory. Based on this representation we construct an
	implementation of the deductive system of PLM which allows to
	automatically and interactively find and verify theorems of PLM.
	</p> <p> Our work thereby supports the concept of shallow
	semantical embeddings of logical systems in HOL as a universal tool
	for logical reasoning <a
	href="http://www.mi.fu-berlin.de/inf/groups/ag-ki/publications/Universal-Reasoning/1703_09620_pd.pdf">as
	promoted by Christoph Benzmüller</a>. </p>
	<p> The most notable result of the presented work is the
	discovery of a previously unknown paradox in the formulation of the
	Theory of Abstract Objects. The embedding of the theory in
	Isabelle/HOL played a vital part in this discovery. Furthermore it was
	possible to immediately offer several options to modify the theory to
	guarantee its consistency. Thereby our work could provide a
	significant contribution to the development of a proper grounding for
	object theory. </p>

	[KD_Tree]
	title = Multidimensional Binary Search Trees
	author = Martin Rau<>
	topic = Computer Science/Data Structures
	date = 2019-05-30
	notify = martin.rau@tum.de, mrtnrau@googlemail.com
	-abstract =
	+abstract =
	This entry provides a formalization of multidimensional binary trees,
	also known as k-d trees. It includes a balanced build algorithm as
	well as the nearest neighbor algorithm and the range search algorithm.
	It is based on the papers <a
	href="https://dl.acm.org/citation.cfm?doid=361002.361007">Multidimensional
	binary search trees used for associative searching</a> and <a
	href="https://dl.acm.org/citation.cfm?doid=355744.355745">
	An Algorithm for Finding Best Matches in Logarithmic Expected
	Time</a>.


	[Diophantine_Eqns_Lin_Hom]
	title = Homogeneous Linear Diophantine Equations
	author = Florian Messner <mailto:florian.g.messner@uibk.ac.at>, Julian Parsert <mailto:julian.parsert@gmail.com>, Jonas Schöpf <mailto:jonas.schoepf@uibk.ac.at>, Christian Sternagel <mailto:c.sternagel@gmail.com>
	topic = Computer Science/Algorithms, Mathematics/Number Theory, Tools
	license = LGPL
	date = 2017-10-14
	notify = c.sternagel@gmail.com, julian.parsert@gmail.com
	abstract =
	We formalize the theory of homogeneous linear diophantine equations,
	focusing on two main results: (1) an abstract characterization of
	minimal complete sets of solutions, and (2) an algorithm computing
	them. Both, the characterization and the algorithm are based on
	previous work by Huet. Our starting point is a simple but inefficient
	variant of Huet's lexicographic algorithm incorporating improved
	bounds due to Clausen and Fortenbacher. We proceed by proving its
	soundness and completeness. Finally, we employ code equations to
	obtain a reasonably efficient implementation. Thus, we provide a
	formally verified solver for homogeneous linear diophantine equations.

	[Winding_Number_Eval]
	title = Evaluate Winding Numbers through Cauchy Indices
	author = Wenda Li <https://www.cl.cam.ac.uk/~wl302/>
	topic = Mathematics/Analysis
	date = 2017-10-17
	notify = wl302@cam.ac.uk, liwenda1990@hotmail.com
	abstract =
	In complex analysis, the winding number measures the number of times a
	path (counterclockwise) winds around a point, while the Cauchy index
	can approximate how the path winds. This entry provides a
	formalisation of the Cauchy index, which is then shown to be related
	to the winding number. In addition, this entry also offers a tactic
	that enables users to evaluate the winding number by calculating
	Cauchy indices.

	[Count_Complex_Roots]
	title = Count the Number of Complex Roots
	author = Wenda Li <https://www.cl.cam.ac.uk/~wl302/>
	topic = Mathematics/Analysis
	date = 2017-10-17
	notify = wl302@cam.ac.uk, liwenda1990@hotmail.com
	abstract =
	Based on evaluating Cauchy indices through remainder sequences, this
	entry provides an effective procedure to count the number of complex
	roots (with multiplicity) of a polynomial within a rectangle box or a
	half-plane. Potential applications of this entry include certified
	complex root isolation (of a polynomial) and testing the Routh-Hurwitz
	stability criterion (i.e., to check whether all the roots of some
	characteristic polynomial have negative real parts).

	[Buchi_Complementation]
	title = Büchi Complementation
	author = Julian Brunner <http://www21.in.tum.de/~brunnerj/>
	topic = Computer Science/Automata and Formal Languages
	date = 2017-10-19
	notify = brunnerj@in.tum.de
	abstract =
	This entry provides a verified implementation of rank-based Büchi
	Complementation. The verification is done in three steps: <ol>
	<li>Definition of odd rankings and proof that an automaton
	rejects a word iff there exists an odd ranking for it.</li>
	<li>Definition of the complement automaton and proof that it
	accepts exactly those words for which there is an odd
	ranking.</li> <li>Verified implementation of the
	complement automaton using the Isabelle Collections
	Framework.</li> </ol>

	[Transition_Systems_and_Automata]
	title = Transition Systems and Automata
	author = Julian Brunner <http://www21.in.tum.de/~brunnerj/>
	topic = Computer Science/Automata and Formal Languages
	date = 2017-10-19
	notify = brunnerj@in.tum.de
	abstract =
	This entry provides a very abstract theory of transition systems that
	can be instantiated to express various types of automata. A transition
	system is typically instantiated by providing a set of initial states,
	a predicate for enabled transitions, and a transition execution
	function. From this, it defines the concepts of finite and infinite
	paths as well as the set of reachable states, among other things. Many
	useful theorems, from basic path manipulation rules to coinduction and
	run construction rules, are proven in this abstract transition system
	context. The library comes with instantiations for DFAs, NFAs, and
	Büchi automata.

	[Kuratowski_Closure_Complement]
	title = The Kuratowski Closure-Complement Theorem
	author = Peter Gammie <http://peteg.org>, Gianpaolo Gioiosa<>
	topic = Mathematics/Topology
	date = 2017-10-26
	notify = peteg42@gmail.com
	abstract =
	We discuss a topological curiosity discovered by Kuratowski (1922):
	the fact that the number of distinct operators on a topological space
	generated by compositions of closure and complement never exceeds 14,
	and is exactly 14 in the case of R. In addition, we prove a theorem
	due to Chagrov (1982) that classifies topological spaces according to
	the number of such operators they support.

	[Hybrid_Multi_Lane_Spatial_Logic]
	title = Hybrid Multi-Lane Spatial Logic
	author = Sven Linker <mailto:s.linker@liverpool.ac.uk>
	topic = Logic
	date = 2017-11-06
	notify = s.linker@liverpool.ac.uk
	abstract =
	We present a semantic embedding of a spatio-temporal multi-modal
	logic, specifically defined to reason about motorway traffic, into
	Isabelle/HOL. The semantic model is an abstraction of a motorway,
	emphasising local spatial properties, and parameterised by the types
	of sensors deployed in the vehicles. We use the logic to define
	controller constraints to ensure safety, i.e., the absence of
	collisions on the motorway. After proving safety with a restrictive
	definition of sensors, we relax these assumptions and show how to
	amend the controller constraints to still guarantee safety.

	[Dirichlet_L]
	title = Dirichlet L-Functions and Dirichlet's Theorem
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Number Theory, Mathematics/Algebra
	date = 2017-12-21
	notify = eberlm@in.tum.de
	abstract =
	<p>This article provides a formalisation of Dirichlet characters
	and Dirichlet <em>L</em>-functions including proofs of
	their basic properties – most notably their analyticity,
	their areas of convergence, and their non-vanishing for &Re;(s)
	≥ 1. All of this is built in a very high-level style using
	Dirichlet series. The proof of the non-vanishing follows a very short
	and elegant proof by Newman, which we attempt to reproduce faithfully
	in a similar level of abstraction in Isabelle.</p> <p>This
	also leads to a relatively short proof of Dirichlet’s Theorem, which
	states that, if <em>h</em> and <em>n</em> are
	coprime, there are infinitely many primes <em>p</em> with
	<em>p</em> &equiv; <em>h</em> (mod
	<em>n</em>).</p>

	[Symmetric_Polynomials]
	title = Symmetric Polynomials
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Algebra
	date = 2018-09-25
	notify = eberlm@in.tum.de
	abstract =
	<p>A symmetric polynomial is a polynomial in variables
	<em>X</em><sub>1</sub>,…,<em>X</em><sub>n</sub>
	that does not discriminate between its variables, i. e. it
	is invariant under any permutation of them. These polynomials are
	important in the study of the relationship between the coefficients of
	a univariate polynomial and its roots in its algebraic
	closure.</p> <p>This article provides a definition of
	symmetric polynomials and the elementary symmetric polynomials
	e<sub>1</sub>,…,e<sub>n</sub> and
	proofs of their basic properties, including three notable
	ones:</p> <ul> <li> Vieta's formula, which
	gives an explicit expression for the <em>k</em>-th
	coefficient of a univariate monic polynomial in terms of its roots
	<em>x</em><sub>1</sub>,…,<em>x</em><sub>n</sub>,
	namely
	<em>c</em><sub><em>k</em></sub> = (-1)<sup><em>n</em>-<em>k</em></sup> e<sub><em>n</em>-<em>k</em></sub>(<em>x</em><sub>1</sub>,…,<em>x</em><sub>n</sub>).</li>
	<li>Second, the Fundamental Theorem of Symmetric Polynomials,
	which states that any symmetric polynomial is itself a uniquely
	determined polynomial combination of the elementary symmetric
	polynomials.</li> <li>Third, as a corollary of the
	previous two, that given a polynomial over some ring
	<em>R</em>, any symmetric polynomial combination of its
	roots is also in <em>R</em> even when the roots are not.
	</ul> <p> Both the symmetry property itself and the
	witness for the Fundamental Theorem are executable. </p>

	[Taylor_Models]
	title = Taylor Models
	author = Christoph Traut<>, Fabian Immler <http://www21.in.tum.de/~immler>
	topic = Computer Science/Algorithms, Computer Science/Data Structures, Mathematics/Analysis, Mathematics/Algebra
	date = 2018-01-08
	notify = immler@in.tum.de
	abstract =
	We present a formally verified implementation of multivariate Taylor
	models. Taylor models are a form of rigorous polynomial approximation,
	consisting of an approximation polynomial based on Taylor expansions,
	combined with a rigorous bound on the approximation error. Taylor
	models were introduced as a tool to mitigate the dependency problem of
	interval arithmetic. Our implementation automatically computes Taylor
	models for the class of elementary functions, expressed by composition
	of arithmetic operations and basic functions like exp, sin, or square
	root.

	[Green]
	title = An Isabelle/HOL formalisation of Green's Theorem
	author = Mohammad Abdulaziz <mailto:mohammad.abdulaziz8@gmail.com>, Lawrence C. Paulson <http://www.cl.cam.ac.uk/~lp15/>
	topic = Mathematics/Analysis
	date = 2018-01-11
	notify = mohammad.abdulaziz8@gmail.com, lp15@cam.ac.uk
	abstract =
	We formalise a statement of Green’s theorem—the first formalisation to
	our knowledge—in Isabelle/HOL. The theorem statement that we formalise
	is enough for most applications, especially in physics and
	engineering. Our formalisation is made possible by a novel proof that
	avoids the ubiquitous line integral cancellation argument. This
	eliminates the need to formalise orientations and region boundaries
	explicitly with respect to the outwards-pointing normal vector.
	Instead we appeal to a homological argument about equivalences between
	paths.

	[Gromov_Hyperbolicity]
	title = Gromov Hyperbolicity
	author = Sebastien Gouezel<>
	topic = Mathematics/Geometry
	date = 2018-01-16
	notify = sebastien.gouezel@univ-rennes1.fr
	abstract =
	A geodesic metric space is Gromov hyperbolic if all its geodesic
	triangles are thin, i.e., every side is contained in a fixed
	thickening of the two other sides. While this definition looks
	innocuous, it has proved extremely important and versatile in modern
	geometry since its introduction by Gromov. We formalize the basic
	classical properties of Gromov hyperbolic spaces, notably the Morse
	lemma asserting that quasigeodesics are close to geodesics, the
	invariance of hyperbolicity under quasi-isometries, we define and
	study the Gromov boundary and its associated distance, and prove that
	a quasi-isometry between Gromov hyperbolic spaces extends to a
	homeomorphism of the boundaries. We also prove a less classical
	theorem, by Bonk and Schramm, asserting that a Gromov hyperbolic space
	embeds isometrically in a geodesic Gromov-hyperbolic space. As the
	original proof uses a transfinite sequence of Cauchy completions, this
	is an interesting formalization exercise. Along the way, we introduce
	basic material on isometries, quasi-isometries, Lipschitz maps,
	geodesic spaces, the Hausdorff distance, the Cauchy completion of a
	metric space, and the exponential on extended real numbers.

	[Ordered_Resolution_Prover]
	title = Formalization of Bachmair and Ganzinger's Ordered Resolution Prover
	author = Anders Schlichtkrull <mailto:andschl@dtu.dk>, Jasmin Christian Blanchette <mailto:j.c.blanchette@vu.nl>, Dmitriy Traytel <mailto:traytel@inf.ethz.ch>, Uwe Waldmann <mailto:uwe@mpi-inf.mpg.de>
	topic = Logic
	date = 2018-01-18
	notify = andschl@dtu.dk, j.c.blanchette@vu.nl
	abstract =
	This Isabelle/HOL formalization covers Sections 2 to 4 of Bachmair and
	Ganzinger's "Resolution Theorem Proving" chapter in the
	<em>Handbook of Automated Reasoning</em>. This includes
	soundness and completeness of unordered and ordered variants of ground
	resolution with and without literal selection, the standard redundancy
	criterion, a general framework for refutational theorem proving, and
	soundness and completeness of an abstract first-order prover.

	[BNF_Operations]
	title = Operations on Bounded Natural Functors
	author = Jasmin Christian Blanchette <mailto:jasmin.blanchette@gmail.com>, Andrei Popescu <mailto:uuomul@yahoo.com>, Dmitriy Traytel <mailto:traytel@inf.ethz.ch>
	topic = Tools
	date = 2017-12-19
	notify = jasmin.blanchette@gmail.com,uuomul@yahoo.com,traytel@inf.ethz.ch
	abstract =
	This entry formalizes the closure property of bounded natural functors
	(BNFs) under seven operations. These operations and the corresponding
	proofs constitute the core of Isabelle's (co)datatype package. To
	be close to the implemented tactics, the proofs are deliberately
	formulated as detailed apply scripts. The (co)datatypes together with
	(co)induction principles and (co)recursors are byproducts of the
	fixpoint operations LFP and GFP. Composition of BNFs is subdivided
	into four simpler operations: Compose, Kill, Lift, and Permute. The
	N2M operation provides mutual (co)induction principles and
	(co)recursors for nested (co)datatypes.

	[LLL_Basis_Reduction]
	title = A verified LLL algorithm
	author = Ralph Bottesch <>, Jose Divasón <http://www.unirioja.es/cu/jodivaso/>, Maximilian Haslbeck <>, Sebastiaan Joosten <http://sjcjoosten.nl/>, René Thiemann <http://cl-informatik.uibk.ac.at/users/thiemann/>, Akihisa Yamada<>
	topic = Computer Science/Algorithms, Mathematics/Algebra
	date = 2018-02-02
	notify = ralph.bottesch@uibk.ac.at, jose.divason@unirioja.es, maximilian.haslbeck@uibk.ac.at, s.j.c.joosten@utwente.nl, rene.thiemann@uibk.ac.at, ayamada@trs.cm.is.nagoya-u.ac.jp
	abstract =
	The Lenstra-Lenstra-Lovász basis reduction algorithm, also known as
	LLL algorithm, is an algorithm to find a basis with short, nearly
	orthogonal vectors of an integer lattice. Thereby, it can also be seen
	as an approximation to solve the shortest vector problem (SVP), which
	is an NP-hard problem, where the approximation quality solely depends
	on the dimension of the lattice, but not the lattice itself. The
	algorithm also possesses many applications in diverse fields of
	computer science, from cryptanalysis to number theory, but it is
	specially well-known since it was used to implement the first
	polynomial-time algorithm to factor polynomials. In this work we
	present the first mechanized soundness proof of the LLL algorithm to
	compute short vectors in lattices. The formalization follows a
	textbook by von zur Gathen and Gerhard.
	extra-history =
	Change history:
	[2018-04-16]: Integrated formal complexity bounds (Haslbeck, Thiemann)
	[2018-05-25]: Integrated much faster LLL implementation based on integer arithmetic (Bottesch, Haslbeck, Thiemann)

	[LLL_Factorization]
	title = A verified factorization algorithm for integer polynomials with polynomial complexity
	author = Jose Divasón <http://www.unirioja.es/cu/jodivaso/>, Sebastiaan Joosten <http://sjcjoosten.nl/>, René Thiemann <http://cl-informatik.uibk.ac.at/users/thiemann/>, Akihisa Yamada <mailto:ayamada@trs.cm.is.nagoya-u.ac.jp>
	topic = Mathematics/Algebra
	date = 2018-02-06
	notify = jose.divason@unirioja.es, s.j.c.joosten@utwente.nl, rene.thiemann@uibk.ac.at, ayamada@trs.cm.is.nagoya-u.ac.jp
	abstract =
	Short vectors in lattices and factors of integer polynomials are
	related. Each factor of an integer polynomial belongs to a certain
	lattice. When factoring polynomials, the condition that we are looking
	for an irreducible polynomial means that we must look for a small
	element in a lattice, which can be done by a basis reduction
	algorithm. In this development we formalize this connection and
	thereby one main application of the LLL basis reduction algorithm: an
	algorithm to factor square-free integer polynomials which runs in
	polynomial time. The work is based on our previous
	Berlekamp–Zassenhaus development, where the exponential reconstruction
	phase has been replaced by the polynomial-time basis reduction
	algorithm. Thanks to this formalization we found a serious flaw in a
	textbook.

	[Treaps]
	title = Treaps
	author = Maximilian Haslbeck <https://home.in.tum.de/~haslbecm>, Manuel Eberl <https://www.in.tum.de/~eberlm>, Tobias Nipkow <https://www.in.tum.de/~nipkow>
	topic = Computer Science/Data Structures
	date = 2018-02-06
	notify = eberlm@in.tum.de
	abstract =
	<p> A Treap is a binary tree whose nodes contain pairs
	consisting of some payload and an associated priority. It must have
	the search-tree property w.r.t. the payloads and the heap property
	w.r.t. the priorities. Treaps are an interesting data structure that
	is related to binary search trees (BSTs) in the following way: if one
	forgets all the priorities of a treap, the resulting BST is exactly
	the same as if one had inserted the elements into an empty BST in
	order of ascending priority. This means that a treap behaves like a
	BST where we can pretend the elements were inserted in a different
	order from the one in which they were actually inserted. </p>
	<p> In particular, by choosing these priorities at random upon
	insertion of an element, we can pretend that we inserted the elements
	in <em>random order</em>, so that the shape of the
	resulting tree is that of a random BST no matter in what order we
	insert the elements. This is the main result of this
	formalisation.</p>

	[Hoare_Time]
	title = Hoare Logics for Time Bounds
	author = Maximilian P. L. Haslbeck <http://www.in.tum.de/~haslbema>, Tobias Nipkow <https://www.in.tum.de/~nipkow>
	topic = Computer Science/Programming Languages/Logics
	date = 2018-02-26
	notify = haslbema@in.tum.de
	abstract =
	We study three different Hoare logics for reasoning about time bounds
	of imperative programs and formalize them in Isabelle/HOL: a classical
	Hoare like logic due to Nielson, a logic with potentials due to
	Carbonneaux <i>et al.</i> and a <i>separation
	logic</i> following work by Atkey, Chaguérand and Pottier.
	These logics are formally shown to be sound and complete. Verification
	condition generators are developed and are shown sound and complete
	too. We also consider variants of the systems where we abstract from
	multiplicative constants in the running time bounds, thus supporting a
	big-O style of reasoning. Finally we compare the expressive power of
	the three systems.

	[Architectural_Design_Patterns]
	title = A Theory of Architectural Design Patterns
	author = Diego Marmsoler <http://marmsoler.com>
	topic = Computer Science/System Description Languages
	date = 2018-03-01
	notify = diego.marmsoler@tum.de
	abstract =
	The following document formalizes and verifies several architectural
	design patterns. Each pattern specification is formalized in terms of
	a locale where the locale assumptions correspond to the assumptions
	which a pattern poses on an architecture. Thus, pattern specifications
	may build on top of each other by interpreting the corresponding
	locale. A pattern is verified using the framework provided by the AFP
	entry Dynamic Architectures. Currently, the document consists of
	formalizations of 4 different patterns: the singleton, the publisher
	subscriber, the blackboard pattern, and the blockchain pattern.
	Thereby, the publisher component of the publisher subscriber pattern
	is modeled as an instance of the singleton pattern and the blackboard
	pattern is modeled as an instance of the publisher subscriber pattern.
	In general, this entry provides the first steps towards an overall
	theory of architectural design patterns.
	extra-history =
	Change history:
	[2018-05-25]: changing the major assumption for blockchain architectures from alternative minings to relative mining frequencies (revision 5043c5c71685)<br>
	[2019-04-08]: adapting the terminology: honest instead of trusted, dishonest instead of untrusted (revision 7af3431a22ae)

	[Weight_Balanced_Trees]
	title = Weight-Balanced Trees
	author = Tobias Nipkow <https://www.in.tum.de/~nipkow>, Stefan Dirix<>
	topic = Computer Science/Data Structures
	date = 2018-03-13
	notify = nipkow@in.tum.de
	abstract =
	This theory provides a verified implementation of weight-balanced
	trees following the work of <a
	href="https://doi.org/10.1017/S0956796811000104">Hirai
	and Yamamoto</a> who proved that all parameters in a certain
	range are valid, i.e. guarantee that insertion and deletion preserve
	weight-balance. Instead of a general theorem we provide parameterized
	proofs of preservation of the invariant that work for many (all?)
	valid parameters.

	[Fishburn_Impossibility]
	title = The Incompatibility of Fishburn-Strategyproofness and Pareto-Efficiency
	author = Felix Brandt <http://dss.in.tum.de/staff/brandt.html>, Manuel Eberl <https://www21.in.tum.de/~eberlm>, Christian Saile <http://dss.in.tum.de/staff/christian-saile.html>, Christian Stricker <http://dss.in.tum.de/staff/christian-stricker.html>
	topic = Mathematics/Economics
	date = 2018-03-22
	notify = eberlm@in.tum.de
	abstract =
	<p>This formalisation contains the proof that there is no
	anonymous Social Choice Function for at least three agents and
	alternatives that fulfils both Pareto-Efficiency and
	Fishburn-Strategyproofness. It was derived from a proof of <a
	href="http://dss.in.tum.de/files/brandt-research/stratset.pdf">Brandt
	<em>et al.</em></a>, which relies on an unverified
	translation of a fixed finite instance of the original problem to SAT.
	This Isabelle proof contains a machine-checked version of both the
	statement for exactly three agents and alternatives and the lifting to
	the general case.</p>

	[BNF_CC]
	title = Bounded Natural Functors with Covariance and Contravariance
	author = Andreas Lochbihler <http://www.andreas-lochbihler.de>, Joshua Schneider <mailto:joshua.schneider@inf.ethz.ch>
	topic = Computer Science/Functional Programming, Tools
	date = 2018-04-24
	notify = mail@andreas-lochbihler.de, joshua.schneider@inf.ethz.ch
	abstract =
	Bounded natural functors (BNFs) provide a modular framework for the
	construction of (co)datatypes in higher-order logic. Their functorial
	operations, the mapper and relator, are restricted to a subset of the
	parameters, namely those where recursion can take place. For certain
	applications, such as free theorems, data refinement, quotients, and
	generalised rewriting, it is desirable that these operations do not
	ignore the other parameters. In this article, we formalise the
	generalisation BNF<sub>CC</sub> that extends the mapper
	and relator to covariant and contravariant parameters. We show that
	<ol> <li> BNF<sub>CC</sub>s are closed under
	functor composition and least and greatest fixpoints,</li>
	<li> subtypes inherit the BNF<sub>CC</sub> structure
	under conditions that generalise those for the BNF case,
	and</li> <li> BNF<sub>CC</sub>s preserve
	quotients under mild conditions.</li> </ol> These proofs
	are carried out for abstract BNF<sub>CC</sub>s similar to
	the AFP entry BNF Operations. In addition, we apply the
	BNF<sub>CC</sub> theory to several concrete functors.

	[Modular_Assembly_Kit_Security]
	title = An Isabelle/HOL Formalization of the Modular Assembly Kit for Security Properties
	author = Oliver Bračevac <mailto:bracevac@st.informatik.tu-darmstadt.de>, Richard Gay <mailto:gay@mais.informatik.tu-darmstadt.de>, Sylvia Grewe <mailto:grewe@st.informatik.tu-darmstadt.de>, Heiko Mantel <mailto:mantel@mais.informatik.tu-darmstadt.de>, Henning Sudbrock <mailto:sudbrock@mais.informatik.tu-darmstadt.de>, Markus Tasch <mailto:tasch@mais.informatik.tu-darmstadt.de>
	topic = Computer Science/Security
	date = 2018-05-07
	notify = tasch@mais.informatik.tu-darmstadt.de
	abstract =
	The "Modular Assembly Kit for Security Properties" (MAKS) is
	a framework for both the definition and verification of possibilistic
	information-flow security properties at the specification-level. MAKS
	supports the uniform representation of a wide range of possibilistic
	information-flow properties and provides support for the verification
	of such properties via unwinding results and compositionality results.
	We provide a formalization of this framework in Isabelle/HOL.

	[AxiomaticCategoryTheory]
	title = Axiom Systems for Category Theory in Free Logic
	author = Christoph Benzmüller <http://christoph-benzmueller.de>, Dana Scott <http://www.cs.cmu.edu/~scott/>
	topic = Mathematics/Category Theory
	date = 2018-05-23
	notify = c.benzmueller@gmail.com
	abstract =
	This document provides a concise overview on the core results of our
	previous work on the exploration of axioms systems for category
	theory. Extending the previous studies
	(http://arxiv.org/abs/1609.01493) we include one further axiomatic
	theory in our experiments. This additional theory has been suggested
	by Mac Lane in 1948. We show that the axioms proposed by Mac Lane are
	equivalent to the ones we studied before, which includes an axioms set
	suggested by Scott in the 1970s and another axioms set proposed by
	Freyd and Scedrov in 1990, which we slightly modified to remedy a
	minor technical issue.

	[OpSets]
	title = OpSets: Sequential Specifications for Replicated Datatypes
	author = Martin Kleppmann <mailto:mk428@cl.cam.ac.uk>, Victor B. F. Gomes <mailto:vb358@cl.cam.ac.uk>, Dominic P. Mulligan <mailto:Dominic.Mulligan@arm.com>, Alastair R. Beresford <mailto:arb33@cl.cam.ac.uk>
	topic = Computer Science/Algorithms/Distributed, Computer Science/Data Structures
	date = 2018-05-10
	notify = vb358@cam.ac.uk
	abstract =
	We introduce OpSets, an executable framework for specifying and
	reasoning about the semantics of replicated datatypes that provide
	eventual consistency in a distributed system, and for mechanically
	verifying algorithms that implement these datatypes. Our approach is
	simple but expressive, allowing us to succinctly specify a variety of
	abstract datatypes, including maps, sets, lists, text, graphs, trees,
	and registers. Our datatypes are also composable, enabling the
	construction of complex data structures. To demonstrate the utility of
	OpSets for analysing replication algorithms, we highlight an important
	correctness property for collaborative text editing that has
	traditionally been overlooked; algorithms that do not satisfy this
	property can exhibit awkward interleaving of text. We use OpSets to
	specify this correctness property and prove that although one existing
	replication algorithm satisfies this property, several other published
	algorithms do not.

	[Irrationality_J_Hancl]
	title = Irrational Rapidly Convergent Series
	author = Angeliki Koutsoukou-Argyraki <http://www.cl.cam.ac.uk/~ak2110/>, Wenda Li <http://www.cl.cam.ac.uk/~wl302/>
	topic = Mathematics/Number Theory, Mathematics/Analysis
	date = 2018-05-23
	notify = ak2110@cam.ac.uk, wl302@cam.ac.uk
	abstract =
	We formalize with Isabelle/HOL a proof of a theorem by J. Hancl asserting the
	irrationality of the sum of a series consisting of rational numbers, built up
	by sequences that fulfill certain properties. Even though the criterion is a
	number theoretic result, the proof makes use only of analytical arguments. We
	also formalize a corollary of the theorem for a specific series fulfilling the
	assumptions of the theorem.

	[Optimal_BST]
	title = Optimal Binary Search Trees
	author = Tobias Nipkow <https://www.in.tum.de/~nipkow>, Dániel Somogyi <>
	topic = Computer Science/Algorithms, Computer Science/Data Structures
	date = 2018-05-27
	notify = nipkow@in.tum.de
	abstract =
	This article formalizes recursive algorithms for the construction
	of optimal binary search trees given fixed access frequencies.
	We follow Knuth (1971), Yao (1980) and Mehlhorn (1984).
	The algorithms are memoized with the help of the AFP article
	<a href="Monad_Memo_DP.html">Monadification, Memoization and Dynamic Programming</a>,
	thus yielding dynamic programming algorithms.

	[Projective_Geometry]
	title = Projective Geometry
	author = Anthony Bordg <https://sites.google.com/site/anthonybordg/>
	topic = Mathematics/Geometry
	date = 2018-06-14
	notify = apdb3@cam.ac.uk
	abstract =
	We formalize the basics of projective geometry. In particular, we give
	a proof of the so-called Hessenberg's theorem in projective plane
	geometry. We also provide a proof of the so-called Desargues's
	theorem based on an axiomatization of (higher) projective space
	geometry using the notion of rank of a matroid. This last approach
	allows to handle incidence relations in an homogeneous way dealing
	only with points and without the need of talking explicitly about
	lines, planes or any higher entity.

	[Localization_Ring]
	title = The Localization of a Commutative Ring
	author = Anthony Bordg <https://sites.google.com/site/anthonybordg/>
	topic = Mathematics/Algebra
	date = 2018-06-14
	notify = apdb3@cam.ac.uk
	abstract =
	We formalize the localization of a commutative ring R with respect to
	a multiplicative subset (i.e. a submonoid of R seen as a
	multiplicative monoid). This localization is itself a commutative ring
	and we build the natural homomorphism of rings from R to its
	localization.

	[Minsky_Machines]
	title = Minsky Machines
	author = Bertram Felgenhauer<>
	topic = Logic
	date = 2018-08-14
	notify = int-e@gmx.de
	abstract =
	<p> We formalize undecidablity results for Minsky machines. To
	this end, we also formalize recursive inseparability.
	</p><p> We start by proving that Minsky machines can
	compute arbitrary primitive recursive and recursive functions. We then
	show that there is a deterministic Minsky machine with one argument
	and two final states such that the set of inputs that are accepted in
	one state is recursively inseparable from the set of inputs that are
	accepted in the other state. </p><p> As a corollary, the
	set of Minsky configurations that reach the first state but not the
	second recursively inseparable from the set of Minsky configurations
	that reach the second state but not the first. In particular both
	these sets are undecidable. </p><p> We do
	<em>not</em> prove that recursive functions can simulate
	Minsky machines. </p>

	[Neumann_Morgenstern_Utility]
	title = Von-Neumann-Morgenstern Utility Theorem
	author = Julian Parsert<mailto:julian.parsert@gmail.com>, Cezary Kaliszyk<http://cl-informatik.uibk.ac.at/users/cek/>
	topic = Mathematics/Economics
	license = LGPL
	date = 2018-07-04
	notify = julian.parsert@uibk.ac.at, cezary.kaliszyk@uibk.ac.at
	abstract =
	Utility functions form an essential part of game theory and economics.
	In order to guarantee the existence of utility functions most of the
	time sufficient properties are assumed in an axiomatic manner. One
	famous and very common set of such assumptions is that of expected
	utility theory. Here, the rationality, continuity, and independence of
	preferences is assumed. The von-Neumann-Morgenstern Utility theorem
	shows that these assumptions are necessary and sufficient for an
	expected utility function to exists. This theorem was proven by
	Neumann and Morgenstern in ``Theory of Games and Economic
	Behavior'' which is regarded as one of the most influential
	works in game theory. The formalization includes formal definitions of
	the underlying concepts including continuity and independence of
	preferences.

	[Simplex]
	title = An Incremental Simplex Algorithm with Unsatisfiable Core Generation
	author = Filip Marić <mailto:filip@matf.bg.ac.rs>, Mirko Spasić <mailto:mirko@matf.bg.ac.rs>, René Thiemann <http://cl-informatik.uibk.ac.at/~thiemann/>
	topic = Computer Science/Algorithms
	date = 2018-08-24
	notify = rene.thiemann@uibk.ac.at
	abstract =
	We present an Isabelle/HOL formalization and total correctness proof
	for the incremental version of the Simplex algorithm which is used in
	most state-of-the-art SMT solvers. It supports extraction of
	satisfying assignments, extraction of minimal unsatisfiable cores, incremental
	assertion of constraints and backtracking. The formalization relies on
	stepwise program refinement, starting from a simple specification,
	going through a number of refinement steps, and ending up in a fully
	executable functional implementation. Symmetries present in the
	algorithm are handled with special care.

	[Budan_Fourier]
	title = The Budan-Fourier Theorem and Counting Real Roots with Multiplicity
	author = Wenda Li <https://www.cl.cam.ac.uk/~wl302/>
	topic = Mathematics/Analysis
	date = 2018-09-02
	notify = wl302@cam.ac.uk, liwenda1990@hotmail.com
	abstract =
	This entry is mainly about counting and approximating real roots (of a
	polynomial) with multiplicity. We have first formalised the
	Budan-Fourier theorem: given a polynomial with real coefficients, we
	can calculate sign variations on Fourier sequences to over-approximate
	the number of real roots (counting multiplicity) within an interval.
	When all roots are known to be real, the over-approximation becomes
	tight: we can utilise this theorem to count real roots exactly. It is
	also worth noting that Descartes' rule of sign is a direct
	consequence of the Budan-Fourier theorem, and has been included in
	this entry. In addition, we have extended previous formalised
	Sturm's theorem to count real roots with multiplicity, while the
	original Sturm's theorem only counts distinct real roots.
	Compared to the Budan-Fourier theorem, our extended Sturm's
	theorem always counts roots exactly but may suffer from greater
	computational cost.

	[Quaternions]
	title = Quaternions
	author = Lawrence C. Paulson <https://www.cl.cam.ac.uk/~lp15/>
	topic = Mathematics/Algebra, Mathematics/Geometry
	date = 2018-09-05
	notify = lp15@cam.ac.uk
	abstract =
	This theory is inspired by the HOL Light development of quaternions,
	but follows its own route. Quaternions are developed coinductively, as
	in the existing formalisation of the complex numbers. Quaternions are
	quickly shown to belong to the type classes of real normed division
	algebras and real inner product spaces. And therefore they inherit a
	great body of facts involving algebraic laws, limits, continuity,
	etc., which must be proved explicitly in the HOL Light version. The
	development concludes with the geometric interpretation of the product
	of imaginary quaternions.

	[Octonions]
	title = Octonions
	author = Angeliki Koutsoukou-Argyraki <http://www.cl.cam.ac.uk/~ak2110/>
	topic = Mathematics/Algebra, Mathematics/Geometry
	date = 2018-09-14
	notify = ak2110@cam.ac.uk
	abstract =
	We develop the basic theory of Octonions, including various identities
	and properties of the octonions and of the octonionic product, a
	description of 7D isometries and representations of orthogonal
	transformations. To this end we first develop the theory of the vector
	cross product in 7 dimensions. The development of the theory of
	Octonions is inspired by that of the theory of Quaternions by Lawrence
	Paulson. However, we do not work within the type class real_algebra_1
	because the octonionic product is not associative.

	[Aggregation_Algebras]
	title = Aggregation Algebras
	author = Walter Guttmann <http://www.cosc.canterbury.ac.nz/walter.guttmann/>
	topic = Mathematics/Algebra
	date = 2018-09-15
	notify = walter.guttmann@canterbury.ac.nz
	abstract =
	We develop algebras for aggregation and minimisation for weight
	matrices and for edge weights in graphs. We verify the correctness of
	Prim's and Kruskal's minimum spanning tree algorithms based
	on these algebras. We also show numerous instances of these algebras
	based on linearly ordered commutative semigroups.

	[Prime_Number_Theorem]
	title = The Prime Number Theorem
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>, Lawrence C. Paulson <https://www.cl.cam.ac.uk/~lp15/>
	topic = Mathematics/Number Theory
	date = 2018-09-19
	notify = eberlm@in.tum.de
	abstract =
	<p>This article provides a short proof of the Prime Number
	Theorem in several equivalent forms, most notably
	π(<em>x</em>) ~ <em>x</em>/ln
	<em>x</em> where π(<em>x</em>) is the
	number of primes no larger than <em>x</em>. It also
	defines other basic number-theoretic functions related to primes like
	Chebyshev's functions &thetasym; and ψ and the
	“<em>n</em>-th prime number” function
	p<sub><em>n</em></sub>. We also show various
	bounds and relationship between these functions are shown. Lastly, we
	derive Mertens' First and Second Theorem, i. e.
	∑<sub><em>p</em>≤<em>x</em></sub>
	ln <em>p</em>/<em>p</em> = ln
	<em>x</em> + <em>O</em>(1) and
	∑<sub><em>p</em>≤<em>x</em></sub>
	1/<em>p</em> = ln ln <em>x</em> + M +
	<em>O</em>(1/ln <em>x</em>). We also give
	explicit bounds for the remainder terms.</p> <p>The proof
	of the Prime Number Theorem builds on a library of Dirichlet series
	and analytic combinatorics. We essentially follow the presentation by
	Newman. The core part of the proof is a Tauberian theorem for
	Dirichlet series, which is proven using complex analysis and then used
	to strengthen Mertens' First Theorem to
	∑<sub><em>p</em>≤<em>x</em></sub>
	ln <em>p</em>/<em>p</em> = ln
	<em>x</em> + c + <em>o</em>(1).</p>
	<p>A variant of this proof has been formalised before by
	Harrison in HOL Light, and formalisations of Selberg's elementary
	proof exist both by Avigad <em>et al.</em> in Isabelle and
	by Carneiro in Metamath. The advantage of the analytic proof is that,
	while it requires more powerful mathematical tools, it is considerably
	shorter and clearer. This article attempts to provide a short and
	clear formalisation of all components of that proof using the full
	range of mathematical machinery available in Isabelle, staying as
	close as possible to Newman's simple paper proof.</p>

	[Signature_Groebner]
	title = Signature-Based Gröbner Basis Algorithms
	author = Alexander Maletzky <https://risc.jku.at/m/alexander-maletzky/>
	topic = Mathematics/Algebra, Computer Science/Algorithms
	date = 2018-09-20
	notify = alexander.maletzky@risc.jku.at
	abstract =
	<p>This article formalizes signature-based algorithms for computing
	Gröbner bases. Such algorithms are, in general, superior to
	other algorithms in terms of efficiency, and have not been formalized
	in any proof assistant so far. The present development is both
	generic, in the sense that most known variants of signature-based
	algorithms are covered by it, and effectively executable on concrete
	input thanks to Isabelle's code generator. Sample computations of
	benchmark problems show that the verified implementation of
	signature-based algorithms indeed outperforms the existing
	implementation of Buchberger's algorithm in Isabelle/HOL.</p>
	<p>Besides total correctness of the algorithms, the article also proves
	that under certain conditions they a-priori detect and avoid all
	useless zero-reductions, and always return 'minimal' (in
	some sense) Gröbner bases if an input parameter is chosen in
	the right way.</p><p>The formalization follows the recent survey article by
	Eder and Faugère.</p>

	[Factored_Transition_System_Bounding]
	title = Upper Bounding Diameters of State Spaces of Factored Transition Systems
	author = Friedrich Kurz <>, Mohammad Abdulaziz <http://home.in.tum.de/~mansour/>
	topic = Computer Science/Automata and Formal Languages, Mathematics/Graph Theory
	date = 2018-10-12
	notify = friedrich.kurz@tum.de, mohammad.abdulaziz@in.tum.de
	abstract =
	A completeness threshold is required to guarantee the completeness of
	planning as satisfiability, and bounded model checking of safety
	properties. One valid completeness threshold is the diameter of the
	underlying transition system. The diameter is the maximum element in
	the set of lengths of all shortest paths between pairs of states. The
	diameter is not calculated exactly in our setting, where the
	transition system is succinctly described using a (propositionally)
	factored representation. Rather, an upper bound on the diameter is
	calculated compositionally, by bounding the diameters of small
	abstract subsystems, and then composing those. We port a HOL4
	formalisation of a compositional algorithm for computing a relatively
	tight upper bound on the system diameter. This compositional algorithm
	exploits acyclicity in the state space to achieve compositionality,
	and it was introduced by Abdulaziz et. al. The formalisation that we
	port is described as a part of another paper by Abdulaziz et. al. As a
	part of this porting we developed a libray about transition systems,
	which shall be of use in future related mechanisation efforts.

	[Smooth_Manifolds]
	title = Smooth Manifolds
	author = Fabian Immler <http://home.in.tum.de/~immler/>, Bohua Zhan <http://lcs.ios.ac.cn/~bzhan/>
	topic = Mathematics/Analysis, Mathematics/Topology
	date = 2018-10-22
	notify = immler@in.tum.de, bzhan@ios.ac.cn
	abstract =
	We formalize the definition and basic properties of smooth manifolds
	in Isabelle/HOL. Concepts covered include partition of unity, tangent
	and cotangent spaces, and the fundamental theorem of path integrals.
	We also examine some concrete manifolds such as spheres and projective
	spaces. The formalization makes extensive use of the analysis and
	linear algebra libraries in Isabelle/HOL, in particular its
	“types-to-sets” mechanism.

	[Matroids]
	title = Matroids
	author = Jonas Keinholz<>
	topic = Mathematics/Combinatorics
	date = 2018-11-16
	notify = eberlm@in.tum.de
	abstract =
	<p>This article defines the combinatorial structures known as
	<em>Independence Systems</em> and
	<em>Matroids</em> and provides basic concepts and theorems
	related to them. These structures play an important role in
	combinatorial optimisation, e. g. greedy algorithms such as
	Kruskal's algorithm. The development is based on Oxley's
	<a href="http://www.math.lsu.edu/~oxley/survey4.pdf">`What
	is a Matroid?'</a>.</p>

	[Graph_Saturation]
	title = Graph Saturation
	author = Sebastiaan J. C. Joosten<>
	topic = Logic/Rewriting, Mathematics/Graph Theory
	date = 2018-11-23
	notify = sjcjoosten@gmail.com
	abstract =
	This is an Isabelle/HOL formalisation of graph saturation, closely
	following a <a href="https://doi.org/10.1016/j.jlamp.2018.06.005">paper by the author</a> on graph saturation.
	Nine out of ten lemmas of the original paper are proven in this
	formalisation. The formalisation additionally includes two theorems
	that show the main premise of the paper: that consistency and
	entailment are decided through graph saturation. This formalisation
	does not give executable code, and it did not implement any of the
	optimisations suggested in the paper.

	[Functional_Ordered_Resolution_Prover]
	title = A Verified Functional Implementation of Bachmair and Ganzinger's Ordered Resolution Prover
	author = Anders Schlichtkrull <mailto:andschl@dtu.dk>, Jasmin Christian Blanchette <mailto:j.c.blanchette@vu.nl>, Dmitriy Traytel <mailto:traytel@inf.ethz.ch>
	topic = Logic
	date = 2018-11-23
	notify = andschl@dtu.dk,j.c.blanchette@vu.nl,traytel@inf.ethz.ch
	abstract =
	This Isabelle/HOL formalization refines the abstract ordered
	resolution prover presented in Section 4.3 of Bachmair and
	Ganzinger's "Resolution Theorem Proving" chapter in the
	<i>Handbook of Automated Reasoning</i>. The result is a
	functional implementation of a first-order prover.

	[Auto2_HOL]
	title = Auto2 Prover
	author = Bohua Zhan <http://lcs.ios.ac.cn/~bzhan/>
	topic = Tools
	date = 2018-11-20
	notify = bzhan@ios.ac.cn
	abstract =
	Auto2 is a saturation-based heuristic prover for higher-order logic,
	implemented as a tactic in Isabelle. This entry contains the
	instantiation of auto2 for Isabelle/HOL, along with two basic
	examples: solutions to some of the Pelletier’s problems, and
	elementary number theory of primes.

	[Order_Lattice_Props]
	title = Properties of Orderings and Lattices
	author = Georg Struth <http://staffwww.dcs.shef.ac.uk/people/G.Struth/>
	topic = Mathematics/Algebra
	date = 2018-12-11
	notify = g.struth@sheffield.ac.uk
	abstract =
	These components add further fundamental order and lattice-theoretic
	concepts and properties to Isabelle's libraries. They follow by
	and large the introductory sections of the Compendium of Continuous
	Lattices, covering directed and filtered sets, down-closed and
	up-closed sets, ideals and filters, Galois connections, closure and
	co-closure operators. Some emphasis is on duality and morphisms
	between structures, as in the Compendium. To this end, three ad-hoc
	approaches to duality are compared.

	[Quantales]
	title = Quantales
	author = Georg Struth <http://staffwww.dcs.shef.ac.uk/people/G.Struth/>
	topic = Mathematics/Algebra
	date = 2018-12-11
	notify = g.struth@sheffield.ac.uk
	abstract =
	These mathematical components formalise basic properties of quantales,
	together with some important models, constructions, and concepts,
	including quantic nuclei and conuclei.

	[Transformer_Semantics]
	title = Transformer Semantics
	author = Georg Struth <http://staffwww.dcs.shef.ac.uk/people/G.Struth/>
	topic = Mathematics/Algebra, Computer Science/Semantics
	date = 2018-12-11
	notify = g.struth@sheffield.ac.uk
	abstract =
	These mathematical components formalise predicate transformer
	semantics for programs, yet currently only for partial correctness and
	in the absence of faults. A first part for isotone (or monotone),
	Sup-preserving and Inf-preserving transformers follows Back and von
	Wright's approach, with additional emphasis on the quantalic
	structure of algebras of transformers. The second part develops
	Sup-preserving and Inf-preserving predicate transformers from the
	powerset monad, via its Kleisli category and Eilenberg-Moore algebras,
	with emphasis on adjunctions and dualities, as well as isomorphisms
	between relations, state transformers and predicate transformers.

	[Concurrent_Revisions]
	title = Formalization of Concurrent Revisions
	author = Roy Overbeek <mailto:Roy.Overbeek@cwi.nl>
	topic = Computer Science/Concurrency
	date = 2018-12-25
	notify = Roy.Overbeek@cwi.nl
	abstract =
	Concurrent revisions is a concurrency control model developed by
	Microsoft Research. It has many interesting properties that
	distinguish it from other well-known models such as transactional
	memory. One of these properties is <em>determinacy</em>:
	programs written within the model always produce the same outcome,
	independent of scheduling activity. The concurrent revisions model has
	an operational semantics, with an informal proof of determinacy. This
	document contains an Isabelle/HOL formalization of this semantics and
	the proof of determinacy.

	[Core_DOM]
	title = A Formal Model of the Document Object Model
	author = Achim D. Brucker <https://www.brucker.ch/>, Michael Herzberg <http://www.dcs.shef.ac.uk/cgi-bin/makeperson?M.Herzberg>
	topic = Computer Science/Data Structures
	date = 2018-12-26
	notify = adbrucker@0x5f.org
	abstract =
	In this AFP entry, we formalize the core of the Document Object Model
	(DOM). At its core, the DOM defines a tree-like data structure for
	representing documents in general and HTML documents in particular. It
	is the heart of any modern web browser. Formalizing the key concepts
	of the DOM is a prerequisite for the formal reasoning over client-side
	JavaScript programs and for the analysis of security concepts in
	modern web browsers. We present a formalization of the core DOM, with
	focus on the node-tree and the operations defined on node-trees, in
	Isabelle/HOL. We use the formalization to verify the functional
	correctness of the most important functions defined in the DOM
	standard. Moreover, our formalization is 1) extensible, i.e., can be
	extended without the need of re-proving already proven properties and
	2) executable, i.e., we can generate executable code from our
	specification.

	[Store_Buffer_Reduction]
	title = A Reduction Theorem for Store Buffers
	author = Ernie Cohen <mailto:ecohen@amazon.com>, Norbert Schirmer <mailto:norbert.schirmer@web.de>
	topic = Computer Science/Concurrency
	date = 2019-01-07
	notify = norbert.schirmer@web.de
	abstract =
	When verifying a concurrent program, it is usual to assume that memory
	is sequentially consistent. However, most modern multiprocessors
	depend on store buffering for efficiency, and provide native
	sequential consistency only at a substantial performance penalty. To
	regain sequential consistency, a programmer has to follow an
	appropriate programming discipline. However, naïve disciplines,
	such as protecting all shared accesses with locks, are not flexible
	enough for building high-performance multiprocessor software. We
	present a new discipline for concurrent programming under TSO (total
	store order, with store buffer forwarding). It does not depend on
	concurrency primitives, such as locks. Instead, threads use ghost
	operations to acquire and release ownership of memory addresses. A
	thread can write to an address only if no other thread owns it, and
	can read from an address only if it owns it or it is shared and the
	thread has flushed its store buffer since it last wrote to an address
	it did not own. This discipline covers both coarse-grained concurrency
	(where data is protected by locks) as well as fine-grained concurrency
	(where atomic operations race to memory). We formalize this
	discipline in Isabelle/HOL, and prove that if every execution of a
	program in a system without store buffers follows the discipline, then
	every execution of the program with store buffers is sequentially
	consistent. Thus, we can show sequential consistency under TSO by
	ordinary assertional reasoning about the program, without having to
	consider store buffers at all.

	[IMP2]
	title = IMP2 – Simple Program Verification in Isabelle/HOL
	author = Peter Lammich <http://www21.in.tum.de/~lammich>, Simon Wimmer <http://in.tum.de/~wimmers>
	topic = Computer Science/Programming Languages/Logics, Computer Science/Algorithms
	date = 2019-01-15
	notify = lammich@in.tum.de
	abstract =
	IMP2 is a simple imperative language together with Isabelle tooling to
	create a program verification environment in Isabelle/HOL. The tools
	include a C-like syntax, a verification condition generator, and
	Isabelle commands for the specification of programs. The framework is
	modular, i.e., it allows easy reuse of already proved programs within
	larger programs. This entry comes with a quickstart guide and a large
	collection of examples, spanning basic algorithms with simple proofs
	to more advanced algorithms and proof techniques like data refinement.
	Some highlights from the examples are: <ul> <li>Bisection
	Square Root, </li> <li>Extended Euclid, </li>
	<li>Exponentiation by Squaring, </li> <li>Binary
	Search, </li> <li>Insertion Sort, </li>
	<li>Quicksort, </li> <li>Depth First Search.
	</li> </ul> The abstract syntax and semantics are very
	simple and well-documented. They are suitable to be used in a course,
	as extension to the IMP language which comes with the Isabelle
	distribution. While this entry is limited to a simple imperative
	language, the ideas could be extended to more sophisticated languages.

	[Farkas]
	title = Farkas' Lemma and Motzkin's Transposition Theorem
	author = Ralph Bottesch <http://cl-informatik.uibk.ac.at/users/bottesch/>, Max W. Haslbeck <http://cl-informatik.uibk.ac.at/users/mhaslbeck/>, René Thiemann <http://cl-informatik.uibk.ac.at/~thiemann/>
	topic = Mathematics/Algebra
	date = 2019-01-17
	notify = rene.thiemann@uibk.ac.at
	abstract =
	We formalize a proof of Motzkin's transposition theorem and
	Farkas' lemma in Isabelle/HOL. Our proof is based on the
	formalization of the simplex algorithm which, given a set of linear
	constraints, either returns a satisfying assignment to the problem or
	detects unsatisfiability. By reusing facts about the simplex algorithm
	we show that a set of linear constraints is unsatisfiable if and only
	if there is a linear combination of the constraints which evaluates to
	a trivially unsatisfiable inequality.

	[Auto2_Imperative_HOL]
	title = Verifying Imperative Programs using Auto2
	author = Bohua Zhan <http://lcs.ios.ac.cn/~bzhan/>
	topic = Computer Science/Algorithms, Computer Science/Data Structures
	date = 2018-12-21
	notify = bzhan@ios.ac.cn
	abstract =
	This entry contains the application of auto2 to verifying functional
	and imperative programs. Algorithms and data structures that are
	verified include linked lists, binary search trees, red-black trees,
	interval trees, priority queue, quicksort, union-find, Dijkstra's
	algorithm, and a sweep-line algorithm for detecting rectangle
	intersection. The imperative verification is based on Imperative HOL
	and its separation logic framework. A major goal of this work is to
	set up automation in order to reduce the length of proof that the user
	needs to provide, both for verifying functional programs and for
	working with separation logic.

	[UTP]
	title = Isabelle/UTP: Mechanised Theory Engineering for Unifying Theories of Programming
	author = Simon Foster <https://www-users.cs.york.ac.uk/~simonf/>, Frank Zeyda<>, Yakoub Nemouchi <mailto:yakoub.nemouchi@york.ac.uk>, Pedro Ribeiro<>, Burkhart Wolff<mailto:wolff@lri.fr>
	topic = Computer Science/Programming Languages/Logics
	date = 2019-02-01
	notify = simon.foster@york.ac.uk
	abstract =
	Isabelle/UTP is a mechanised theory engineering toolkit based on Hoare
	and He’s Unifying Theories of Programming (UTP). UTP enables the
	creation of denotational, algebraic, and operational semantics for
	different programming languages using an alphabetised relational
	calculus. We provide a semantic embedding of the alphabetised
	relational calculus in Isabelle/HOL, including new type definitions,
	relational constructors, automated proof tactics, and accompanying
	algebraic laws. Isabelle/UTP can be used to both capture laws of
	programming for different languages, and put these fundamental
	theorems to work in the creation of associated verification tools,
	using calculi like Hoare logics. This document describes the
	relational core of the UTP in Isabelle/HOL.

	[HOL-CSP]
	title = HOL-CSP Version 2.0
	author = Safouan Taha <mailto:safouan.taha@lri.fr>, Lina Ye <mailto:lina.ye@lri.fr>, Burkhart Wolff<mailto:wolff@lri.fr>
	topic = Computer Science/Concurrency/Process Calculi, Computer Science/Semantics
	date = 2019-04-26
	notify = wolff@lri.fr
	abstract =
	This is a complete formalization of the work of Hoare and Roscoe on
	the denotational semantics of the Failure/Divergence Model of CSP. It
	follows essentially the presentation of CSP in Roscoe’s Book ”Theory
	and Practice of Concurrency” [8] and the semantic details in a joint
	Paper of Roscoe and Brooks ”An improved failures model for
	communicating processes". The present work is based on a prior
	formalization attempt, called HOL-CSP 1.0, done in 1997 by H. Tej and
	B. Wolff with the Isabelle proof technology available at that time.
	This work revealed minor, but omnipresent foundational errors in key
	concepts like the process invariant. The present version HOL-CSP
	profits from substantially improved libraries (notably HOLCF),
	improved automated proof techniques, and structured proof techniques
	in Isar and is substantially shorter but more complete.

	[Probabilistic_Prime_Tests]
	title = Probabilistic Primality Testing
	author = Daniel Stüwe<>, Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Number Theory
	date = 2019-02-11
	notify = eberlm@in.tum.de
	abstract =
	<p>The most efficient known primality tests are
	<em>probabilistic</em> in the sense that they use
	randomness and may, with some probability, mistakenly classify a
	composite number as prime – but never a prime number as
	composite. Examples of this are the Miller–Rabin test, the
	Solovay–Strassen test, and (in most cases) Fermat's
	test.</p> <p>This entry defines these three tests and
	proves their correctness. It also develops some of the
	number-theoretic foundations, such as Carmichael numbers and the
	Jacobi symbol with an efficient executable algorithm to compute
	it.</p>

	[Kruskal]
	title = Kruskal's Algorithm for Minimum Spanning Forest
	author = Maximilian P.L. Haslbeck <http://in.tum.de/~haslbema/>, Peter Lammich <http://www21.in.tum.de/~lammich>, Julian Biendarra<>
	topic = Computer Science/Algorithms
	date = 2019-02-14
	notify = haslbema@in.tum.de, lammich@in.tum.de
	abstract =
	This Isabelle/HOL formalization defines a greedy algorithm for finding
	a minimum weight basis on a weighted matroid and proves its
	correctness. This algorithm is an abstract version of Kruskal's
	algorithm. We interpret the abstract algorithm for the cycle matroid
	(i.e. forests in a graph) and refine it to imperative executable code
	using an efficient union-find data structure. Our formalization can
	be instantiated for different graph representations. We provide
	instantiations for undirected graphs and symmetric directed graphs.

	[List_Inversions]
	title = The Inversions of a List
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Computer Science/Algorithms
	date = 2019-02-01
	notify = eberlm@in.tum.de
	abstract =
	<p>This entry defines the set of <em>inversions</em>
	of a list, i.e. the pairs of indices that violate sortedness. It also
	proves the correctness of the well-known
	<em>O</em>(<em>n log n</em>)
	divide-and-conquer algorithm to compute the number of
	inversions.</p>

	[Prime_Distribution_Elementary]
	title = Elementary Facts About the Distribution of Primes
	author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
	topic = Mathematics/Number Theory
	date = 2019-02-21
	notify = eberlm@in.tum.de
	abstract =
	<p>This entry is a formalisation of Chapter 4 (and parts of
	Chapter 3) of Apostol's <a
	href="https://www.springer.com/de/book/9780387901633"><em>Introduction
	to Analytic Number Theory</em></a>. The main topics that
	are addressed are properties of the distribution of prime numbers that
	can be shown in an elementary way (i. e. without the Prime
	Number Theorem), the various equivalent forms of the PNT (which imply
	each other in elementary ways), and consequences that follow from the
	PNT in elementary ways. The latter include, most notably, asymptotic
	bounds for the number of distinct prime factors of
	<em>n</em>, the divisor function
	<em>d(n)</em>, Euler's totient function
	<em>φ(n)</em>, and
	lcm(1,…,<em>n</em>).</p>

	[Safe_OCL]
	title = Safe OCL
	author = Denis Nikiforov <>
	topic = Computer Science/Programming Languages/Language Definitions
	license = LGPL
	date = 2019-03-09
	notify = denis.nikif@gmail.com
	abstract =
	<p>The theory is a formalization of the
	<a href="https://www.omg.org/spec/OCL/">OCL</a> type system, its abstract
	syntax and expression typing rules. The theory does not define a concrete
	syntax and a semantics. In contrast to
	<a href="https://www.isa-afp.org/entries/Featherweight_OCL.html">Featherweight OCL</a>,
	it is based on a deep embedding approach. The type system is defined from scratch,
	it is not based on the Isabelle HOL type system.</p>
	<p>The Safe OCL distincts nullable and non-nullable types. Also the theory gives a
	formal definition of <a href="http://ceur-ws.org/Vol-1512/paper07.pdf">safe
	navigation operations</a>. The Safe OCL typing rules are much stricter than rules
	given in the OCL specification. It allows one to catch more errors on a type
	checking phase.</p>
	<p>The type theory presented is four-layered: classes, basic types, generic types,
	errorable types. We introduce the following new types: non-nullable types (T[1]),
	nullable types (T[?]), OclSuper. OclSuper is a supertype of all other types (basic
	types, collections, tuples). This type allows us to define a total supremum function,
	so types form an upper semilattice. It allows us to define rich expression typing
	rules in an elegant manner.</p>
	<p>The Preliminaries Chapter of the theory defines a number of helper lemmas for
	transitive closures and tuples. It defines also a generic object model independent
	from OCL. It allows one to use the theory as a reference for formalization of analogous languages.</p>

	[QHLProver]
	title = Quantum Hoare Logic
	author = Junyi Liu<>, Bohua Zhan <http://lcs.ios.ac.cn/~bzhan/>, Shuling Wang<>, Shenggang Ying<>, Tao Liu<>, Yangjia Li<>, Mingsheng Ying<>, Naijun Zhan<>
	topic = Computer Science/Programming Languages/Logics, Computer Science/Semantics
	date = 2019-03-24
	notify = bzhan@ios.ac.cn
	abstract =
	We formalize quantum Hoare logic as given in [1]. In particular, we
	specify the syntax and denotational semantics of a simple model of
	quantum programs. Then, we write down the rules of quantum Hoare logic
	for partial correctness, and show the soundness and completeness of
	the resulting proof system. As an application, we verify the
	correctness of Grover’s algorithm.

	[Transcendence_Series_Hancl_Rucki]
	title = The Transcendence of Certain Infinite Series
	author = Angeliki Koutsoukou-Argyraki <https://www.cl.cam.ac.uk/~ak2110/>, Wenda Li <https://www.cl.cam.ac.uk/~wl302/>
	topic = Mathematics/Analysis, Mathematics/Number Theory
	date = 2019-03-27
	notify = wl302@cam.ac.uk, ak2110@cam.ac.uk
	abstract =
	We formalize the proofs of two transcendence criteria by J. Hančl
	and P. Rucki that assert the transcendence of the sums of certain
	infinite series built up by sequences that fulfil certain properties.
	Both proofs make use of Roth's celebrated theorem on diophantine
	approximations to algebraic numbers from 1955 which we implement as
	an assumption without having formalised its proof.

	[Binding_Syntax_Theory]
	title = A General Theory of Syntax with Bindings
	author = Lorenzo Gheri <mailto:lor.gheri@gmail.com>, Andrei Popescu <mailto:a.popescu@mdx.ac.uk>
	topic = Computer Science/Programming Languages/Lambda Calculi, Computer Science/Functional Programming, Logic
	date = 2019-04-06
	notify = a.popescu@mdx.ac.uk, lor.gheri@gmail.com
	abstract =
	We formalize a theory of syntax with bindings that has been developed
	and refined over the last decade to support several large
	formalization efforts. Terms are defined for an arbitrary number of
	constructors of varying numbers of inputs, quotiented to
	alpha-equivalence and sorted according to a binding signature. The
	theory includes many properties of the standard operators on terms:
	substitution, swapping and freshness. It also includes bindings-aware
	induction and recursion principles and support for semantic
	interpretation. This work has been presented in the ITP 2017 paper “A
	Formalized General Theory of Syntax with Bindings”.

	[LTL_Master_Theorem]
	title = A Compositional and Unified Translation of LTL into ω-Automata
	author = Benedikt Seidl <mailto:benedikt.seidl@tum.de>, Salomon Sickert <mailto:s.sickert@tum.de>
	topic = Computer Science/Automata and Formal Languages
	date = 2019-04-16
	notify = benedikt.seidl@tum.de, s.sickert@tum.de
	abstract =
	We present a formalisation of the unified translation approach of
	linear temporal logic (LTL) into ω-automata from [1]. This approach
	decomposes LTL formulas into ``simple'' languages and allows
	a clear separation of concerns: first, we formalise the purely logical
	result yielding this decomposition; second, we instantiate this
	generic theory to obtain a construction for deterministic
	(state-based) Rabin automata (DRA). We extract from this particular
	instantiation an executable tool translating LTL to DRAs. To the best
	of our knowledge this is the first verified translation from LTL to
	DRAs that is proven to be double exponential in the worst case which
	asymptotically matches the known lower bound.
	<p>
	[1] Javier Esparza, Jan Kretínský, Salomon Sickert. One Theorem to Rule Them All:
	A Unified Translation of LTL into ω-Automata. LICS 2018

	[LambdaAuth]
	title = Formalization of Generic Authenticated Data Structures
	author = Matthias Brun<>, Dmitriy Traytel <http://people.inf.ethz.ch/trayteld/>
	topic = Computer Science/Security, Computer Science/Programming Languages/Lambda Calculi
	date = 2019-05-14
	notify = traytel@inf.ethz.ch
	abstract =
	Authenticated data structures are a technique for outsourcing data
	storage and maintenance to an untrusted server. The server is required
	to produce an efficiently checkable and cryptographically secure proof
	that it carried out precisely the requested computation. <a
	href="https://doi.org/10.1145/2535838.2535851">Miller et
	al.</a> introduced λ• (pronounced
	<i>lambda auth</i>)—a functional programming
	language with a built-in primitive authentication construct, which
	supports a wide range of user-specified authenticated data structures
	while guaranteeing certain correctness and security properties for all
	well-typed programs. We formalize λ• and prove its
	correctness and security properties. With Isabelle's help, we
	uncover and repair several mistakes in the informal proofs and lemma
	statements. Our findings are summarized in a <a
	href="http://people.inf.ethz.ch/trayteld/papers/lambdaauth/lambdaauth.pdf">paper
	draft</a>.
	+
	+[IMP2_Binary_Heap]
	+title = Binary Heaps for IMP2
	+author = Simon Griebel<>
	+topic = Computer Science/Data Structures, Computer Science/Algorithms
	+date = 2019-06-13
	+notify = s.griebel@tum.de
	+abstract =
	+ In this submission array-based binary minimum heaps are formalized.
	+ The correctness of the following heap operations is proved: insert,
	+ get-min, delete-min and make-heap. These are then used to verify an
	+ in-place heapsort. The formalization is based on IMP2, an imperative
	+ program verification framework implemented in Isabelle/HOL. The
	+ verified heap functions are iterative versions of the partly recursive
	+ functions found in "Algorithms and Data Structures – The Basic
	+ Toolbox" by K. Mehlhorn and P. Sanders and "Introduction to
	+ Algorithms" by T. H. Cormen, C. E. Leiserson, R. L. Rivest and C.
	+ Stein.
	+
	+[Groebner_Macaulay]
	+title = Gröbner Bases, Macaulay Matrices and Dubé's Degree Bounds
	+author = Alexander Maletzky <https://risc.jku.at/m/alexander-maletzky/>
	+topic = Mathematics/Algebra
	+date = 2019-06-15
	+notify = alexander.maletzky@risc.jku.at
	+abstract =
	+ This entry formalizes the connection between Gröbner bases and
	+ Macaulay matrices (sometimes also referred to as `generalized
	+ Sylvester matrices'). In particular, it contains a method for
	+ computing Gröbner bases, which proceeds by first constructing some
	+ Macaulay matrix of the initial set of polynomials, then row-reducing
	+ this matrix, and finally converting the result back into a set of
	+ polynomials. The output is shown to be a Gröbner basis if the Macaulay
	+ matrix constructed in the first step is sufficiently large. In order
	+ to obtain concrete upper bounds on the size of the matrix (and hence
	+ turn the method into an effectively executable algorithm), Dubé's
	+ degree bounds on Gröbner bases are utilized; consequently, they are
	+ also part of the formalization.
	+
	+[Linear_Inequalities]
	+title = Linear Inequalities
	+author = Ralph Bottesch <http://cl-informatik.uibk.ac.at/users/bottesch/>, Alban Reynaud <>, René Thiemann <http://cl-informatik.uibk.ac.at/~thiemann/>
	+topic = Mathematics/Algebra
	+date = 2019-06-21
	+notify = rene.thiemann@uibk.ac.at
	+abstract =
	+ We formalize results about linear inqualities, mainly from
	+ Schrijver's book. The main results are the proof of the
	+ fundamental theorem on linear inequalities, Farkas' lemma,
	+ Carathéodory's theorem, the Farkas-Minkowsky-Weyl theorem, the
	+ decomposition theorem of polyhedra, and Meyer's result that the
	+ integer hull of a polyhedron is a polyhedron itself. Several theorems
	+ include bounds on the appearing numbers, and in particular we provide
	+ an a-priori bound on mixed-integer solutions of linear inequalities.
	+
	diff --git a/metadata/release-dates b/metadata/release-dates
	--- a/metadata/release-dates
	+++ b/metadata/release-dates
	@@ -1,20 +1,21 @@
	2003 = 2003-05-13
	2004 = 2004-04-19
	2005 = 2005-09-30
	2007 = 2007-11-22
	2008 = 2008-06-08
	2009 = 2009-04-16
	2009-1 = 2009-12-02
	2009-2 = 2010-06-23
	2011 = 2011-02-11
	2011-1 = 2011-10-10
	2012 = 2012-05-23
	2013 = 2013-02-15
	2013-1 = 2013-11-12
	2013-2 = 2013-12-06
	2014 = 2014-08-28
	2015 = 2015-05-27
	2016 = 2016-02-18
	2016-1 = 2016-12-14
	2017 = 2017-10-10
	2018 = 2018-08-16
	+2019 = 2019-06-10
	diff --git a/metadata/releases b/metadata/releases
	--- a/metadata/releases
	+++ b/metadata/releases
	@@ -1,3371 +1,3846 @@
	afp-Abortable_Linearizable_Modules-2012-03-02.tar.gz
	afp-Abortable_Linearizable_Modules-2012-05-24.tar.gz
	afp-Abortable_Linearizable_Modules-2013-02-16.tar.gz
	afp-Abortable_Linearizable_Modules-2013-11-17.tar.gz
	afp-Abortable_Linearizable_Modules-2013-12-11.tar.gz
	afp-Abortable_Linearizable_Modules-2014-08-28.tar.gz
	afp-Abortable_Linearizable_Modules-2015-05-27.tar.gz
	afp-Abortable_Linearizable_Modules-2016-02-22.tar.gz
	afp-Abortable_Linearizable_Modules-2016-12-17.tar.gz
	afp-Abortable_Linearizable_Modules-2017-10-10.tar.gz
	afp-Abortable_Linearizable_Modules-2018-08-16.tar.gz
	+afp-Abortable_Linearizable_Modules-2019-06-11.tar.gz
	afp-Abs_Int_ITP2012-2016-12-17.tar.gz
	afp-Abs_Int_ITP2012-2017-10-10.tar.gz
	afp-Abs_Int_ITP2012-2018-08-16.tar.gz
	+afp-Abs_Int_ITP2012-2019-06-11.tar.gz
	afp-Abstract_Completeness-2014-04-16.tar.gz
	afp-Abstract_Completeness-2014-08-28.tar.gz
	afp-Abstract_Completeness-2015-05-27.tar.gz
	afp-Abstract_Completeness-2016-02-22.tar.gz
	afp-Abstract_Completeness-2016-12-17.tar.gz
	afp-Abstract_Completeness-2017-10-10.tar.gz
	afp-Abstract_Completeness-2018-08-16.tar.gz
	+afp-Abstract_Completeness-2019-06-11.tar.gz
	afp-Abstract-Hoare-Logics-2007-11-27.tar.gz
	afp-Abstract-Hoare-Logics-2008-06-10.tar.gz
	afp-Abstract-Hoare-Logics-2009-04-29.tar.gz
	afp-Abstract-Hoare-Logics-2009-12-12.tar.gz
	afp-Abstract-Hoare-Logics-2010-06-30.tar.gz
	afp-Abstract-Hoare-Logics-2011-02-11.tar.gz
	afp-Abstract-Hoare-Logics-2011-10-11.tar.gz
	afp-Abstract-Hoare-Logics-2012-05-24.tar.gz
	afp-Abstract-Hoare-Logics-2013-02-16.tar.gz
	afp-Abstract-Hoare-Logics-2013-11-17.tar.gz
	afp-Abstract-Hoare-Logics-2013-12-11.tar.gz
	afp-Abstract-Hoare-Logics-2014-08-28.tar.gz
	afp-Abstract-Hoare-Logics-2015-05-27.tar.gz
	afp-Abstract-Hoare-Logics-2016-02-22.tar.gz
	afp-Abstract-Hoare-Logics-2016-12-17.tar.gz
	afp-Abstract-Hoare-Logics-2017-10-10.tar.gz
	afp-Abstract-Hoare-Logics-2018-08-16.tar.gz
	+afp-Abstract-Hoare-Logics-2019-06-11.tar.gz
	afp-Abstract-Rewriting-2010-06-17.tar.gz
	afp-Abstract-Rewriting-2010-06-30.tar.gz
	afp-Abstract-Rewriting-2011-02-11.tar.gz
	afp-Abstract-Rewriting-2011-10-11.tar.gz
	afp-Abstract-Rewriting-2012-05-24.tar.gz
	afp-Abstract-Rewriting-2013-02-16.tar.gz
	afp-Abstract-Rewriting-2013-11-17.tar.gz
	afp-Abstract-Rewriting-2013-12-11.tar.gz
	afp-Abstract-Rewriting-2014-08-28.tar.gz
	afp-Abstract-Rewriting-2015-05-27.tar.gz
	afp-Abstract-Rewriting-2016-02-22.tar.gz
	afp-Abstract-Rewriting-2016-12-17.tar.gz
	afp-Abstract-Rewriting-2017-10-10.tar.gz
	afp-Abstract-Rewriting-2018-08-16.tar.gz
	+afp-Abstract-Rewriting-2019-06-11.tar.gz
	afp-Abstract_Soundness-2017-02-13.tar.gz
	afp-Abstract_Soundness-2017-10-10.tar.gz
	afp-Abstract_Soundness-2018-08-16.tar.gz
	+afp-Abstract_Soundness-2019-06-11.tar.gz
	afp-Affine_Arithmetic-2014-08-28.tar.gz
	afp-Affine_Arithmetic-2015-05-27.tar.gz
	afp-Affine_Arithmetic-2016-02-22.tar.gz
	afp-Affine_Arithmetic-2016-12-17.tar.gz
	afp-Affine_Arithmetic-2017-10-10.tar.gz
	afp-Affine_Arithmetic-2018-08-16.tar.gz
	+afp-Affine_Arithmetic-2019-06-11.tar.gz
	afp-Aggregation_Algebras-2018-09-16.tar.gz
	+afp-Aggregation_Algebras-2019-06-11.tar.gz
	afp-Akra_Bazzi-2015-07-15.tar.gz
	afp-Akra_Bazzi-2015-07-24.tar.gz
	afp-Akra_Bazzi-2016-02-22.tar.gz
	afp-Akra_Bazzi-2016-12-17.tar.gz
	afp-Akra_Bazzi-2017-10-10.tar.gz
	afp-Akra_Bazzi-2018-08-16.tar.gz
	+afp-Akra_Bazzi-2019-06-11.tar.gz
	afp-Algebraic_Numbers-2015-12-22.tar.gz
	afp-Algebraic_Numbers-2016-02-22.tar.gz
	afp-Algebraic_Numbers-2016-12-17.tar.gz
	afp-Algebraic_Numbers-2017-10-10.tar.gz
	afp-Algebraic_Numbers-2018-08-16.tar.gz
	+afp-Algebraic_Numbers-2019-06-11.tar.gz
	afp-Algebraic_VCs-2016-06-18.tar.gz
	afp-Algebraic_VCs-2016-12-17.tar.gz
	afp-Algebraic_VCs-2017-10-10.tar.gz
	afp-Algebraic_VCs-2018-08-16.tar.gz
	+afp-Algebraic_VCs-2019-06-11.tar.gz
	afp-Allen_Calculus-2016-09-29.tar.gz
	afp-Allen_Calculus-2016-10-05.tar.gz
	afp-Allen_Calculus-2016-12-17.tar.gz
	afp-Allen_Calculus-2017-10-10.tar.gz
	afp-Allen_Calculus-2018-08-16.tar.gz
	+afp-Allen_Calculus-2019-06-11.tar.gz
	afp-Amortized_Complexity-2014-08-28.tar.gz
	afp-Amortized_Complexity-2015-05-19.tar.gz
	afp-Amortized_Complexity-2015-05-27.tar.gz
	afp-Amortized_Complexity-2015-05-28.tar.gz
	afp-Amortized_Complexity-2016-02-22.tar.gz
	afp-Amortized_Complexity-2016-12-17.tar.gz
	afp-Amortized_Complexity-2017-10-10.tar.gz
	afp-Amortized_Complexity-2018-08-16.tar.gz
	+afp-Amortized_Complexity-2019-06-11.tar.gz
	afp-AnselmGod-2017-09-08.tar.gz
	afp-AnselmGod-2017-09-11.tar.gz
	afp-AnselmGod-2017-09-18.tar.gz
	afp-AnselmGod-2017-10-10.tar.gz
	afp-AnselmGod-2018-08-16.tar.gz
	+afp-AnselmGod-2019-06-11.tar.gz
	afp-AODV-2014-11-01.tar.gz
	afp-AODV-2014-11-03.tar.gz
	afp-AODV-2015-05-27.tar.gz
	afp-AODV-2016-02-22.tar.gz
	afp-AODV-2016-12-17.tar.gz
	afp-AODV-2017-10-10.tar.gz
	afp-AODV-2018-08-16.tar.gz
	+afp-AODV-2019-06-11.tar.gz
	afp-Applicative_Lifting-2015-12-22.tar.gz
	afp-Applicative_Lifting-2016-02-22.tar.gz
	afp-Applicative_Lifting-2016-12-17.tar.gz
	afp-Applicative_Lifting-2017-10-10.tar.gz
	afp-Applicative_Lifting-2018-08-16.tar.gz
	+afp-Applicative_Lifting-2019-06-11.tar.gz
	afp-Architectural_Design_Patterns-2018-03-01.tar.gz
	afp-Architectural_Design_Patterns-2018-08-16.tar.gz
	+afp-Architectural_Design_Patterns-2019-06-11.tar.gz
	afp-ArrowImpossibilityGS-2009-04-29.tar.gz
	afp-ArrowImpossibilityGS-2009-09-29.tar.gz
	afp-ArrowImpossibilityGS-2009-12-12.tar.gz
	afp-ArrowImpossibilityGS-2010-06-30.tar.gz
	afp-ArrowImpossibilityGS-2011-02-11.tar.gz
	afp-ArrowImpossibilityGS-2011-10-11.tar.gz
	afp-ArrowImpossibilityGS-2012-05-24.tar.gz
	afp-ArrowImpossibilityGS-2013-02-16.tar.gz
	afp-ArrowImpossibilityGS-2013-03-02.tar.gz
	afp-ArrowImpossibilityGS-2013-11-17.tar.gz
	afp-ArrowImpossibilityGS-2013-12-11.tar.gz
	afp-ArrowImpossibilityGS-2014-08-28.tar.gz
	afp-ArrowImpossibilityGS-2015-05-27.tar.gz
	afp-ArrowImpossibilityGS-2016-02-22.tar.gz
	afp-ArrowImpossibilityGS-2016-12-17.tar.gz
	afp-ArrowImpossibilityGS-2017-10-10.tar.gz
	afp-ArrowImpossibilityGS-2018-08-16.tar.gz
	+afp-ArrowImpossibilityGS-2019-06-11.tar.gz
	afp-Auto2_HOL-2018-11-29.tar.gz
	+afp-Auto2_HOL-2019-06-11.tar.gz
	afp-Auto2_Imperative_HOL-2019-01-22.tar.gz
	+afp-Auto2_Imperative_HOL-2019-06-11.tar.gz
	afp-AutoFocus-Stream-2011-02-24.tar.gz
	afp-AutoFocus-Stream-2011-10-11.tar.gz
	afp-AutoFocus-Stream-2012-05-24.tar.gz
	afp-AutoFocus-Stream-2013-02-16.tar.gz
	afp-AutoFocus-Stream-2013-03-08.tar.gz
	afp-AutoFocus-Stream-2013-11-17.tar.gz
	afp-AutoFocus-Stream-2013-12-11.tar.gz
	afp-AutoFocus-Stream-2014-08-28.tar.gz
	afp-AutoFocus-Stream-2015-05-27.tar.gz
	afp-AutoFocus-Stream-2016-02-22.tar.gz
	afp-AutoFocus-Stream-2016-12-17.tar.gz
	afp-AutoFocus-Stream-2017-10-10.tar.gz
	afp-AutoFocus-Stream-2018-08-16.tar.gz
	+afp-AutoFocus-Stream-2019-06-11.tar.gz
	afp-Automatic_Refinement-2013-11-17.tar.gz
	afp-Automatic_Refinement-2013-12-11.tar.gz
	afp-Automatic_Refinement-2014-08-28.tar.gz
	afp-Automatic_Refinement-2015-05-27.tar.gz
	afp-Automatic_Refinement-2016-02-22.tar.gz
	afp-Automatic_Refinement-2016-12-17.tar.gz
	afp-Automatic_Refinement-2017-10-10.tar.gz
	afp-Automatic_Refinement-2018-08-16.tar.gz
	+afp-Automatic_Refinement-2019-06-11.tar.gz
	afp-AVL-Trees-2004-03-19.tar.gz
	afp-AVL-Trees-2004-04-20.tar.gz
	afp-AVL-Trees-2004-05-21.tar.gz
	afp-AVL-Trees-2005-10-14.tar.gz
	afp-AVL-Trees-2007-11-27.tar.gz
	afp-AVL-Trees-2008-06-10.tar.gz
	afp-AVL-Trees-2009-04-29.tar.gz
	afp-AVL-Trees-2009-12-12.tar.gz
	afp-AVL-Trees-2010-06-30.tar.gz
	afp-AVL-Trees-2011-02-11.tar.gz
	afp-AVL-Trees-2011-10-11.tar.gz
	afp-AVL-Trees-2012-05-24.tar.gz
	afp-AVL-Trees-2013-02-16.tar.gz
	afp-AVL-Trees-2013-11-17.tar.gz
	afp-AVL-Trees-2013-12-11.tar.gz
	afp-AVL-Trees-2014-08-28.tar.gz
	afp-AVL-Trees-2015-05-27.tar.gz
	afp-AVL-Trees-2016-02-22.tar.gz
	afp-AVL-Trees-2016-12-17.tar.gz
	afp-AVL-Trees-2017-10-10.tar.gz
	afp-AVL-Trees-2018-08-16.tar.gz
	+afp-AVL-Trees-2019-06-11.tar.gz
	afp-AWN-2014-03-15.tar.gz
	afp-AWN-2014-08-28.tar.gz
	afp-AWN-2015-05-27.tar.gz
	afp-AWN-2016-02-22.tar.gz
	afp-AWN-2016-12-17.tar.gz
	afp-AWN-2017-10-10.tar.gz
	afp-AWN-2018-08-16.tar.gz
	+afp-AWN-2019-06-11.tar.gz
	afp-AxiomaticCategoryTheory-2018-05-23.tar.gz
	afp-AxiomaticCategoryTheory-2018-08-16.tar.gz
	+afp-AxiomaticCategoryTheory-2019-06-11.tar.gz
	afp-BDD-2008-03-07.tar.gz
	afp-BDD-2008-06-10.tar.gz
	afp-BDD-2009-04-29.tar.gz
	afp-BDD-2009-12-12.tar.gz
	afp-BDD-2010-06-30.tar.gz
	afp-BDD-2011-02-11.tar.gz
	afp-BDD-2011-10-11.tar.gz
	afp-BDD-2012-05-24.tar.gz
	afp-BDD-2013-02-16.tar.gz
	afp-BDD-2013-11-17.tar.gz
	afp-BDD-2013-12-11.tar.gz
	afp-BDD-2014-08-28.tar.gz
	afp-BDD-2015-05-27.tar.gz
	afp-BDD-2016-02-22.tar.gz
	afp-BDD-2016-12-17.tar.gz
	afp-BDD-2017-10-10.tar.gz
	afp-BDD-2018-08-16.tar.gz
	+afp-BDD-2019-06-11.tar.gz
	afp-Bell_Numbers_Spivey-2016-05-04.tar.gz
	afp-Bell_Numbers_Spivey-2016-12-17.tar.gz
	afp-Bell_Numbers_Spivey-2017-10-10.tar.gz
	afp-Bell_Numbers_Spivey-2018-08-16.tar.gz
	+afp-Bell_Numbers_Spivey-2019-06-11.tar.gz
	afp-Berlekamp_Zassenhaus-2016-12-17.tar.gz
	afp-Berlekamp_Zassenhaus-2017-10-10.tar.gz
	afp-Berlekamp_Zassenhaus-2018-08-16.tar.gz
	afp-Berlekamp_Zassenhaus-2018-09-07.tar.gz
	+afp-Berlekamp_Zassenhaus-2019-06-11.tar.gz
	afp-Bernoulli-2017-01-24.tar.gz
	afp-Bernoulli-2017-10-10.tar.gz
	afp-Bernoulli-2018-08-16.tar.gz
	+afp-Bernoulli-2019-06-11.tar.gz
	afp-Bertrands_Postulate-2017-01-18.tar.gz
	afp-Bertrands_Postulate-2017-10-10.tar.gz
	afp-Bertrands_Postulate-2018-08-16.tar.gz
	+afp-Bertrands_Postulate-2019-06-11.tar.gz
	afp-BinarySearchTree-2004-04-20.tar.gz
	afp-BinarySearchTree-2004-04-21.tar.gz
	afp-BinarySearchTree-2004-09-21.tar.gz
	afp-BinarySearchTree-2005-10-14.tar.gz
	afp-BinarySearchTree-2007-11-27.tar.gz
	afp-BinarySearchTree-2008-06-10.tar.gz
	afp-BinarySearchTree-2009-04-29.tar.gz
	afp-BinarySearchTree-2009-12-12.tar.gz
	afp-BinarySearchTree-2010-06-30.tar.gz
	afp-BinarySearchTree-2011-02-11.tar.gz
	afp-BinarySearchTree-2011-10-11.tar.gz
	afp-BinarySearchTree-2012-05-24.tar.gz
	afp-BinarySearchTree-2013-02-16.tar.gz
	afp-BinarySearchTree-2013-11-17.tar.gz
	afp-BinarySearchTree-2013-12-11.tar.gz
	afp-BinarySearchTree-2014-08-28.tar.gz
	afp-BinarySearchTree-2015-05-27.tar.gz
	afp-BinarySearchTree-2016-02-22.tar.gz
	afp-BinarySearchTree-2016-12-17.tar.gz
	afp-BinarySearchTree-2017-10-10.tar.gz
	afp-BinarySearchTree-2018-08-16.tar.gz
	+afp-BinarySearchTree-2019-06-11.tar.gz
	afp-Binding_Syntax_Theory-2019-04-08.tar.gz
	+afp-Binding_Syntax_Theory-2019-06-11.tar.gz
	afp-Binomial-Heaps-2010-10-28.tar.gz
	afp-Binomial-Heaps-2011-02-11.tar.gz
	afp-Binomial-Heaps-2011-10-11.tar.gz
	afp-Binomial-Heaps-2012-05-24.tar.gz
	afp-Binomial-Heaps-2013-02-16.tar.gz
	afp-Binomial-Heaps-2013-03-02.tar.gz
	afp-Binomial-Heaps-2013-11-17.tar.gz
	afp-Binomial-Heaps-2013-12-11.tar.gz
	afp-Binomial-Heaps-2014-08-28.tar.gz
	afp-Binomial-Heaps-2015-05-27.tar.gz
	afp-Binomial-Heaps-2016-02-22.tar.gz
	afp-Binomial-Heaps-2016-12-17.tar.gz
	afp-Binomial-Heaps-2017-10-10.tar.gz
	afp-Binomial-Heaps-2018-08-16.tar.gz
	+afp-Binomial-Heaps-2019-06-11.tar.gz
	afp-Binomial-Queues-2011-02-11.tar.gz
	afp-Binomial-Queues-2011-10-11.tar.gz
	afp-Binomial-Queues-2012-05-24.tar.gz
	afp-Binomial-Queues-2013-02-16.tar.gz
	afp-Binomial-Queues-2013-11-17.tar.gz
	afp-Binomial-Queues-2013-12-11.tar.gz
	afp-Binomial-Queues-2014-08-28.tar.gz
	afp-Binomial-Queues-2015-05-27.tar.gz
	afp-Binomial-Queues-2016-02-22.tar.gz
	afp-Binomial-Queues-2016-12-17.tar.gz
	afp-Binomial-Queues-2017-10-10.tar.gz
	afp-Binomial-Queues-2018-08-16.tar.gz
	+afp-Binomial-Queues-2019-06-11.tar.gz
	afp-BNF_CC-2018-04-25.tar.gz
	afp-BNF_CC-2018-08-16.tar.gz
	+afp-BNF_CC-2019-06-11.tar.gz
	afp-BNF_Operations-2018-08-16.tar.gz
	+afp-BNF_Operations-2019-06-11.tar.gz
	afp-Bondy-2012-10-27.tar.gz
	afp-Bondy-2013-02-16.tar.gz
	afp-Bondy-2013-11-17.tar.gz
	afp-Bondy-2013-12-11.tar.gz
	afp-Bondy-2014-08-28.tar.gz
	afp-Bondy-2015-05-27.tar.gz
	afp-Bondy-2016-02-22.tar.gz
	afp-Bondy-2016-12-17.tar.gz
	afp-Bondy-2017-10-10.tar.gz
	afp-Bondy-2018-08-16.tar.gz
	+afp-Bondy-2019-06-11.tar.gz
	afp-Boolean_Expression_Checkers-2014-06-08.tar.gz
	afp-Boolean_Expression_Checkers-2014-08-28.tar.gz
	afp-Boolean_Expression_Checkers-2015-05-27.tar.gz
	afp-Boolean_Expression_Checkers-2016-02-22.tar.gz
	afp-Boolean_Expression_Checkers-2016-12-17.tar.gz
	afp-Boolean_Expression_Checkers-2017-10-10.tar.gz
	afp-Boolean_Expression_Checkers-2018-08-16.tar.gz
	+afp-Boolean_Expression_Checkers-2019-06-11.tar.gz
	afp-Bounded_Deducibility_Security-2014-04-24.tar.gz
	afp-Bounded_Deducibility_Security-2014-08-28.tar.gz
	afp-Bounded_Deducibility_Security-2015-05-27.tar.gz
	afp-Bounded_Deducibility_Security-2016-02-22.tar.gz
	afp-Bounded_Deducibility_Security-2016-12-17.tar.gz
	afp-Bounded_Deducibility_Security-2017-10-10.tar.gz
	afp-Bounded_Deducibility_Security-2018-08-16.tar.gz
	+afp-Bounded_Deducibility_Security-2019-06-11.tar.gz
	afp-Buchi_Complementation-2017-10-27.tar.gz
	afp-Buchi_Complementation-2018-08-16.tar.gz
	+afp-Buchi_Complementation-2019-06-11.tar.gz
	afp-Budan_Fourier-2018-09-04.tar.gz
	+afp-Budan_Fourier-2019-06-11.tar.gz
	afp-Buffons_Needle-2017-06-06.tar.gz
	afp-Buffons_Needle-2017-10-10.tar.gz
	afp-Buffons_Needle-2018-08-16.tar.gz
	+afp-Buffons_Needle-2019-06-11.tar.gz
	afp-Buildings-2016-07-01.tar.gz
	afp-Buildings-2016-12-17.tar.gz
	afp-Buildings-2017-10-10.tar.gz
	afp-Buildings-2018-08-16.tar.gz
	+afp-Buildings-2019-06-11.tar.gz
	afp-BytecodeLogicJmlTypes-2008-12-22.tar.gz
	afp-BytecodeLogicJmlTypes-2009-04-29.tar.gz
	afp-BytecodeLogicJmlTypes-2009-12-12.tar.gz
	afp-BytecodeLogicJmlTypes-2010-06-30.tar.gz
	afp-BytecodeLogicJmlTypes-2011-02-11.tar.gz
	afp-BytecodeLogicJmlTypes-2011-10-11.tar.gz
	afp-BytecodeLogicJmlTypes-2012-05-24.tar.gz
	afp-BytecodeLogicJmlTypes-2013-02-16.tar.gz
	afp-BytecodeLogicJmlTypes-2013-11-17.tar.gz
	afp-BytecodeLogicJmlTypes-2013-12-11.tar.gz
	afp-BytecodeLogicJmlTypes-2014-08-28.tar.gz
	afp-BytecodeLogicJmlTypes-2015-05-27.tar.gz
	afp-BytecodeLogicJmlTypes-2016-02-22.tar.gz
	afp-BytecodeLogicJmlTypes-2016-12-17.tar.gz
	afp-BytecodeLogicJmlTypes-2017-10-10.tar.gz
	afp-BytecodeLogicJmlTypes-2018-08-16.tar.gz
	+afp-BytecodeLogicJmlTypes-2019-06-11.tar.gz
	afp-CakeML-2018-08-16.tar.gz
	+afp-CakeML-2019-06-11.tar.gz
	afp-Call_Arity-2015-02-20.tar.gz
	afp-Call_Arity-2015-02-21.tar.gz
	afp-Call_Arity-2015-05-11.tar.gz
	afp-Call_Arity-2015-05-27.tar.gz
	afp-Call_Arity-2016-02-22.tar.gz
	afp-Call_Arity-2016-12-17.tar.gz
	afp-Call_Arity-2017-10-10.tar.gz
	afp-Call_Arity-2018-08-16.tar.gz
	+afp-Call_Arity-2019-06-11.tar.gz
	afp-Card_Equiv_Relations-2016-05-24.tar.gz
	afp-Card_Equiv_Relations-2016-12-17.tar.gz
	afp-Card_Equiv_Relations-2017-10-10.tar.gz
	afp-Card_Equiv_Relations-2018-08-16.tar.gz
	+afp-Card_Equiv_Relations-2019-06-11.tar.gz
	afp-Card_Multisets-2016-06-26.tar.gz
	afp-Card_Multisets-2016-12-17.tar.gz
	afp-Card_Multisets-2017-10-10.tar.gz
	afp-Card_Multisets-2018-08-16.tar.gz
	+afp-Card_Multisets-2019-06-11.tar.gz
	afp-Card_Number_Partitions-2016-01-14.tar.gz
	afp-Card_Number_Partitions-2016-02-22.tar.gz
	afp-Card_Number_Partitions-2016-12-17.tar.gz
	afp-Card_Number_Partitions-2017-10-10.tar.gz
	afp-Card_Number_Partitions-2018-08-16.tar.gz
	+afp-Card_Number_Partitions-2019-06-11.tar.gz
	afp-Card_Partitions-2015-12-13.tar.gz
	afp-Card_Partitions-2016-02-22.tar.gz
	afp-Card_Partitions-2016-12-17.tar.gz
	afp-Card_Partitions-2017-10-10.tar.gz
	afp-Card_Partitions-2018-08-16.tar.gz
	+afp-Card_Partitions-2019-06-11.tar.gz
	afp-Cartan_FP-2016-03-09.tar.gz
	afp-Cartan_FP-2016-12-17.tar.gz
	afp-Cartan_FP-2017-10-10.tar.gz
	afp-Cartan_FP-2018-08-16.tar.gz
	+afp-Cartan_FP-2019-06-11.tar.gz
	afp-Case_Labeling-2015-07-24.tar.gz
	afp-Case_Labeling-2015-07-27.tar.gz
	afp-Case_Labeling-2015-08-17.tar.gz
	afp-Case_Labeling-2016-02-22.tar.gz
	afp-Case_Labeling-2016-12-17.tar.gz
	afp-Case_Labeling-2017-10-10.tar.gz
	afp-Case_Labeling-2018-08-16.tar.gz
	+afp-Case_Labeling-2019-06-11.tar.gz
	afp-Catalan_Numbers-2016-12-17.tar.gz
	afp-Catalan_Numbers-2017-10-10.tar.gz
	afp-Catalan_Numbers-2018-08-16.tar.gz
	+afp-Catalan_Numbers-2019-06-11.tar.gz
	afp-Category-2005-04-21.tar.gz
	afp-Category-2005-05-01.tar.gz
	afp-Category-2005-10-14.tar.gz
	afp-Category-2007-11-27.tar.gz
	afp-Category-2008-06-10.tar.gz
	afp-Category-2009-04-29.tar.gz
	afp-Category-2009-12-12.tar.gz
	afp-Category-2010-06-30.tar.gz
	afp-Category-2011-02-11.tar.gz
	afp-Category-2011-10-11.tar.gz
	afp-Category-2012-05-24.tar.gz
	afp-Category-2013-02-16.tar.gz
	afp-Category-2013-03-02.tar.gz
	afp-Category-2013-11-17.tar.gz
	afp-Category-2013-12-11.tar.gz
	afp-Category-2014-08-28.tar.gz
	afp-Category-2015-05-27.tar.gz
	afp-Category-2016-02-22.tar.gz
	afp-Category-2016-12-17.tar.gz
	afp-Category-2017-10-10.tar.gz
	afp-Category-2018-08-16.tar.gz
	+afp-Category-2019-06-11.tar.gz
	afp-Category2-2010-06-21.tar.gz
	afp-Category2-2010-06-30.tar.gz
	afp-Category2-2011-02-11.tar.gz
	afp-Category2-2011-10-11.tar.gz
	afp-Category2-2012-05-24.tar.gz
	afp-Category2-2013-02-16.tar.gz
	afp-Category2-2013-03-02.tar.gz
	afp-Category2-2013-11-17.tar.gz
	afp-Category2-2013-12-11.tar.gz
	afp-Category2-2014-08-28.tar.gz
	afp-Category2-2015-05-27.tar.gz
	afp-Category2-2016-02-22.tar.gz
	afp-Category2-2016-12-17.tar.gz
	afp-Category2-2017-10-10.tar.gz
	afp-Category2-2018-08-16.tar.gz
	+afp-Category2-2019-06-11.tar.gz
	afp-Category3-2016-06-26.tar.gz
	afp-Category3-2016-12-17.tar.gz
	afp-Category3-2017-10-10.tar.gz
	afp-Category3-2018-08-16.tar.gz
	+afp-Category3-2019-06-11.tar.gz
	afp-Cauchy-2006-03-14.tar.gz
	afp-Cauchy-2007-11-27.tar.gz
	afp-Cauchy-2008-06-10.tar.gz
	afp-Cauchy-2009-04-29.tar.gz
	afp-Cauchy-2009-12-12.tar.gz
	afp-Cauchy-2010-06-30.tar.gz
	afp-Cauchy-2011-02-11.tar.gz
	afp-Cauchy-2011-10-11.tar.gz
	afp-Cauchy-2012-05-24.tar.gz
	afp-Cauchy-2013-02-16.tar.gz
	afp-Cauchy-2013-11-17.tar.gz
	afp-Cauchy-2013-12-11.tar.gz
	afp-Cauchy-2014-08-28.tar.gz
	afp-Cauchy-2015-05-27.tar.gz
	afp-Cauchy-2016-02-22.tar.gz
	afp-Cauchy-2016-12-17.tar.gz
	afp-Cauchy-2017-10-10.tar.gz
	afp-Cauchy-2018-08-16.tar.gz
	+afp-Cauchy-2019-06-11.tar.gz
	afp-CAVA_Automata-2014-05-29.tar.gz
	afp-CAVA_Automata-2014-08-28.tar.gz
	afp-CAVA_Automata-2015-05-27.tar.gz
	afp-CAVA_Automata-2016-02-22.tar.gz
	afp-CAVA_Automata-2016-12-17.tar.gz
	afp-CAVA_Automata-2017-10-10.tar.gz
	afp-CAVA_Automata-2018-08-16.tar.gz
	+afp-CAVA_Automata-2019-06-11.tar.gz
	afp-CAVA_LTL_Modelchecker-2014-05-29.tar.gz
	afp-CAVA_LTL_Modelchecker-2014-05-30.tar.gz
	afp-CAVA_LTL_Modelchecker-2014-08-28.tar.gz
	afp-CAVA_LTL_Modelchecker-2015-05-27.tar.gz
	afp-CAVA_LTL_Modelchecker-2016-02-22.tar.gz
	afp-CAVA_LTL_Modelchecker-2016-12-17.tar.gz
	afp-CAVA_LTL_Modelchecker-2017-10-10.tar.gz
	afp-CAVA_LTL_Modelchecker-2018-08-16.tar.gz
	+afp-CAVA_LTL_Modelchecker-2019-06-11.tar.gz
	afp-Cayley_Hamilton-2014-09-16.tar.gz
	afp-Cayley_Hamilton-2015-05-27.tar.gz
	afp-Cayley_Hamilton-2016-02-22.tar.gz
	afp-Cayley_Hamilton-2016-12-17.tar.gz
	afp-Cayley_Hamilton-2017-10-10.tar.gz
	afp-Cayley_Hamilton-2018-08-16.tar.gz
	+afp-Cayley_Hamilton-2019-06-11.tar.gz
	afp-CCS-2012-06-14.tar.gz
	afp-CCS-2013-02-16.tar.gz
	afp-CCS-2013-11-17.tar.gz
	afp-CCS-2013-12-11.tar.gz
	afp-CCS-2014-08-28.tar.gz
	afp-CCS-2015-05-27.tar.gz
	afp-CCS-2016-02-22.tar.gz
	afp-CCS-2016-12-17.tar.gz
	afp-CCS-2017-10-10.tar.gz
	afp-CCS-2018-08-16.tar.gz
	+afp-CCS-2019-06-11.tar.gz
	afp-Certification_Monads-2014-10-08.tar.gz
	afp-Certification_Monads-2015-05-27.tar.gz
	afp-Certification_Monads-2016-02-22.tar.gz
	afp-Certification_Monads-2016-12-17.tar.gz
	afp-Certification_Monads-2017-10-10.tar.gz
	afp-Certification_Monads-2018-08-16.tar.gz
	+afp-Certification_Monads-2019-06-11.tar.gz
	afp-Chord_Segments-2016-10-11.tar.gz
	afp-Chord_Segments-2016-12-17.tar.gz
	afp-Chord_Segments-2017-10-10.tar.gz
	afp-Chord_Segments-2018-08-16.tar.gz
	+afp-Chord_Segments-2019-06-11.tar.gz
	afp-Circus-2012-05-29.tar.gz
	afp-Circus-2013-02-16.tar.gz
	afp-Circus-2013-11-17.tar.gz
	afp-Circus-2013-12-11.tar.gz
	afp-Circus-2014-08-28.tar.gz
	afp-Circus-2015-05-27.tar.gz
	afp-Circus-2016-02-22.tar.gz
	afp-Circus-2016-12-17.tar.gz
	afp-Circus-2017-10-10.tar.gz
	afp-Circus-2018-08-16.tar.gz
	+afp-Circus-2019-06-11.tar.gz
	afp-CISC-Kernel-2014-07-18.tar.gz
	afp-CISC-Kernel-2014-08-28.tar.gz
	afp-CISC-Kernel-2015-05-27.tar.gz
	afp-CISC-Kernel-2016-02-22.tar.gz
	afp-CISC-Kernel-2016-12-17.tar.gz
	afp-CISC-Kernel-2017-10-10.tar.gz
	afp-CISC-Kernel-2018-08-16.tar.gz
	+afp-CISC-Kernel-2019-06-11.tar.gz
	afp-ClockSynchInst-2006-03-15.tar.gz
	afp-ClockSynchInst-2007-11-27.tar.gz
	afp-ClockSynchInst-2008-06-10.tar.gz
	afp-ClockSynchInst-2009-04-29.tar.gz
	afp-ClockSynchInst-2009-12-12.tar.gz
	afp-ClockSynchInst-2010-06-30.tar.gz
	afp-ClockSynchInst-2011-02-11.tar.gz
	afp-ClockSynchInst-2011-10-11.tar.gz
	afp-ClockSynchInst-2012-05-24.tar.gz
	afp-ClockSynchInst-2013-02-16.tar.gz
	afp-ClockSynchInst-2013-03-02.tar.gz
	afp-ClockSynchInst-2013-11-17.tar.gz
	afp-ClockSynchInst-2013-12-11.tar.gz
	afp-ClockSynchInst-2014-08-28.tar.gz
	afp-ClockSynchInst-2015-05-27.tar.gz
	afp-ClockSynchInst-2016-02-22.tar.gz
	afp-ClockSynchInst-2016-12-17.tar.gz
	afp-ClockSynchInst-2017-10-10.tar.gz
	afp-ClockSynchInst-2018-08-16.tar.gz
	+afp-ClockSynchInst-2019-06-11.tar.gz
	afp-CofGroups-2009-08-09.tar.gz
	afp-CofGroups-2009-09-05.tar.gz
	afp-CofGroups-2009-12-12.tar.gz
	afp-CofGroups-2010-06-30.tar.gz
	afp-CofGroups-2011-02-11.tar.gz
	afp-CofGroups-2011-10-11.tar.gz
	afp-CofGroups-2012-05-24.tar.gz
	afp-CofGroups-2013-02-16.tar.gz
	afp-CofGroups-2013-03-02.tar.gz
	afp-CofGroups-2013-11-17.tar.gz
	afp-CofGroups-2013-12-11.tar.gz
	afp-CofGroups-2014-08-28.tar.gz
	afp-CofGroups-2015-05-27.tar.gz
	afp-CofGroups-2016-02-22.tar.gz
	afp-CofGroups-2016-12-17.tar.gz
	afp-CofGroups-2017-10-10.tar.gz
	afp-CofGroups-2018-08-16.tar.gz
	+afp-CofGroups-2019-06-11.tar.gz
	afp-Coinductive-2010-02-14.tar.gz
	afp-Coinductive-2010-02-15.tar.gz
	afp-Coinductive-2010-06-30.tar.gz
	afp-Coinductive-2011-02-11.tar.gz
	afp-Coinductive-2011-10-11.tar.gz
	afp-Coinductive-2012-05-24.tar.gz
	afp-Coinductive-2013-02-16.tar.gz
	afp-Coinductive-2013-03-02.tar.gz
	afp-Coinductive-2013-11-17.tar.gz
	afp-Coinductive-2013-12-11.tar.gz
	afp-Coinductive-2014-08-28.tar.gz
	afp-Coinductive-2015-05-27.tar.gz
	afp-Coinductive-2016-02-22.tar.gz
	afp-Coinductive-2016-12-17.tar.gz
	afp-Coinductive-2017-10-10.tar.gz
	afp-Coinductive-2018-08-16.tar.gz
	+afp-Coinductive-2019-06-11.tar.gz
	afp-Coinductive_Languages-2013-11-17.tar.gz
	afp-Coinductive_Languages-2013-12-11.tar.gz
	afp-Coinductive_Languages-2014-08-28.tar.gz
	afp-Coinductive_Languages-2015-05-27.tar.gz
	afp-Coinductive_Languages-2016-02-22.tar.gz
	afp-Coinductive_Languages-2016-12-17.tar.gz
	afp-Coinductive_Languages-2017-10-10.tar.gz
	afp-Coinductive_Languages-2018-08-16.tar.gz
	+afp-Coinductive_Languages-2019-06-11.tar.gz
	afp-Collections-2009-11-29.tar.gz
	afp-Collections-2009-12-12.tar.gz
	afp-Collections-2009-12-13.tar.gz
	afp-Collections-2010-06-30.tar.gz
	afp-Collections-2011-02-11.tar.gz
	afp-Collections-2011-10-11.tar.gz
	afp-Collections-2011-10-12.tar.gz
	afp-Collections-2012-05-24.tar.gz
	afp-Collections-2013-02-16.tar.gz
	afp-Collections-2013-03-02.tar.gz
	afp-Collections-2013-11-17.tar.gz
	afp-Collections-2013-12-11.tar.gz
	afp-Collections-2014-08-28.tar.gz
	afp-Collections-2015-05-27.tar.gz
	afp-Collections-2016-02-22.tar.gz
	afp-Collections-2016-12-17.tar.gz
	afp-Collections-2017-10-10.tar.gz
	afp-Collections-2018-08-16.tar.gz
	+afp-Collections-2019-06-11.tar.gz
	afp-Comparison_Sort_Lower_Bound-2017-03-16.tar.gz
	afp-Comparison_Sort_Lower_Bound-2017-10-10.tar.gz
	afp-Comparison_Sort_Lower_Bound-2018-08-16.tar.gz
	+afp-Comparison_Sort_Lower_Bound-2019-06-11.tar.gz
	afp-Compiling-Exceptions-Correctly-2004-07-09.tar.gz
	afp-Compiling-Exceptions-Correctly-2005-10-14.tar.gz
	afp-Compiling-Exceptions-Correctly-2007-11-27.tar.gz
	afp-Compiling-Exceptions-Correctly-2008-06-10.tar.gz
	afp-Compiling-Exceptions-Correctly-2009-04-29.tar.gz
	afp-Compiling-Exceptions-Correctly-2009-12-12.tar.gz
	afp-Compiling-Exceptions-Correctly-2010-06-30.tar.gz
	afp-Compiling-Exceptions-Correctly-2011-02-11.tar.gz
	afp-Compiling-Exceptions-Correctly-2011-10-11.tar.gz
	afp-Compiling-Exceptions-Correctly-2012-05-24.tar.gz
	afp-Compiling-Exceptions-Correctly-2013-02-16.tar.gz
	afp-Compiling-Exceptions-Correctly-2013-11-17.tar.gz
	afp-Compiling-Exceptions-Correctly-2013-12-11.tar.gz
	afp-Compiling-Exceptions-Correctly-2014-08-28.tar.gz
	afp-Compiling-Exceptions-Correctly-2015-05-27.tar.gz
	afp-Compiling-Exceptions-Correctly-2016-02-22.tar.gz
	afp-Compiling-Exceptions-Correctly-2016-12-17.tar.gz
	afp-Compiling-Exceptions-Correctly-2017-10-10.tar.gz
	afp-Compiling-Exceptions-Correctly-2018-08-16.tar.gz
	+afp-Compiling-Exceptions-Correctly-2019-06-11.tar.gz
	afp-Completeness-2004-09-20.tar.gz
	afp-Completeness-2004-09-21.tar.gz
	afp-Completeness-2005-07-22.tar.gz
	afp-Completeness-2005-10-14.tar.gz
	afp-Completeness-2007-11-27.tar.gz
	afp-Completeness-2008-06-10.tar.gz
	afp-Completeness-2009-04-29.tar.gz
	afp-Completeness-2009-12-12.tar.gz
	afp-Completeness-2010-06-30.tar.gz
	afp-Completeness-2011-02-11.tar.gz
	afp-Completeness-2011-10-11.tar.gz
	afp-Completeness-2012-05-24.tar.gz
	afp-Completeness-2013-02-16.tar.gz
	afp-Completeness-2013-03-02.tar.gz
	afp-Completeness-2013-11-17.tar.gz
	afp-Completeness-2013-12-11.tar.gz
	afp-Completeness-2014-08-28.tar.gz
	afp-Completeness-2015-05-27.tar.gz
	afp-Completeness-2016-02-22.tar.gz
	afp-Completeness-2016-12-17.tar.gz
	afp-Completeness-2017-10-10.tar.gz
	afp-Completeness-2018-08-16.tar.gz
	+afp-Completeness-2019-06-11.tar.gz
	afp-Complx-2016-11-29.tar.gz
	afp-Complx-2016-12-17.tar.gz
	afp-Complx-2017-10-10.tar.gz
	afp-Complx-2018-08-16.tar.gz
	+afp-Complx-2019-06-11.tar.gz
	afp-ComponentDependencies-2014-04-29.tar.gz
	afp-ComponentDependencies-2014-08-28.tar.gz
	afp-ComponentDependencies-2015-05-27.tar.gz
	afp-ComponentDependencies-2016-02-22.tar.gz
	afp-ComponentDependencies-2016-12-17.tar.gz
	afp-ComponentDependencies-2017-10-10.tar.gz
	afp-ComponentDependencies-2018-08-16.tar.gz
	+afp-ComponentDependencies-2019-06-11.tar.gz
	afp-ConcurrentGC-2015-04-15.tar.gz
	afp-ConcurrentGC-2015-05-27.tar.gz
	afp-ConcurrentGC-2016-02-22.tar.gz
	afp-ConcurrentGC-2016-12-17.tar.gz
	afp-ConcurrentGC-2017-10-10.tar.gz
	afp-ConcurrentGC-2018-08-16.tar.gz
	+afp-ConcurrentGC-2019-06-11.tar.gz
	afp-ConcurrentIMP-2015-04-15.tar.gz
	afp-ConcurrentIMP-2015-05-27.tar.gz
	afp-ConcurrentIMP-2016-02-22.tar.gz
	afp-ConcurrentIMP-2016-12-17.tar.gz
	afp-ConcurrentIMP-2017-10-10.tar.gz
	afp-ConcurrentIMP-2018-08-16.tar.gz
	+afp-ConcurrentIMP-2019-06-11.tar.gz
	afp-Concurrent_Ref_Alg-2017-01-04.tar.gz
	afp-Concurrent_Ref_Alg-2017-10-10.tar.gz
	afp-Concurrent_Ref_Alg-2018-08-16.tar.gz
	+afp-Concurrent_Ref_Alg-2019-06-11.tar.gz
	afp-Concurrent_Revisions-2019-01-03.tar.gz
	+afp-Concurrent_Revisions-2019-06-11.tar.gz
	afp-Consensus_Refined-2015-03-19.tar.gz
	afp-Consensus_Refined-2015-05-27.tar.gz
	afp-Consensus_Refined-2016-02-22.tar.gz
	afp-Consensus_Refined-2016-12-17.tar.gz
	afp-Consensus_Refined-2017-10-10.tar.gz
	afp-Consensus_Refined-2018-08-16.tar.gz
	+afp-Consensus_Refined-2019-06-11.tar.gz
	afp-Constructive_Cryptography-2018-12-19.tar.gz
	afp-Constructive_Cryptography-2018-12-20.tar.gz
	+afp-Constructive_Cryptography-2019-06-11.tar.gz
	afp-Constructor_Funs-2017-04-20.tar.gz
	afp-Constructor_Funs-2017-10-10.tar.gz
	afp-Constructor_Funs-2018-08-16.tar.gz
	+afp-Constructor_Funs-2019-06-11.tar.gz
	afp-Containers-2013-04-23.tar.gz
	afp-Containers-2013-11-17.tar.gz
	afp-Containers-2013-12-11.tar.gz
	afp-Containers-2014-08-28.tar.gz
	afp-Containers-2015-05-27.tar.gz
	afp-Containers-2016-02-22.tar.gz
	afp-Containers-2016-12-17.tar.gz
	afp-Containers-2017-10-10.tar.gz
	afp-Containers-2018-08-16.tar.gz
	+afp-Containers-2019-06-11.tar.gz
	afp-CoreC++-2006-05-16.tar.gz
	afp-CoreC++-2007-11-27.tar.gz
	afp-CoreC++-2008-06-10.tar.gz
	afp-CoreC++-2009-04-29.tar.gz
	afp-CoreC++-2009-12-12.tar.gz
	afp-CoreC++-2010-06-30.tar.gz
	afp-CoreC++-2011-02-11.tar.gz
	afp-CoreC++-2011-10-11.tar.gz
	afp-CoreC++-2012-05-24.tar.gz
	afp-CoreC++-2013-02-16.tar.gz
	afp-CoreC++-2013-03-02.tar.gz
	afp-CoreC++-2013-11-17.tar.gz
	afp-CoreC++-2013-12-11.tar.gz
	afp-CoreC++-2014-08-28.tar.gz
	afp-CoreC++-2015-05-27.tar.gz
	afp-CoreC++-2016-02-22.tar.gz
	afp-CoreC++-2016-12-17.tar.gz
	afp-CoreC++-2017-10-10.tar.gz
	afp-CoreC++-2018-08-16.tar.gz
	+afp-CoreC++-2019-06-11.tar.gz
	afp-Core_DOM-2019-01-07.tar.gz
	+afp-Core_DOM-2019-06-11.tar.gz
	afp-Count_Complex_Roots-2017-10-18.tar.gz
	afp-Count_Complex_Roots-2018-08-16.tar.gz
	+afp-Count_Complex_Roots-2019-06-11.tar.gz
	afp-CRDT-2017-07-07.tar.gz
	afp-CRDT-2017-10-10.tar.gz
	afp-CRDT-2018-08-16.tar.gz
	+afp-CRDT-2019-06-11.tar.gz
	afp-CryptHOL-2017-05-11.tar.gz
	afp-CryptHOL-2017-10-10.tar.gz
	afp-CryptHOL-2018-08-16.tar.gz
	+afp-CryptHOL-2019-06-11.tar.gz
	afp-CryptoBasedCompositionalProperties-2014-01-11.tar.gz
	afp-CryptoBasedCompositionalProperties-2014-01-14.tar.gz
	afp-CryptoBasedCompositionalProperties-2014-08-28.tar.gz
	afp-CryptoBasedCompositionalProperties-2015-05-27.tar.gz
	afp-CryptoBasedCompositionalProperties-2016-02-22.tar.gz
	afp-CryptoBasedCompositionalProperties-2016-12-17.tar.gz
	afp-CryptoBasedCompositionalProperties-2017-10-10.tar.gz
	afp-CryptoBasedCompositionalProperties-2018-08-16.tar.gz
	+afp-CryptoBasedCompositionalProperties-2019-06-11.tar.gz
	afp-CYK-2016-04-27.tar.gz
	afp-CYK-2016-12-17.tar.gz
	afp-CYK-2017-10-10.tar.gz
	afp-CYK-2018-08-16.tar.gz
	+afp-CYK-2019-06-11.tar.gz
	afp-DataRefinementIBP-2010-05-28.tar.gz
	afp-DataRefinementIBP-2010-06-30.tar.gz
	afp-DataRefinementIBP-2011-02-11.tar.gz
	afp-DataRefinementIBP-2011-10-11.tar.gz
	afp-DataRefinementIBP-2012-05-24.tar.gz
	afp-DataRefinementIBP-2013-02-16.tar.gz
	afp-DataRefinementIBP-2013-11-17.tar.gz
	afp-DataRefinementIBP-2013-12-11.tar.gz
	afp-DataRefinementIBP-2014-08-28.tar.gz
	afp-DataRefinementIBP-2015-05-27.tar.gz
	afp-DataRefinementIBP-2016-02-22.tar.gz
	afp-DataRefinementIBP-2016-12-17.tar.gz
	afp-DataRefinementIBP-2017-10-10.tar.gz
	afp-DataRefinementIBP-2018-08-16.tar.gz
	+afp-DataRefinementIBP-2019-06-11.tar.gz
	afp-Datatype_Order_Generator-2012-08-07.tar.gz
	afp-Datatype_Order_Generator-2013-02-16.tar.gz
	afp-Datatype_Order_Generator-2013-03-02.tar.gz
	afp-Datatype_Order_Generator-2013-11-17.tar.gz
	afp-Datatype_Order_Generator-2013-12-11.tar.gz
	afp-Datatype_Order_Generator-2014-08-28.tar.gz
	afp-Datatype_Order_Generator-2015-05-27.tar.gz
	afp-Datatype_Order_Generator-2016-02-22.tar.gz
	afp-Datatype_Order_Generator-2016-12-17.tar.gz
	afp-Datatype_Order_Generator-2017-10-10.tar.gz
	afp-Datatype_Order_Generator-2018-08-16.tar.gz
	+afp-Datatype_Order_Generator-2019-06-11.tar.gz
	afp-Decl_Sem_Fun_PL-2017-07-24.tar.gz
	afp-Decl_Sem_Fun_PL-2017-10-10.tar.gz
	afp-Decl_Sem_Fun_PL-2018-08-16.tar.gz
	+afp-Decl_Sem_Fun_PL-2019-06-11.tar.gz
	afp-Decreasing-Diagrams-2013-11-18.tar.gz
	afp-Decreasing-Diagrams-2013-12-02.tar.gz
	afp-Decreasing-Diagrams-2013-12-11.tar.gz
	afp-Decreasing-Diagrams-2014-08-28.tar.gz
	afp-Decreasing-Diagrams-2015-05-27.tar.gz
	afp-Decreasing-Diagrams-2016-02-22.tar.gz
	afp-Decreasing-Diagrams-2016-12-17.tar.gz
	afp-Decreasing-Diagrams-2017-10-10.tar.gz
	afp-Decreasing-Diagrams-2018-08-16.tar.gz
	+afp-Decreasing-Diagrams-2019-06-11.tar.gz
	afp-Decreasing-Diagrams-II-2015-08-21.tar.gz
	afp-Decreasing-Diagrams-II-2016-02-22.tar.gz
	afp-Decreasing-Diagrams-II-2016-12-17.tar.gz
	afp-Decreasing-Diagrams-II-2017-10-10.tar.gz
	afp-Decreasing-Diagrams-II-2018-08-16.tar.gz
	+afp-Decreasing-Diagrams-II-2019-06-11.tar.gz
	afp-Deep_Learning-2016-11-10.tar.gz
	afp-Deep_Learning-2016-12-17.tar.gz
	afp-Deep_Learning-2017-10-10.tar.gz
	afp-Deep_Learning-2018-08-16.tar.gz
	+afp-Deep_Learning-2019-06-11.tar.gz
	afp-Density_Compiler-2014-10-09.tar.gz
	afp-Density_Compiler-2014-12-22.tar.gz
	afp-Density_Compiler-2015-05-27.tar.gz
	afp-Density_Compiler-2016-02-22.tar.gz
	afp-Density_Compiler-2016-12-17.tar.gz
	afp-Density_Compiler-2017-10-10.tar.gz
	afp-Density_Compiler-2018-08-16.tar.gz
	+afp-Density_Compiler-2019-06-11.tar.gz
	afp-Dependent_SIFUM_Refinement-2016-06-28.tar.gz
	afp-Dependent_SIFUM_Refinement-2016-12-17.tar.gz
	afp-Dependent_SIFUM_Refinement-2017-10-10.tar.gz
	afp-Dependent_SIFUM_Refinement-2018-08-16.tar.gz
	+afp-Dependent_SIFUM_Refinement-2019-06-11.tar.gz
	afp-Dependent_SIFUM_Type_Systems-2016-06-25.tar.gz
	afp-Dependent_SIFUM_Type_Systems-2016-12-17.tar.gz
	afp-Dependent_SIFUM_Type_Systems-2017-10-10.tar.gz
	afp-Dependent_SIFUM_Type_Systems-2018-08-16.tar.gz
	+afp-Dependent_SIFUM_Type_Systems-2019-06-11.tar.gz
	afp-Depth-First-Search-2004-06-24.tar.gz
	afp-Depth-First-Search-2005-10-14.tar.gz
	afp-Depth-First-Search-2007-11-27.tar.gz
	afp-Depth-First-Search-2008-06-10.tar.gz
	afp-Depth-First-Search-2009-04-29.tar.gz
	afp-Depth-First-Search-2009-12-12.tar.gz
	afp-Depth-First-Search-2010-06-30.tar.gz
	afp-Depth-First-Search-2011-02-11.tar.gz
	afp-Depth-First-Search-2011-10-11.tar.gz
	afp-Depth-First-Search-2012-05-24.tar.gz
	afp-Depth-First-Search-2013-02-16.tar.gz
	afp-Depth-First-Search-2013-11-17.tar.gz
	afp-Depth-First-Search-2013-12-11.tar.gz
	afp-Depth-First-Search-2014-08-28.tar.gz
	afp-Depth-First-Search-2015-05-27.tar.gz
	afp-Depth-First-Search-2016-02-22.tar.gz
	afp-Depth-First-Search-2016-12-17.tar.gz
	afp-Depth-First-Search-2017-10-10.tar.gz
	afp-Depth-First-Search-2018-08-16.tar.gz
	+afp-Depth-First-Search-2019-06-11.tar.gz
	afp-Derangements-2015-06-28.tar.gz
	afp-Derangements-2015-11-20.tar.gz
	afp-Derangements-2016-02-22.tar.gz
	afp-Derangements-2016-12-17.tar.gz
	afp-Derangements-2017-10-10.tar.gz
	afp-Derangements-2018-08-16.tar.gz
	+afp-Derangements-2019-06-11.tar.gz
	afp-Deriving-2015-05-27.tar.gz
	afp-Deriving-2016-02-22.tar.gz
	afp-Deriving-2016-12-17.tar.gz
	afp-Deriving-2017-10-10.tar.gz
	afp-Deriving-2018-08-16.tar.gz
	+afp-Deriving-2019-06-11.tar.gz
	afp-Descartes_Sign_Rule-2016-01-05.tar.gz
	afp-Descartes_Sign_Rule-2016-02-22.tar.gz
	afp-Descartes_Sign_Rule-2016-12-17.tar.gz
	afp-Descartes_Sign_Rule-2017-10-10.tar.gz
	afp-Descartes_Sign_Rule-2018-08-16.tar.gz
	+afp-Descartes_Sign_Rule-2019-06-11.tar.gz
	afp-DFS_Framework-2016-07-05.tar.gz
	afp-DFS_Framework-2016-12-17.tar.gz
	afp-DFS_Framework-2017-10-10.tar.gz
	afp-DFS_Framework-2018-08-16.tar.gz
	+afp-DFS_Framework-2019-06-11.tar.gz
	afp-Dict_Construction-2017-10-10.tar.gz
	afp-Dict_Construction-2018-08-16.tar.gz
	+afp-Dict_Construction-2019-06-11.tar.gz
	afp-Differential_Dynamic_Logic-2017-02-14.tar.gz
	afp-Differential_Dynamic_Logic-2017-10-10.tar.gz
	afp-Differential_Dynamic_Logic-2018-08-16.tar.gz
	+afp-Differential_Dynamic_Logic-2019-06-11.tar.gz
	afp-Dijkstra_Shortest_Path-2012-02-10.tar.gz
	afp-Dijkstra_Shortest_Path-2012-03-15.tar.gz
	afp-Dijkstra_Shortest_Path-2012-05-24.tar.gz
	afp-Dijkstra_Shortest_Path-2013-02-16.tar.gz
	afp-Dijkstra_Shortest_Path-2013-03-08.tar.gz
	afp-Dijkstra_Shortest_Path-2013-11-17.tar.gz
	afp-Dijkstra_Shortest_Path-2013-12-11.tar.gz
	afp-Dijkstra_Shortest_Path-2014-08-28.tar.gz
	afp-Dijkstra_Shortest_Path-2015-05-27.tar.gz
	afp-Dijkstra_Shortest_Path-2016-02-22.tar.gz
	afp-Dijkstra_Shortest_Path-2016-12-17.tar.gz
	afp-Dijkstra_Shortest_Path-2017-10-10.tar.gz
	afp-Dijkstra_Shortest_Path-2018-08-16.tar.gz
	+afp-Dijkstra_Shortest_Path-2019-06-11.tar.gz
	afp-Diophantine_Eqns_Lin_Hom-2017-10-15.tar.gz
	afp-Diophantine_Eqns_Lin_Hom-2018-08-16.tar.gz
	+afp-Diophantine_Eqns_Lin_Hom-2019-06-11.tar.gz
	afp-Dirichlet_L-2018-08-16.tar.gz
	+afp-Dirichlet_L-2019-06-11.tar.gz
	afp-Dirichlet_Series-2017-10-16.tar.gz
	afp-Dirichlet_Series-2018-08-16.tar.gz
	+afp-Dirichlet_Series-2019-06-11.tar.gz
	afp-DiscretePricing-2018-07-18.tar.gz
	afp-DiscretePricing-2018-08-16.tar.gz
	+afp-DiscretePricing-2019-06-11.tar.gz
	afp-Discrete_Summation-2014-04-13.tar.gz
	afp-Discrete_Summation-2014-08-28.tar.gz
	afp-Discrete_Summation-2015-05-27.tar.gz
	afp-Discrete_Summation-2016-02-22.tar.gz
	afp-Discrete_Summation-2016-12-17.tar.gz
	afp-Discrete_Summation-2017-10-10.tar.gz
	afp-Discrete_Summation-2018-08-16.tar.gz
	+afp-Discrete_Summation-2019-06-11.tar.gz
	afp-DiskPaxos-2005-06-22.tar.gz
	afp-DiskPaxos-2005-10-14.tar.gz
	afp-DiskPaxos-2007-11-27.tar.gz
	afp-DiskPaxos-2008-06-10.tar.gz
	afp-DiskPaxos-2009-04-29.tar.gz
	afp-DiskPaxos-2009-12-12.tar.gz
	afp-DiskPaxos-2010-06-30.tar.gz
	afp-DiskPaxos-2011-02-11.tar.gz
	afp-DiskPaxos-2011-10-11.tar.gz
	afp-DiskPaxos-2012-05-24.tar.gz
	afp-DiskPaxos-2013-02-16.tar.gz
	afp-DiskPaxos-2013-11-17.tar.gz
	afp-DiskPaxos-2013-12-11.tar.gz
	afp-DiskPaxos-2014-08-28.tar.gz
	afp-DiskPaxos-2015-05-27.tar.gz
	afp-DiskPaxos-2016-02-22.tar.gz
	afp-DiskPaxos-2016-12-17.tar.gz
	afp-DiskPaxos-2017-10-10.tar.gz
	afp-DiskPaxos-2018-08-16.tar.gz
	+afp-DiskPaxos-2019-06-11.tar.gz
	afp-DPT-SAT-Solver-2009-12-12.tar.gz
	afp-DPT-SAT-Solver-2010-06-30.tar.gz
	afp-DPT-SAT-Solver-2011-02-11.tar.gz
	afp-DPT-SAT-Solver-2011-10-11.tar.gz
	afp-DPT-SAT-Solver-2012-05-24.tar.gz
	afp-DPT-SAT-Solver-2013-02-16.tar.gz
	afp-DPT-SAT-Solver-2013-11-17.tar.gz
	afp-DPT-SAT-Solver-2013-12-11.tar.gz
	afp-DPT-SAT-Solver-2014-08-28.tar.gz
	afp-DPT-SAT-Solver-2015-05-27.tar.gz
	afp-DPT-SAT-Solver-2015-07-27.tar.gz
	afp-DPT-SAT-Solver-2016-02-22.tar.gz
	afp-DPT-SAT-Solver-2016-12-17.tar.gz
	afp-DPT-SAT-Solver-2017-10-10.tar.gz
	afp-DPT-SAT-Solver-2018-08-16.tar.gz
	+afp-DPT-SAT-Solver-2019-06-11.tar.gz
	afp-DynamicArchitectures-2017-07-31.tar.gz
	afp-DynamicArchitectures-2017-10-10.tar.gz
	afp-DynamicArchitectures-2018-08-16.tar.gz
	+afp-DynamicArchitectures-2019-06-11.tar.gz
	afp-Dynamic_Tables-2015-06-07.tar.gz
	afp-Dynamic_Tables-2015-06-08.tar.gz
	afp-Dynamic_Tables-2016-02-22.tar.gz
	afp-Dynamic_Tables-2016-12-17.tar.gz
	afp-Dynamic_Tables-2017-10-10.tar.gz
	afp-Dynamic_Tables-2018-08-16.tar.gz
	+afp-Dynamic_Tables-2019-06-11.tar.gz
	afp-Echelon_Form-2015-02-12.tar.gz
	afp-Echelon_Form-2015-05-27.tar.gz
	afp-Echelon_Form-2016-02-22.tar.gz
	afp-Echelon_Form-2016-12-17.tar.gz
	afp-Echelon_Form-2017-10-10.tar.gz
	afp-Echelon_Form-2018-08-16.tar.gz
	+afp-Echelon_Form-2019-06-11.tar.gz
	afp-EdmondsKarp_Maxflow-2016-08-12.tar.gz
	afp-EdmondsKarp_Maxflow-2016-12-17.tar.gz
	afp-EdmondsKarp_Maxflow-2017-10-10.tar.gz
	afp-EdmondsKarp_Maxflow-2018-08-16.tar.gz
	+afp-EdmondsKarp_Maxflow-2019-06-11.tar.gz
	afp-Efficient-Mergesort-2011-11-10.tar.gz
	afp-Efficient-Mergesort-2012-05-24.tar.gz
	afp-Efficient-Mergesort-2013-02-16.tar.gz
	afp-Efficient-Mergesort-2013-03-02.tar.gz
	afp-Efficient-Mergesort-2013-11-17.tar.gz
	afp-Efficient-Mergesort-2013-12-11.tar.gz
	afp-Efficient-Mergesort-2014-08-28.tar.gz
	afp-Efficient-Mergesort-2015-05-27.tar.gz
	afp-Efficient-Mergesort-2016-02-22.tar.gz
	afp-Efficient-Mergesort-2016-12-17.tar.gz
	afp-Efficient-Mergesort-2017-10-10.tar.gz
	afp-Efficient-Mergesort-2018-08-16.tar.gz
	+afp-Efficient-Mergesort-2019-06-11.tar.gz
	afp-Elliptic_Curves_Group_Law-2017-03-01.tar.gz
	afp-Elliptic_Curves_Group_Law-2017-10-10.tar.gz
	afp-Elliptic_Curves_Group_Law-2018-08-16.tar.gz
	+afp-Elliptic_Curves_Group_Law-2019-06-11.tar.gz
	afp-Encodability_Process_Calculi-2015-08-11.tar.gz
	afp-Encodability_Process_Calculi-2016-02-22.tar.gz
	afp-Encodability_Process_Calculi-2016-12-17.tar.gz
	afp-Encodability_Process_Calculi-2017-10-10.tar.gz
	afp-Encodability_Process_Calculi-2018-08-16.tar.gz
	+afp-Encodability_Process_Calculi-2019-06-11.tar.gz
	afp-Epistemic_Logic-2018-10-29.tar.gz
	+afp-Epistemic_Logic-2019-06-11.tar.gz
	afp-Ergodic_Theory-2016-02-22.tar.gz
	afp-Ergodic_Theory-2016-12-17.tar.gz
	afp-Ergodic_Theory-2017-10-10.tar.gz
	afp-Ergodic_Theory-2018-08-16.tar.gz
	+afp-Ergodic_Theory-2019-06-11.tar.gz
	afp-Error_Function-2018-02-07.tar.gz
	afp-Error_Function-2018-08-16.tar.gz
	+afp-Error_Function-2019-06-11.tar.gz
	afp-E_Transcendental-2017-01-13.tar.gz
	afp-E_Transcendental-2017-10-10.tar.gz
	afp-E_Transcendental-2018-08-16.tar.gz
	+afp-E_Transcendental-2019-06-11.tar.gz
	afp-Euler_MacLaurin-2017-03-14.tar.gz
	afp-Euler_MacLaurin-2017-10-10.tar.gz
	afp-Euler_MacLaurin-2018-08-16.tar.gz
	+afp-Euler_MacLaurin-2019-06-11.tar.gz
	afp-Euler_Partition-2015-11-20.tar.gz
	afp-Euler_Partition-2016-02-22.tar.gz
	afp-Euler_Partition-2016-12-17.tar.gz
	afp-Euler_Partition-2017-10-10.tar.gz
	afp-Euler_Partition-2018-08-16.tar.gz
	+afp-Euler_Partition-2019-06-11.tar.gz
	afp-Factored_Transition_System_Bounding-2018-10-16.tar.gz
	+afp-Factored_Transition_System_Bounding-2019-06-11.tar.gz
	afp-Falling_Factorial_Sum-2017-12-30.tar.gz
	afp-Falling_Factorial_Sum-2018-08-16.tar.gz
	+afp-Falling_Factorial_Sum-2019-06-11.tar.gz
	afp-Farkas-2019-01-21.tar.gz
	+afp-Farkas-2019-06-11.tar.gz
	afp-FeatherweightJava-2006-04-05.tar.gz
	afp-FeatherweightJava-2006-04-06.tar.gz
	afp-FeatherweightJava-2007-11-27.tar.gz
	afp-FeatherweightJava-2008-06-10.tar.gz
	afp-FeatherweightJava-2009-04-29.tar.gz
	afp-FeatherweightJava-2009-12-12.tar.gz
	afp-FeatherweightJava-2010-06-30.tar.gz
	afp-FeatherweightJava-2011-02-11.tar.gz
	afp-FeatherweightJava-2011-10-11.tar.gz
	afp-FeatherweightJava-2012-05-24.tar.gz
	afp-FeatherweightJava-2013-02-16.tar.gz
	afp-FeatherweightJava-2013-11-17.tar.gz
	afp-FeatherweightJava-2013-12-11.tar.gz
	afp-FeatherweightJava-2014-08-28.tar.gz
	afp-FeatherweightJava-2015-05-27.tar.gz
	afp-FeatherweightJava-2016-02-22.tar.gz
	afp-FeatherweightJava-2016-12-17.tar.gz
	afp-FeatherweightJava-2017-10-10.tar.gz
	afp-FeatherweightJava-2018-08-16.tar.gz
	+afp-FeatherweightJava-2019-06-11.tar.gz
	afp-Featherweight_OCL-2014-01-16.tar.gz
	afp-Featherweight_OCL-2014-08-28.tar.gz
	afp-Featherweight_OCL-2015-05-27.tar.gz
	afp-Featherweight_OCL-2016-02-22.tar.gz
	afp-Featherweight_OCL-2016-12-17.tar.gz
	afp-Featherweight_OCL-2017-10-10.tar.gz
	afp-Featherweight_OCL-2018-08-16.tar.gz
	+afp-Featherweight_OCL-2019-06-11.tar.gz
	afp-Fermat3_4-2007-11-27.tar.gz
	afp-Fermat3_4-2008-06-10.tar.gz
	afp-Fermat3_4-2009-04-29.tar.gz
	afp-Fermat3_4-2009-12-12.tar.gz
	afp-Fermat3_4-2010-06-30.tar.gz
	afp-Fermat3_4-2011-02-11.tar.gz
	afp-Fermat3_4-2011-10-11.tar.gz
	afp-Fermat3_4-2012-05-24.tar.gz
	afp-Fermat3_4-2013-02-16.tar.gz
	afp-Fermat3_4-2013-11-17.tar.gz
	afp-Fermat3_4-2013-12-11.tar.gz
	afp-Fermat3_4-2014-08-28.tar.gz
	afp-Fermat3_4-2015-05-27.tar.gz
	afp-Fermat3_4-2016-02-22.tar.gz
	afp-Fermat3_4-2016-12-17.tar.gz
	afp-Fermat3_4-2017-10-10.tar.gz
	afp-Fermat3_4-2018-08-16.tar.gz
	+afp-Fermat3_4-2019-06-11.tar.gz
	afp-FFT-2005-10-14.tar.gz
	afp-FFT-2007-11-27.tar.gz
	afp-FFT-2008-06-10.tar.gz
	afp-FFT-2009-04-29.tar.gz
	afp-FFT-2009-12-12.tar.gz
	afp-FFT-2010-06-30.tar.gz
	afp-FFT-2011-02-11.tar.gz
	afp-FFT-2011-10-11.tar.gz
	afp-FFT-2012-05-24.tar.gz
	afp-FFT-2013-02-16.tar.gz
	afp-FFT-2013-11-17.tar.gz
	afp-FFT-2013-12-11.tar.gz
	afp-FFT-2014-08-28.tar.gz
	afp-FFT-2015-05-27.tar.gz
	afp-FFT-2016-02-22.tar.gz
	afp-FFT-2016-12-17.tar.gz
	afp-FFT-2017-10-10.tar.gz
	afp-FFT-2018-08-16.tar.gz
	+afp-FFT-2019-06-11.tar.gz
	afp-FileRefinement-2004-12-15.tar.gz
	afp-FileRefinement-2005-10-14.tar.gz
	afp-FileRefinement-2007-11-27.tar.gz
	afp-FileRefinement-2008-06-10.tar.gz
	afp-FileRefinement-2009-04-29.tar.gz
	afp-FileRefinement-2009-12-12.tar.gz
	afp-FileRefinement-2010-06-30.tar.gz
	afp-FileRefinement-2011-02-11.tar.gz
	afp-FileRefinement-2011-10-11.tar.gz
	afp-FileRefinement-2012-05-24.tar.gz
	afp-FileRefinement-2013-02-16.tar.gz
	afp-FileRefinement-2013-11-17.tar.gz
	afp-FileRefinement-2013-12-11.tar.gz
	afp-FileRefinement-2014-08-28.tar.gz
	afp-FileRefinement-2015-05-27.tar.gz
	afp-FileRefinement-2016-02-22.tar.gz
	afp-FileRefinement-2016-12-17.tar.gz
	afp-FileRefinement-2017-10-10.tar.gz
	afp-FileRefinement-2018-08-16.tar.gz
	+afp-FileRefinement-2019-06-11.tar.gz
	afp-FinFun-2009-05-25.tar.gz
	afp-FinFun-2009-12-12.tar.gz
	afp-FinFun-2010-06-30.tar.gz
	afp-FinFun-2011-02-11.tar.gz
	afp-FinFun-2011-10-11.tar.gz
	afp-FinFun-2012-05-24.tar.gz
	afp-FinFun-2013-02-16.tar.gz
	afp-FinFun-2013-03-02.tar.gz
	afp-FinFun-2013-11-17.tar.gz
	afp-FinFun-2013-12-11.tar.gz
	afp-FinFun-2014-08-28.tar.gz
	afp-FinFun-2015-05-27.tar.gz
	afp-FinFun-2016-02-22.tar.gz
	afp-FinFun-2016-12-17.tar.gz
	afp-FinFun-2017-10-10.tar.gz
	afp-FinFun-2018-08-16.tar.gz
	+afp-FinFun-2019-06-11.tar.gz
	afp-Finger-Trees-2010-10-28.tar.gz
	afp-Finger-Trees-2011-02-11.tar.gz
	afp-Finger-Trees-2011-10-11.tar.gz
	afp-Finger-Trees-2012-05-24.tar.gz
	afp-Finger-Trees-2013-02-16.tar.gz
	afp-Finger-Trees-2013-03-02.tar.gz
	afp-Finger-Trees-2013-11-17.tar.gz
	afp-Finger-Trees-2013-12-11.tar.gz
	afp-Finger-Trees-2014-08-28.tar.gz
	afp-Finger-Trees-2015-05-27.tar.gz
	afp-Finger-Trees-2016-02-22.tar.gz
	afp-Finger-Trees-2016-12-17.tar.gz
	afp-Finger-Trees-2017-10-10.tar.gz
	afp-Finger-Trees-2018-08-16.tar.gz
	+afp-Finger-Trees-2019-06-11.tar.gz
	afp-Finite_Automata_HF-2015-02-05.tar.gz
	afp-Finite_Automata_HF-2015-05-27.tar.gz
	afp-Finite_Automata_HF-2016-02-22.tar.gz
	afp-Finite_Automata_HF-2016-12-17.tar.gz
	afp-Finite_Automata_HF-2017-10-10.tar.gz
	afp-Finite_Automata_HF-2018-08-16.tar.gz
	+afp-Finite_Automata_HF-2019-06-11.tar.gz
	afp-First_Order_Terms-2018-02-06.tar.gz
	afp-First_Order_Terms-2018-02-07.tar.gz
	afp-First_Order_Terms-2018-08-16.tar.gz
	+afp-First_Order_Terms-2019-06-11.tar.gz
	afp-First_Welfare_Theorem-2017-09-04.tar.gz
	afp-First_Welfare_Theorem-2017-09-05.tar.gz
	afp-First_Welfare_Theorem-2017-10-10.tar.gz
	afp-First_Welfare_Theorem-2018-08-16.tar.gz
	+afp-First_Welfare_Theorem-2019-06-11.tar.gz
	afp-Fishburn_Impossibility-2018-03-23.tar.gz
	afp-Fishburn_Impossibility-2018-06-10.tar.gz
	afp-Fishburn_Impossibility-2018-08-16.tar.gz
	+afp-Fishburn_Impossibility-2019-06-11.tar.gz
	afp-Fisher_Yates-2016-12-17.tar.gz
	afp-Fisher_Yates-2017-10-10.tar.gz
	afp-Fisher_Yates-2018-08-16.tar.gz
	+afp-Fisher_Yates-2019-06-11.tar.gz
	afp-Flow_Networks-2017-06-02.tar.gz
	afp-Flow_Networks-2017-10-10.tar.gz
	afp-Flow_Networks-2018-08-16.tar.gz
	+afp-Flow_Networks-2019-06-11.tar.gz
	afp-Floyd_Warshall-2017-05-09.tar.gz
	afp-Floyd_Warshall-2017-10-10.tar.gz
	afp-Floyd_Warshall-2018-08-16.tar.gz
	+afp-Floyd_Warshall-2019-06-11.tar.gz
	afp-FLP-2016-05-18.tar.gz
	afp-FLP-2016-12-17.tar.gz
	afp-FLP-2017-10-10.tar.gz
	afp-FLP-2018-08-16.tar.gz
	+afp-FLP-2019-06-11.tar.gz
	afp-Flyspeck-Tame-2007-11-27.tar.gz
	afp-Flyspeck-Tame-2008-01-04.tar.gz
	afp-Flyspeck-Tame-2008-06-10.tar.gz
	afp-Flyspeck-Tame-2009-04-29.tar.gz
	afp-Flyspeck-Tame-2009-12-12.tar.gz
	afp-Flyspeck-Tame-2010-06-30.tar.gz
	afp-Flyspeck-Tame-2011-02-11.tar.gz
	afp-Flyspeck-Tame-2011-10-11.tar.gz
	afp-Flyspeck-Tame-2012-05-25.tar.gz
	afp-Flyspeck-Tame-2013-02-16.tar.gz
	afp-Flyspeck-Tame-2013-03-02.tar.gz
	afp-Flyspeck-Tame-2013-11-17.tar.gz
	afp-Flyspeck-Tame-2013-12-11.tar.gz
	afp-Flyspeck-Tame-2014-08-28.tar.gz
	afp-Flyspeck-Tame-2015-05-27.tar.gz
	afp-Flyspeck-Tame-2016-02-22.tar.gz
	afp-Flyspeck-Tame-2016-12-17.tar.gz
	afp-Flyspeck-Tame-2017-10-10.tar.gz
	afp-Flyspeck-Tame-2018-08-17.tar.gz
	+afp-Flyspeck-Tame-2019-06-11.tar.gz
	afp-FocusStreamsCaseStudies-2013-11-18.tar.gz
	afp-FocusStreamsCaseStudies-2013-12-11.tar.gz
	afp-FocusStreamsCaseStudies-2014-08-28.tar.gz
	afp-FocusStreamsCaseStudies-2015-05-27.tar.gz
	afp-FocusStreamsCaseStudies-2016-02-22.tar.gz
	afp-FocusStreamsCaseStudies-2016-12-17.tar.gz
	afp-FocusStreamsCaseStudies-2017-10-10.tar.gz
	afp-FocusStreamsCaseStudies-2018-08-16.tar.gz
	+afp-FocusStreamsCaseStudies-2019-06-11.tar.gz
	afp-FOL-Fitting-2007-11-27.tar.gz
	afp-FOL-Fitting-2008-06-10.tar.gz
	afp-FOL-Fitting-2009-04-29.tar.gz
	afp-FOL-Fitting-2009-12-12.tar.gz
	afp-FOL-Fitting-2010-06-30.tar.gz
	afp-FOL-Fitting-2011-02-11.tar.gz
	afp-FOL-Fitting-2011-10-11.tar.gz
	afp-FOL-Fitting-2012-05-24.tar.gz
	afp-FOL-Fitting-2013-02-16.tar.gz
	afp-FOL-Fitting-2013-03-02.tar.gz
	afp-FOL-Fitting-2013-11-17.tar.gz
	afp-FOL-Fitting-2013-12-11.tar.gz
	afp-FOL-Fitting-2014-08-28.tar.gz
	afp-FOL-Fitting-2015-05-27.tar.gz
	afp-FOL-Fitting-2016-02-22.tar.gz
	afp-FOL-Fitting-2016-12-17.tar.gz
	afp-FOL-Fitting-2017-10-10.tar.gz
	afp-FOL-Fitting-2018-08-16.tar.gz
	+afp-FOL-Fitting-2019-06-11.tar.gz
	afp-FOL_Harrison-2017-01-04.tar.gz
	afp-FOL_Harrison-2017-10-10.tar.gz
	afp-FOL_Harrison-2018-08-16.tar.gz
	+afp-FOL_Harrison-2019-06-11.tar.gz
	afp-Formal_SSA-2016-02-08.tar.gz
	afp-Formal_SSA-2016-02-22.tar.gz
	afp-Formal_SSA-2016-12-17.tar.gz
	afp-Formal_SSA-2017-10-10.tar.gz
	afp-Formal_SSA-2018-08-16.tar.gz
	+afp-Formal_SSA-2019-06-11.tar.gz
	afp-Formula_Derivatives-2015-05-28.tar.gz
	afp-Formula_Derivatives-2016-02-22.tar.gz
	afp-Formula_Derivatives-2016-12-17.tar.gz
	afp-Formula_Derivatives-2017-10-10.tar.gz
	afp-Formula_Derivatives-2018-08-16.tar.gz
	+afp-Formula_Derivatives-2019-06-11.tar.gz
	afp-Free-Boolean-Algebra-2010-03-29.tar.gz
	afp-Free-Boolean-Algebra-2010-06-30.tar.gz
	afp-Free-Boolean-Algebra-2011-02-11.tar.gz
	afp-Free-Boolean-Algebra-2011-10-11.tar.gz
	afp-Free-Boolean-Algebra-2012-05-24.tar.gz
	afp-Free-Boolean-Algebra-2013-02-16.tar.gz
	afp-Free-Boolean-Algebra-2013-03-02.tar.gz
	afp-Free-Boolean-Algebra-2013-11-17.tar.gz
	afp-Free-Boolean-Algebra-2013-12-11.tar.gz
	afp-Free-Boolean-Algebra-2014-08-28.tar.gz
	afp-Free-Boolean-Algebra-2015-05-27.tar.gz
	afp-Free-Boolean-Algebra-2016-02-22.tar.gz
	afp-Free-Boolean-Algebra-2016-12-17.tar.gz
	afp-Free-Boolean-Algebra-2017-10-10.tar.gz
	afp-Free-Boolean-Algebra-2018-08-16.tar.gz
	+afp-Free-Boolean-Algebra-2019-06-11.tar.gz
	afp-Free-Groups-2010-07-01.tar.gz
	afp-Free-Groups-2011-02-11.tar.gz
	afp-Free-Groups-2011-10-11.tar.gz
	afp-Free-Groups-2012-05-24.tar.gz
	afp-Free-Groups-2013-02-16.tar.gz
	afp-Free-Groups-2013-11-17.tar.gz
	afp-Free-Groups-2013-12-11.tar.gz
	afp-Free-Groups-2014-08-28.tar.gz
	afp-Free-Groups-2015-05-27.tar.gz
	afp-Free-Groups-2016-02-22.tar.gz
	afp-Free-Groups-2016-12-17.tar.gz
	afp-Free-Groups-2017-10-10.tar.gz
	afp-Free-Groups-2018-08-16.tar.gz
	+afp-Free-Groups-2019-06-11.tar.gz
	afp-Functional-Automata-2004-03-30.tar.gz
	afp-Functional-Automata-2004-04-20.tar.gz
	afp-Functional-Automata-2004-05-21.tar.gz
	afp-Functional-Automata-2005-10-14.tar.gz
	afp-Functional-Automata-2007-11-27.tar.gz
	afp-Functional-Automata-2008-06-10.tar.gz
	afp-Functional-Automata-2009-04-29.tar.gz
	afp-Functional-Automata-2009-12-12.tar.gz
	afp-Functional-Automata-2010-07-01.tar.gz
	afp-Functional-Automata-2011-02-11.tar.gz
	afp-Functional-Automata-2011-10-11.tar.gz
	afp-Functional-Automata-2012-05-24.tar.gz
	afp-Functional-Automata-2013-02-16.tar.gz
	afp-Functional-Automata-2013-03-02.tar.gz
	afp-Functional-Automata-2013-11-17.tar.gz
	afp-Functional-Automata-2013-12-11.tar.gz
	afp-Functional-Automata-2014-08-28.tar.gz
	afp-Functional-Automata-2015-05-27.tar.gz
	afp-Functional-Automata-2016-02-22.tar.gz
	afp-Functional-Automata-2016-12-17.tar.gz
	afp-Functional-Automata-2017-10-10.tar.gz
	afp-Functional-Automata-2018-08-16.tar.gz
	+afp-Functional-Automata-2019-06-11.tar.gz
	afp-Functional_Ordered_Resolution_Prover-2018-11-29.tar.gz
	+afp-Functional_Ordered_Resolution_Prover-2019-06-11.tar.gz
	afp-FunWithFunctions-2009-04-29.tar.gz
	afp-FunWithFunctions-2009-12-12.tar.gz
	afp-FunWithFunctions-2010-07-01.tar.gz
	afp-FunWithFunctions-2011-02-11.tar.gz
	afp-FunWithFunctions-2011-10-11.tar.gz
	afp-FunWithFunctions-2012-05-24.tar.gz
	afp-FunWithFunctions-2013-02-16.tar.gz
	afp-FunWithFunctions-2013-11-17.tar.gz
	afp-FunWithFunctions-2013-12-11.tar.gz
	afp-FunWithFunctions-2014-08-28.tar.gz
	afp-FunWithFunctions-2015-05-27.tar.gz
	afp-FunWithFunctions-2016-02-22.tar.gz
	afp-FunWithFunctions-2016-12-17.tar.gz
	afp-FunWithFunctions-2017-10-10.tar.gz
	afp-FunWithFunctions-2018-08-16.tar.gz
	+afp-FunWithFunctions-2019-06-11.tar.gz
	afp-FunWithTilings-2009-04-29.tar.gz
	afp-FunWithTilings-2009-12-12.tar.gz
	afp-FunWithTilings-2010-07-01.tar.gz
	afp-FunWithTilings-2011-02-11.tar.gz
	afp-FunWithTilings-2011-10-11.tar.gz
	afp-FunWithTilings-2012-05-24.tar.gz
	afp-FunWithTilings-2013-02-16.tar.gz
	afp-FunWithTilings-2013-11-17.tar.gz
	afp-FunWithTilings-2013-12-11.tar.gz
	afp-FunWithTilings-2014-08-28.tar.gz
	afp-FunWithTilings-2015-05-27.tar.gz
	afp-FunWithTilings-2016-02-22.tar.gz
	afp-FunWithTilings-2016-12-17.tar.gz
	afp-FunWithTilings-2017-10-10.tar.gz
	afp-FunWithTilings-2018-08-16.tar.gz
	+afp-FunWithTilings-2019-06-11.tar.gz
	afp-Gabow_SCC-2014-05-29.tar.gz
	afp-Gabow_SCC-2014-08-28.tar.gz
	afp-Gabow_SCC-2015-05-27.tar.gz
	afp-Gabow_SCC-2016-02-22.tar.gz
	afp-Gabow_SCC-2016-12-17.tar.gz
	afp-Gabow_SCC-2017-10-10.tar.gz
	afp-Gabow_SCC-2018-08-16.tar.gz
	+afp-Gabow_SCC-2019-06-11.tar.gz
	afp-Game_Based_Crypto-2017-05-11.tar.gz
	afp-Game_Based_Crypto-2017-10-10.tar.gz
	afp-Game_Based_Crypto-2018-08-16.tar.gz
	+afp-Game_Based_Crypto-2019-06-11.tar.gz
	afp-Gauss_Jordan-2014-09-03.tar.gz
	afp-Gauss_Jordan-2015-05-27.tar.gz
	afp-Gauss_Jordan-2016-02-22.tar.gz
	afp-Gauss_Jordan-2016-12-17.tar.gz
	afp-Gauss_Jordan-2017-10-10.tar.gz
	afp-Gauss_Jordan-2018-08-16.tar.gz
	+afp-Gauss_Jordan-2019-06-11.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2011-08-19.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2011-10-11.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2012-05-24.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2013-02-16.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2013-11-17.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2013-12-11.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2014-08-28.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2015-05-27.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2016-02-22.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2016-12-17.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2017-10-10.tar.gz
	afp-Gauss-Jordan-Elim-Fun-2018-08-16.tar.gz
	+afp-Gauss-Jordan-Elim-Fun-2019-06-11.tar.gz
	afp-GenClock-2005-06-24.tar.gz
	afp-GenClock-2005-10-14.tar.gz
	afp-GenClock-2007-11-27.tar.gz
	afp-GenClock-2008-06-10.tar.gz
	afp-GenClock-2009-04-29.tar.gz
	afp-GenClock-2009-12-12.tar.gz
	afp-GenClock-2010-07-01.tar.gz
	afp-GenClock-2011-02-11.tar.gz
	afp-GenClock-2011-10-11.tar.gz
	afp-GenClock-2012-05-24.tar.gz
	afp-GenClock-2013-02-16.tar.gz
	afp-GenClock-2013-11-17.tar.gz
	afp-GenClock-2013-12-11.tar.gz
	afp-GenClock-2014-08-28.tar.gz
	afp-GenClock-2015-05-27.tar.gz
	afp-GenClock-2016-02-22.tar.gz
	afp-GenClock-2016-12-17.tar.gz
	afp-GenClock-2017-10-10.tar.gz
	afp-GenClock-2018-08-16.tar.gz
	+afp-GenClock-2019-06-11.tar.gz
	afp-General-Triangle-2011-04-01.tar.gz
	afp-General-Triangle-2011-10-11.tar.gz
	afp-General-Triangle-2012-05-24.tar.gz
	afp-General-Triangle-2013-02-16.tar.gz
	afp-General-Triangle-2013-11-17.tar.gz
	afp-General-Triangle-2013-12-11.tar.gz
	afp-General-Triangle-2014-08-28.tar.gz
	afp-General-Triangle-2015-05-27.tar.gz
	afp-General-Triangle-2016-02-22.tar.gz
	afp-General-Triangle-2016-12-17.tar.gz
	afp-General-Triangle-2017-10-10.tar.gz
	afp-General-Triangle-2018-08-16.tar.gz
	+afp-General-Triangle-2019-06-11.tar.gz
	afp-Generic_Deriving-2018-11-21.tar.gz
	+afp-Generic_Deriving-2019-06-11.tar.gz
	afp-GewirthPGCProof-2018-10-31.tar.gz
	+afp-GewirthPGCProof-2019-06-11.tar.gz
	afp-Girth_Chromatic-2012-02-06.tar.gz
	afp-Girth_Chromatic-2012-05-24.tar.gz
	afp-Girth_Chromatic-2013-02-16.tar.gz
	afp-Girth_Chromatic-2013-11-17.tar.gz
	afp-Girth_Chromatic-2013-12-11.tar.gz
	afp-Girth_Chromatic-2014-08-28.tar.gz
	afp-Girth_Chromatic-2015-05-27.tar.gz
	afp-Girth_Chromatic-2016-02-22.tar.gz
	afp-Girth_Chromatic-2016-12-17.tar.gz
	afp-Girth_Chromatic-2017-10-10.tar.gz
	afp-Girth_Chromatic-2018-08-16.tar.gz
	+afp-Girth_Chromatic-2019-06-11.tar.gz
	afp-GoedelGod-2013-11-18.tar.gz
	afp-GoedelGod-2013-11-19.tar.gz
	afp-GoedelGod-2013-12-11.tar.gz
	afp-GoedelGod-2014-08-28.tar.gz
	afp-GoedelGod-2015-05-27.tar.gz
	afp-GoedelGod-2016-02-22.tar.gz
	afp-GoedelGod-2016-12-17.tar.gz
	afp-GoedelGod-2017-10-10.tar.gz
	afp-GoedelGod-2018-08-16.tar.gz
	+afp-GoedelGod-2019-06-11.tar.gz
	afp-GPU_Kernel_PL-2014-04-06.tar.gz
	afp-GPU_Kernel_PL-2014-08-28.tar.gz
	afp-GPU_Kernel_PL-2015-05-27.tar.gz
	afp-GPU_Kernel_PL-2016-02-22.tar.gz
	afp-GPU_Kernel_PL-2016-12-17.tar.gz
	afp-GPU_Kernel_PL-2017-10-10.tar.gz
	afp-GPU_Kernel_PL-2018-08-16.tar.gz
	+afp-GPU_Kernel_PL-2019-06-11.tar.gz
	afp-GraphMarkingIBP-2010-05-28.tar.gz
	afp-GraphMarkingIBP-2010-07-01.tar.gz
	afp-GraphMarkingIBP-2011-02-11.tar.gz
	afp-GraphMarkingIBP-2011-10-11.tar.gz
	afp-GraphMarkingIBP-2012-03-15.tar.gz
	afp-GraphMarkingIBP-2012-05-24.tar.gz
	afp-GraphMarkingIBP-2013-02-16.tar.gz
	afp-GraphMarkingIBP-2013-11-17.tar.gz
	afp-GraphMarkingIBP-2013-12-11.tar.gz
	afp-GraphMarkingIBP-2014-08-28.tar.gz
	afp-GraphMarkingIBP-2015-05-27.tar.gz
	afp-GraphMarkingIBP-2016-02-22.tar.gz
	afp-GraphMarkingIBP-2016-12-17.tar.gz
	afp-GraphMarkingIBP-2017-10-10.tar.gz
	afp-GraphMarkingIBP-2018-08-16.tar.gz
	+afp-GraphMarkingIBP-2019-06-11.tar.gz
	afp-Graph_Saturation-2018-11-28.tar.gz
	+afp-Graph_Saturation-2019-06-11.tar.gz
	afp-Graph_Theory-2013-05-02.tar.gz
	afp-Graph_Theory-2013-11-17.tar.gz
	afp-Graph_Theory-2013-12-11.tar.gz
	afp-Graph_Theory-2014-08-28.tar.gz
	afp-Graph_Theory-2015-05-27.tar.gz
	afp-Graph_Theory-2016-02-22.tar.gz
	afp-Graph_Theory-2016-12-17.tar.gz
	afp-Graph_Theory-2017-10-10.tar.gz
	afp-Graph_Theory-2018-08-16.tar.gz
	+afp-Graph_Theory-2019-06-11.tar.gz
	afp-Green-2018-01-12.tar.gz
	afp-Green-2018-08-16.tar.gz
	+afp-Green-2019-06-11.tar.gz
	afp-Groebner_Bases-2016-05-02.tar.gz
	afp-Groebner_Bases-2016-12-17.tar.gz
	afp-Groebner_Bases-2017-10-10.tar.gz
	afp-Groebner_Bases-2018-08-16.tar.gz
	+afp-Groebner_Bases-2019-06-11.tar.gz
	afp-Gromov_Hyperbolicity-2018-08-16.tar.gz
	+afp-Gromov_Hyperbolicity-2019-06-11.tar.gz
	afp-Group-Ring-Module-2004-05-19.tar.gz
	afp-Group-Ring-Module-2004-05-20.tar.gz
	afp-Group-Ring-Module-2005-10-14.tar.gz
	afp-Group-Ring-Module-2007-11-27.tar.gz
	afp-Group-Ring-Module-2008-06-10.tar.gz
	afp-Group-Ring-Module-2009-04-29.tar.gz
	afp-Group-Ring-Module-2009-04-30.tar.gz
	afp-Group-Ring-Module-2009-12-12.tar.gz
	afp-Group-Ring-Module-2010-07-01.tar.gz
	afp-Group-Ring-Module-2011-02-11.tar.gz
	afp-Group-Ring-Module-2011-10-11.tar.gz
	afp-Group-Ring-Module-2012-05-24.tar.gz
	afp-Group-Ring-Module-2013-02-16.tar.gz
	afp-Group-Ring-Module-2013-03-02.tar.gz
	afp-Group-Ring-Module-2013-11-17.tar.gz
	afp-Group-Ring-Module-2013-12-11.tar.gz
	afp-Group-Ring-Module-2014-08-28.tar.gz
	afp-Group-Ring-Module-2015-05-27.tar.gz
	afp-Group-Ring-Module-2016-02-22.tar.gz
	afp-Group-Ring-Module-2016-12-17.tar.gz
	afp-Group-Ring-Module-2017-10-10.tar.gz
	afp-Group-Ring-Module-2018-08-16.tar.gz
	+afp-Group-Ring-Module-2019-06-11.tar.gz
	afp-Heard_Of-2012-07-30.tar.gz
	afp-Heard_Of-2013-02-16.tar.gz
	afp-Heard_Of-2013-03-02.tar.gz
	afp-Heard_Of-2013-11-17.tar.gz
	afp-Heard_Of-2013-12-11.tar.gz
	afp-Heard_Of-2014-08-28.tar.gz
	afp-Heard_Of-2015-05-27.tar.gz
	afp-Heard_Of-2016-02-22.tar.gz
	afp-Heard_Of-2016-12-17.tar.gz
	afp-Heard_Of-2017-10-10.tar.gz
	afp-Heard_Of-2018-08-16.tar.gz
	+afp-Heard_Of-2019-06-11.tar.gz
	afp-HereditarilyFinite-2013-11-17.tar.gz
	afp-HereditarilyFinite-2013-12-11.tar.gz
	afp-HereditarilyFinite-2014-08-28.tar.gz
	afp-HereditarilyFinite-2015-05-27.tar.gz
	afp-HereditarilyFinite-2016-02-22.tar.gz
	afp-HereditarilyFinite-2016-12-17.tar.gz
	afp-HereditarilyFinite-2017-10-10.tar.gz
	afp-HereditarilyFinite-2018-08-16.tar.gz
	+afp-HereditarilyFinite-2019-06-11.tar.gz
	afp-Hermite-2015-07-07.tar.gz
	afp-Hermite-2016-02-22.tar.gz
	afp-Hermite-2016-12-17.tar.gz
	afp-Hermite-2017-10-10.tar.gz
	afp-Hermite-2018-08-16.tar.gz
	+afp-Hermite-2019-06-11.tar.gz
	afp-Hidden_Markov_Models-2018-05-25.tar.gz
	afp-Hidden_Markov_Models-2018-08-16.tar.gz
	+afp-Hidden_Markov_Models-2019-06-11.tar.gz
	afp-Higher_Order_Terms-2019-01-15.tar.gz
	+afp-Higher_Order_Terms-2019-06-11.tar.gz
	afp-Hoare_Time-2018-02-26.tar.gz
	afp-Hoare_Time-2018-08-16.tar.gz
	+afp-Hoare_Time-2019-06-11.tar.gz
	afp-HOLCF-Prelude-2017-07-15.tar.gz
	afp-HOLCF-Prelude-2017-10-10.tar.gz
	afp-HOLCF-Prelude-2018-08-16.tar.gz
	+afp-HOLCF-Prelude-2019-06-11.tar.gz
	afp-HOL-CSP-2019-04-29.tar.gz
	+afp-HOL-CSP-2019-06-11.tar.gz
	afp-HotelKeyCards-2007-11-27.tar.gz
	afp-HotelKeyCards-2008-06-10.tar.gz
	afp-HotelKeyCards-2009-04-29.tar.gz
	afp-HotelKeyCards-2009-12-12.tar.gz
	afp-HotelKeyCards-2010-07-01.tar.gz
	afp-HotelKeyCards-2011-02-11.tar.gz
	afp-HotelKeyCards-2011-10-11.tar.gz
	afp-HotelKeyCards-2012-05-24.tar.gz
	afp-HotelKeyCards-2013-02-16.tar.gz
	afp-HotelKeyCards-2013-11-17.tar.gz
	afp-HotelKeyCards-2013-12-11.tar.gz
	afp-HotelKeyCards-2014-08-28.tar.gz
	afp-HotelKeyCards-2015-05-27.tar.gz
	afp-HotelKeyCards-2016-02-22.tar.gz
	afp-HotelKeyCards-2016-12-17.tar.gz
	afp-HotelKeyCards-2017-10-10.tar.gz
	afp-HotelKeyCards-2018-08-16.tar.gz
	+afp-HotelKeyCards-2019-06-11.tar.gz
	afp-HRB-Slicing-2009-11-19.tar.gz
	afp-HRB-Slicing-2009-12-12.tar.gz
	afp-HRB-Slicing-2010-07-01.tar.gz
	afp-HRB-Slicing-2011-02-11.tar.gz
	afp-HRB-Slicing-2011-10-11.tar.gz
	afp-HRB-Slicing-2012-05-24.tar.gz
	afp-HRB-Slicing-2013-02-16.tar.gz
	afp-HRB-Slicing-2013-11-17.tar.gz
	afp-HRB-Slicing-2013-12-11.tar.gz
	afp-HRB-Slicing-2014-08-28.tar.gz
	afp-HRB-Slicing-2015-05-27.tar.gz
	afp-HRB-Slicing-2016-02-22.tar.gz
	afp-HRB-Slicing-2016-12-17.tar.gz
	afp-HRB-Slicing-2017-10-10.tar.gz
	afp-HRB-Slicing-2018-08-16.tar.gz
	+afp-HRB-Slicing-2019-06-11.tar.gz
	afp-Huffman-2008-10-15.tar.gz
	afp-Huffman-2008-10-21.tar.gz
	afp-Huffman-2009-04-29.tar.gz
	afp-Huffman-2009-12-12.tar.gz
	afp-Huffman-2010-07-01.tar.gz
	afp-Huffman-2011-02-11.tar.gz
	afp-Huffman-2011-10-11.tar.gz
	afp-Huffman-2012-05-24.tar.gz
	afp-Huffman-2013-02-16.tar.gz
	afp-Huffman-2013-03-02.tar.gz
	afp-Huffman-2013-11-17.tar.gz
	afp-Huffman-2013-12-11.tar.gz
	afp-Huffman-2014-08-28.tar.gz
	afp-Huffman-2015-05-27.tar.gz
	afp-Huffman-2016-02-22.tar.gz
	afp-Huffman-2016-12-17.tar.gz
	afp-Huffman-2017-10-10.tar.gz
	afp-Huffman-2018-08-16.tar.gz
	+afp-Huffman-2019-06-11.tar.gz
	afp-Hybrid_Multi_Lane_Spatial_Logic-2017-11-09.tar.gz
	afp-Hybrid_Multi_Lane_Spatial_Logic-2018-08-16.tar.gz
	+afp-Hybrid_Multi_Lane_Spatial_Logic-2019-06-11.tar.gz
	afp-HyperCTL-2014-04-16.tar.gz
	afp-HyperCTL-2014-08-28.tar.gz
	afp-HyperCTL-2015-05-27.tar.gz
	afp-HyperCTL-2016-02-22.tar.gz
	afp-HyperCTL-2016-12-17.tar.gz
	afp-HyperCTL-2017-10-10.tar.gz
	afp-HyperCTL-2018-08-16.tar.gz
	+afp-HyperCTL-2019-06-11.tar.gz
	afp-IEEE_Floating_Point-2013-07-28.tar.gz
	afp-IEEE_Floating_Point-2013-11-17.tar.gz
	afp-IEEE_Floating_Point-2013-12-11.tar.gz
	afp-IEEE_Floating_Point-2014-08-28.tar.gz
	afp-IEEE_Floating_Point-2015-05-27.tar.gz
	afp-IEEE_Floating_Point-2016-02-22.tar.gz
	afp-IEEE_Floating_Point-2016-12-17.tar.gz
	afp-IEEE_Floating_Point-2017-10-10.tar.gz
	afp-IEEE_Floating_Point-2018-08-16.tar.gz
	+afp-IEEE_Floating_Point-2019-06-11.tar.gz
	afp-IMAP-CRDT-2017-11-10.tar.gz
	afp-IMAP-CRDT-2018-08-16.tar.gz
	+afp-IMAP-CRDT-2019-06-11.tar.gz
	afp-IMP2-2019-01-15.tar.gz
	+afp-IMP2-2019-06-11.tar.gz
	afp-Imperative_Insertion_Sort-2014-09-25.tar.gz
	afp-Imperative_Insertion_Sort-2015-05-27.tar.gz
	afp-Imperative_Insertion_Sort-2016-02-22.tar.gz
	afp-Imperative_Insertion_Sort-2016-12-17.tar.gz
	afp-Imperative_Insertion_Sort-2017-10-10.tar.gz
	afp-Imperative_Insertion_Sort-2018-08-16.tar.gz
	+afp-Imperative_Insertion_Sort-2019-06-11.tar.gz
	afp-Impossible_Geometry-2012-08-06.tar.gz
	afp-Impossible_Geometry-2012-08-07.tar.gz
	afp-Impossible_Geometry-2013-02-16.tar.gz
	afp-Impossible_Geometry-2013-11-17.tar.gz
	afp-Impossible_Geometry-2013-12-11.tar.gz
	afp-Impossible_Geometry-2014-08-28.tar.gz
	afp-Impossible_Geometry-2015-05-27.tar.gz
	afp-Impossible_Geometry-2016-02-22.tar.gz
	afp-Impossible_Geometry-2016-12-17.tar.gz
	afp-Impossible_Geometry-2017-10-10.tar.gz
	afp-Impossible_Geometry-2018-08-16.tar.gz
	+afp-Impossible_Geometry-2019-06-11.tar.gz
	afp-Incompleteness-2013-11-17.tar.gz
	afp-Incompleteness-2013-12-02.tar.gz
	afp-Incompleteness-2013-12-11.tar.gz
	afp-Incompleteness-2014-08-28.tar.gz
	afp-Incompleteness-2015-05-27.tar.gz
	afp-Incompleteness-2016-02-22.tar.gz
	afp-Incompleteness-2016-12-17.tar.gz
	afp-Incompleteness-2017-10-10.tar.gz
	afp-Incompleteness-2018-08-16.tar.gz
	+afp-Incompleteness-2019-06-11.tar.gz
	afp-Incredible_Proof_Machine-2016-05-20.tar.gz
	afp-Incredible_Proof_Machine-2016-12-17.tar.gz
	afp-Incredible_Proof_Machine-2017-10-10.tar.gz
	afp-Incredible_Proof_Machine-2018-08-16.tar.gz
	+afp-Incredible_Proof_Machine-2019-06-11.tar.gz
	afp-Inductive_Confidentiality-2012-05-02.tar.gz
	afp-Inductive_Confidentiality-2012-05-24.tar.gz
	afp-Inductive_Confidentiality-2013-02-16.tar.gz
	afp-Inductive_Confidentiality-2013-11-17.tar.gz
	afp-Inductive_Confidentiality-2013-12-11.tar.gz
	afp-Inductive_Confidentiality-2014-08-28.tar.gz
	afp-Inductive_Confidentiality-2015-05-27.tar.gz
	afp-Inductive_Confidentiality-2016-02-22.tar.gz
	afp-Inductive_Confidentiality-2016-12-17.tar.gz
	afp-Inductive_Confidentiality-2017-10-10.tar.gz
	afp-Inductive_Confidentiality-2018-08-16.tar.gz
	+afp-Inductive_Confidentiality-2019-06-11.tar.gz
	afp-InformationFlowSlicing-2010-03-23.tar.gz
	afp-InformationFlowSlicing-2010-07-01.tar.gz
	afp-InformationFlowSlicing-2011-02-11.tar.gz
	afp-InformationFlowSlicing-2011-10-11.tar.gz
	afp-InformationFlowSlicing-2012-05-24.tar.gz
	afp-InformationFlowSlicing-2013-02-16.tar.gz
	afp-InformationFlowSlicing-2013-11-17.tar.gz
	afp-InformationFlowSlicing-2013-12-11.tar.gz
	afp-InformationFlowSlicing-2014-08-28.tar.gz
	afp-InformationFlowSlicing-2015-05-27.tar.gz
	afp-InformationFlowSlicing-2016-02-22.tar.gz
	afp-InformationFlowSlicing-2016-12-17.tar.gz
	afp-InformationFlowSlicing-2017-10-10.tar.gz
	afp-InformationFlowSlicing-2018-08-16.tar.gz
	+afp-InformationFlowSlicing-2019-06-11.tar.gz
	afp-InformationFlowSlicing_Inter-2016-12-17.tar.gz
	afp-InformationFlowSlicing_Inter-2017-10-10.tar.gz
	afp-InformationFlowSlicing_Inter-2018-08-16.tar.gz
	+afp-InformationFlowSlicing_Inter-2019-06-11.tar.gz
	afp-InfPathElimination-2016-08-18.tar.gz
	afp-InfPathElimination-2016-12-17.tar.gz
	afp-InfPathElimination-2017-10-10.tar.gz
	afp-InfPathElimination-2018-08-16.tar.gz
	+afp-InfPathElimination-2019-06-11.tar.gz
	afp-Integration-2004-11-22.tar.gz
	afp-Integration-2004-11-23.tar.gz
	afp-Integration-2005-10-14.tar.gz
	afp-Integration-2007-11-27.tar.gz
	afp-Integration-2008-06-10.tar.gz
	afp-Integration-2009-04-29.tar.gz
	afp-Integration-2009-12-12.tar.gz
	afp-Integration-2010-07-01.tar.gz
	afp-Integration-2011-02-11.tar.gz
	afp-Integration-2011-10-11.tar.gz
	afp-Integration-2012-05-24.tar.gz
	afp-Integration-2013-02-16.tar.gz
	afp-Integration-2013-11-17.tar.gz
	afp-Integration-2013-12-11.tar.gz
	afp-Integration-2014-08-28.tar.gz
	afp-Integration-2015-05-27.tar.gz
	afp-Integration-2016-02-22.tar.gz
	afp-Integration-2016-12-17.tar.gz
	afp-Integration-2017-10-10.tar.gz
	afp-Integration-2018-08-16.tar.gz
	+afp-Integration-2019-06-11.tar.gz
	afp-IP_Addresses-2016-06-28.tar.gz
	afp-IP_Addresses-2016-12-17.tar.gz
	afp-IP_Addresses-2017-10-10.tar.gz
	afp-IP_Addresses-2018-08-16.tar.gz
	+afp-IP_Addresses-2019-06-11.tar.gz
	afp-Iptables_Semantics-2016-09-09.tar.gz
	afp-Iptables_Semantics-2016-12-17.tar.gz
	afp-Iptables_Semantics-2017-10-10.tar.gz
	afp-Iptables_Semantics-2018-08-16.tar.gz
	+afp-Iptables_Semantics-2019-06-11.tar.gz
	afp-Irrationality_J_Hancl-2018-05-26.tar.gz
	afp-Irrationality_J_Hancl-2018-08-16.tar.gz
	+afp-Irrationality_J_Hancl-2019-06-11.tar.gz
	afp-Isabelle_Meta_Model-2015-09-25.tar.gz
	afp-Isabelle_Meta_Model-2015-09-28.tar.gz
	afp-Isabelle_Meta_Model-2016-02-22.tar.gz
	afp-Isabelle_Meta_Model-2016-12-17.tar.gz
	afp-Isabelle_Meta_Model-2017-10-10.tar.gz
	afp-Isabelle_Meta_Model-2018-08-16.tar.gz
	+afp-Isabelle_Meta_Model-2019-06-11.tar.gz
	afp-Jinja-2005-10-14.tar.gz
	afp-Jinja-2006-08-08.tar.gz
	afp-Jinja-2007-11-27.tar.gz
	afp-Jinja-2008-06-10.tar.gz
	afp-Jinja-2009-04-29.tar.gz
	afp-Jinja-2009-12-12.tar.gz
	afp-Jinja-2010-07-01.tar.gz
	afp-Jinja-2011-02-11.tar.gz
	afp-Jinja-2011-10-11.tar.gz
	afp-Jinja-2012-05-24.tar.gz
	afp-Jinja-2013-02-16.tar.gz
	afp-Jinja-2013-11-17.tar.gz
	afp-Jinja-2013-12-11.tar.gz
	afp-Jinja-2014-08-28.tar.gz
	afp-Jinja-2015-05-27.tar.gz
	afp-Jinja-2016-02-22.tar.gz
	afp-Jinja-2016-12-17.tar.gz
	afp-Jinja-2017-10-10.tar.gz
	afp-Jinja-2018-08-16.tar.gz
	+afp-Jinja-2019-06-11.tar.gz
	afp-JinjaThreads-2007-12-03.tar.gz
	afp-JinjaThreads-2008-06-10.tar.gz
	afp-JinjaThreads-2009-04-29.tar.gz
	afp-JinjaThreads-2009-04-30.tar.gz
	afp-JinjaThreads-2009-12-12.tar.gz
	afp-JinjaThreads-2010-07-02.tar.gz
	afp-JinjaThreads-2011-02-11.tar.gz
	afp-JinjaThreads-2011-10-11.tar.gz
	afp-JinjaThreads-2011-10-12.tar.gz
	afp-JinjaThreads-2012-05-26.tar.gz
	afp-JinjaThreads-2013-02-16.tar.gz
	afp-JinjaThreads-2013-11-17.tar.gz
	afp-JinjaThreads-2013-12-11.tar.gz
	afp-JinjaThreads-2014-08-28.tar.gz
	afp-JinjaThreads-2015-05-27.tar.gz
	afp-JinjaThreads-2016-02-22.tar.gz
	afp-JinjaThreads-2016-12-17.tar.gz
	afp-JinjaThreads-2017-10-10.tar.gz
	afp-JinjaThreads-2018-08-17.tar.gz
	+afp-JinjaThreads-2019-06-11.tar.gz
	afp-JiveDataStoreModel-2005-10-14.tar.gz
	afp-JiveDataStoreModel-2007-11-27.tar.gz
	afp-JiveDataStoreModel-2008-06-10.tar.gz
	afp-JiveDataStoreModel-2009-04-29.tar.gz
	afp-JiveDataStoreModel-2009-12-12.tar.gz
	afp-JiveDataStoreModel-2010-07-01.tar.gz
	afp-JiveDataStoreModel-2011-02-11.tar.gz
	afp-JiveDataStoreModel-2011-10-11.tar.gz
	afp-JiveDataStoreModel-2012-05-24.tar.gz
	afp-JiveDataStoreModel-2013-02-16.tar.gz
	afp-JiveDataStoreModel-2013-11-17.tar.gz
	afp-JiveDataStoreModel-2013-12-11.tar.gz
	afp-JiveDataStoreModel-2014-08-28.tar.gz
	afp-JiveDataStoreModel-2015-05-27.tar.gz
	afp-JiveDataStoreModel-2016-02-22.tar.gz
	afp-JiveDataStoreModel-2016-12-17.tar.gz
	afp-JiveDataStoreModel-2017-10-10.tar.gz
	afp-JiveDataStoreModel-2018-08-16.tar.gz
	+afp-JiveDataStoreModel-2019-06-11.tar.gz
	afp-Jordan_Hoelder-2014-09-11.tar.gz
	afp-Jordan_Hoelder-2015-05-27.tar.gz
	afp-Jordan_Hoelder-2016-02-22.tar.gz
	afp-Jordan_Hoelder-2016-12-17.tar.gz
	afp-Jordan_Hoelder-2017-10-10.tar.gz
	afp-Jordan_Hoelder-2018-08-16.tar.gz
	+afp-Jordan_Hoelder-2019-06-11.tar.gz
	afp-Jordan_Normal_Form-2015-08-23.tar.gz
	afp-Jordan_Normal_Form-2016-02-22.tar.gz
	afp-Jordan_Normal_Form-2016-12-17.tar.gz
	afp-Jordan_Normal_Form-2017-10-10.tar.gz
	afp-Jordan_Normal_Form-2018-08-16.tar.gz
	+afp-Jordan_Normal_Form-2019-06-11.tar.gz
	afp-KAD-2016-04-12.tar.gz
	afp-KAD-2016-12-17.tar.gz
	afp-KAD-2017-10-10.tar.gz
	afp-KAD-2018-08-16.tar.gz
	+afp-KAD-2019-06-11.tar.gz
	afp-KAT_and_DRA-2014-01-29.tar.gz
	afp-KAT_and_DRA-2014-08-28.tar.gz
	afp-KAT_and_DRA-2015-05-27.tar.gz
	afp-KAT_and_DRA-2016-02-22.tar.gz
	afp-KAT_and_DRA-2016-12-17.tar.gz
	afp-KAT_and_DRA-2017-10-10.tar.gz
	afp-KAT_and_DRA-2018-08-16.tar.gz
	+afp-KAT_and_DRA-2019-06-11.tar.gz
	afp-KBPs-2011-05-19.tar.gz
	afp-KBPs-2011-10-11.tar.gz
	afp-KBPs-2012-05-24.tar.gz
	afp-KBPs-2013-02-16.tar.gz
	afp-KBPs-2013-03-02.tar.gz
	afp-KBPs-2013-11-17.tar.gz
	afp-KBPs-2013-12-11.tar.gz
	afp-KBPs-2014-08-28.tar.gz
	afp-KBPs-2015-05-27.tar.gz
	afp-KBPs-2016-02-22.tar.gz
	afp-KBPs-2016-12-17.tar.gz
	afp-KBPs-2017-10-10.tar.gz
	afp-KBPs-2018-08-16.tar.gz
	+afp-KBPs-2019-06-11.tar.gz
	+afp-KD_Tree-2019-06-04.tar.gz
	+afp-KD_Tree-2019-06-11.tar.gz
	afp-Key_Agreement_Strong_Adversaries-2017-02-03.tar.gz
	afp-Key_Agreement_Strong_Adversaries-2017-10-10.tar.gz
	afp-Key_Agreement_Strong_Adversaries-2018-08-16.tar.gz
	+afp-Key_Agreement_Strong_Adversaries-2019-06-11.tar.gz
	afp-Kleene_Algebra-2013-01-16.tar.gz
	afp-Kleene_Algebra-2013-02-16.tar.gz
	afp-Kleene_Algebra-2013-03-02.tar.gz
	afp-Kleene_Algebra-2013-11-17.tar.gz
	afp-Kleene_Algebra-2013-12-11.tar.gz
	afp-Kleene_Algebra-2014-08-28.tar.gz
	afp-Kleene_Algebra-2015-05-27.tar.gz
	afp-Kleene_Algebra-2016-02-22.tar.gz
	afp-Kleene_Algebra-2016-12-17.tar.gz
	afp-Kleene_Algebra-2017-10-10.tar.gz
	afp-Kleene_Algebra-2018-08-16.tar.gz
	+afp-Kleene_Algebra-2019-06-11.tar.gz
	afp-Knot_Theory-2016-01-20.tar.gz
	afp-Knot_Theory-2016-02-22.tar.gz
	afp-Knot_Theory-2016-12-17.tar.gz
	afp-Knot_Theory-2017-10-10.tar.gz
	afp-Knot_Theory-2018-08-16.tar.gz
	+afp-Knot_Theory-2019-06-11.tar.gz
	afp-Knuth_Morris_Pratt-2017-12-18.tar.gz
	afp-Knuth_Morris_Pratt-2018-08-16.tar.gz
	+afp-Knuth_Morris_Pratt-2019-06-11.tar.gz
	afp-Koenigsberg_Friendship-2013-07-26.tar.gz
	afp-Koenigsberg_Friendship-2013-11-17.tar.gz
	afp-Koenigsberg_Friendship-2013-12-11.tar.gz
	afp-Koenigsberg_Friendship-2014-08-28.tar.gz
	afp-Koenigsberg_Friendship-2015-05-27.tar.gz
	afp-Koenigsberg_Friendship-2016-02-22.tar.gz
	afp-Koenigsberg_Friendship-2016-12-17.tar.gz
	afp-Koenigsberg_Friendship-2017-10-10.tar.gz
	afp-Koenigsberg_Friendship-2018-08-16.tar.gz
	+afp-Koenigsberg_Friendship-2019-06-11.tar.gz
	afp-Kruskal-2019-02-19.tar.gz
	+afp-Kruskal-2019-06-11.tar.gz
	afp-Kuratowski_Closure_Complement-2017-10-27.tar.gz
	afp-Kuratowski_Closure_Complement-2018-08-16.tar.gz
	+afp-Kuratowski_Closure_Complement-2019-06-11.tar.gz
	afp-LambdaAuth-2019-05-15.tar.gz
	+afp-LambdaAuth-2019-06-11.tar.gz
	afp-Lambda_Free_EPO-2018-10-21.tar.gz
	+afp-Lambda_Free_EPO-2019-06-11.tar.gz
	afp-Lambda_Free_KBOs-2016-12-17.tar.gz
	afp-Lambda_Free_KBOs-2017-10-10.tar.gz
	afp-Lambda_Free_KBOs-2018-08-16.tar.gz
	+afp-Lambda_Free_KBOs-2019-06-11.tar.gz
	afp-Lambda_Free_RPOs-2016-12-17.tar.gz
	afp-Lambda_Free_RPOs-2017-10-10.tar.gz
	afp-Lambda_Free_RPOs-2018-08-16.tar.gz
	+afp-Lambda_Free_RPOs-2019-06-11.tar.gz
	afp-LambdaMu-2017-08-21.tar.gz
	afp-LambdaMu-2017-10-10.tar.gz
	afp-LambdaMu-2018-08-16.tar.gz
	+afp-LambdaMu-2019-06-11.tar.gz
	afp-Lam-ml-Normalization-2010-09-01.tar.gz
	afp-Lam-ml-Normalization-2011-02-11.tar.gz
	afp-Lam-ml-Normalization-2011-10-11.tar.gz
	afp-Lam-ml-Normalization-2012-05-24.tar.gz
	afp-Lam-ml-Normalization-2013-02-16.tar.gz
	afp-Lam-ml-Normalization-2013-11-17.tar.gz
	afp-Lam-ml-Normalization-2013-12-11.tar.gz
	afp-Lam-ml-Normalization-2014-08-28.tar.gz
	afp-Lam-ml-Normalization-2015-05-27.tar.gz
	afp-Lam-ml-Normalization-2016-02-22.tar.gz
	afp-Lam-ml-Normalization-2016-12-17.tar.gz
	afp-Lam-ml-Normalization-2017-10-10.tar.gz
	afp-Lam-ml-Normalization-2018-08-16.tar.gz
	+afp-Lam-ml-Normalization-2019-06-11.tar.gz
	afp-Landau_Symbols-2015-07-15.tar.gz
	afp-Landau_Symbols-2016-02-22.tar.gz
	afp-Landau_Symbols-2016-12-17.tar.gz
	afp-Landau_Symbols-2017-10-10.tar.gz
	afp-Landau_Symbols-2018-08-16.tar.gz
	+afp-Landau_Symbols-2019-06-11.tar.gz
	afp-Latin_Square-2015-12-03.tar.gz
	afp-Latin_Square-2016-02-22.tar.gz
	afp-Latin_Square-2016-12-17.tar.gz
	afp-Latin_Square-2017-10-10.tar.gz
	afp-Latin_Square-2018-08-16.tar.gz
	+afp-Latin_Square-2019-06-11.tar.gz
	afp-LatticeProperties-2011-09-27.tar.gz
	afp-LatticeProperties-2011-10-11.tar.gz
	afp-LatticeProperties-2012-05-24.tar.gz
	afp-LatticeProperties-2013-02-16.tar.gz
	afp-LatticeProperties-2013-11-17.tar.gz
	afp-LatticeProperties-2013-12-11.tar.gz
	afp-LatticeProperties-2014-08-28.tar.gz
	afp-LatticeProperties-2015-05-27.tar.gz
	afp-LatticeProperties-2016-02-22.tar.gz
	afp-LatticeProperties-2016-12-17.tar.gz
	afp-LatticeProperties-2017-10-10.tar.gz
	afp-LatticeProperties-2018-08-16.tar.gz
	+afp-LatticeProperties-2019-06-11.tar.gz
	afp-Launchbury-2013-02-24.tar.gz
	afp-Launchbury-2013-02-25.tar.gz
	afp-Launchbury-2013-11-17.tar.gz
	afp-Launchbury-2013-12-11.tar.gz
	afp-Launchbury-2014-05-24.tar.gz
	afp-Launchbury-2014-05-25.tar.gz
	afp-Launchbury-2014-08-28.tar.gz
	afp-Launchbury-2015-05-27.tar.gz
	afp-Launchbury-2016-02-22.tar.gz
	afp-Launchbury-2016-12-17.tar.gz
	afp-Launchbury-2017-10-10.tar.gz
	afp-Launchbury-2018-08-16.tar.gz
	+afp-Launchbury-2019-06-11.tar.gz
	afp-Lazy_Case-2017-04-20.tar.gz
	afp-Lazy_Case-2017-10-10.tar.gz
	afp-Lazy_Case-2018-08-16.tar.gz
	+afp-Lazy_Case-2019-06-11.tar.gz
	afp-Lazy-Lists-II-2004-04-27.tar.gz
	afp-Lazy-Lists-II-2004-05-21.tar.gz
	afp-Lazy-Lists-II-2005-10-14.tar.gz
	afp-Lazy-Lists-II-2007-11-27.tar.gz
	afp-Lazy-Lists-II-2008-06-10.tar.gz
	afp-Lazy-Lists-II-2009-04-29.tar.gz
	afp-Lazy-Lists-II-2009-12-12.tar.gz
	afp-Lazy-Lists-II-2010-07-01.tar.gz
	afp-Lazy-Lists-II-2011-02-11.tar.gz
	afp-Lazy-Lists-II-2011-10-11.tar.gz
	afp-Lazy-Lists-II-2012-05-24.tar.gz
	afp-Lazy-Lists-II-2013-02-16.tar.gz
	afp-Lazy-Lists-II-2013-11-17.tar.gz
	afp-Lazy-Lists-II-2013-12-11.tar.gz
	afp-Lazy-Lists-II-2014-08-28.tar.gz
	afp-Lazy-Lists-II-2015-05-27.tar.gz
	afp-Lazy-Lists-II-2016-02-22.tar.gz
	afp-Lazy-Lists-II-2016-12-17.tar.gz
	afp-Lazy-Lists-II-2017-10-10.tar.gz
	afp-Lazy-Lists-II-2018-08-16.tar.gz
	+afp-Lazy-Lists-II-2019-06-11.tar.gz
	afp-Lehmer-2013-11-17.tar.gz
	afp-Lehmer-2013-12-11.tar.gz
	afp-Lehmer-2014-08-28.tar.gz
	afp-Lehmer-2015-05-27.tar.gz
	afp-Lehmer-2016-02-22.tar.gz
	afp-Lehmer-2016-12-17.tar.gz
	afp-Lehmer-2017-10-10.tar.gz
	afp-Lehmer-2018-08-16.tar.gz
	+afp-Lehmer-2019-06-11.tar.gz
	afp-Lifting_Definition_Option-2014-10-15.tar.gz
	afp-Lifting_Definition_Option-2015-05-27.tar.gz
	afp-Lifting_Definition_Option-2016-02-22.tar.gz
	afp-Lifting_Definition_Option-2016-12-17.tar.gz
	afp-Lifting_Definition_Option-2017-10-10.tar.gz
	afp-Lifting_Definition_Option-2018-08-16.tar.gz
	+afp-Lifting_Definition_Option-2019-06-11.tar.gz
	afp-LightweightJava-2011-03-02.tar.gz
	afp-LightweightJava-2011-10-11.tar.gz
	afp-LightweightJava-2012-05-24.tar.gz
	afp-LightweightJava-2013-02-16.tar.gz
	afp-LightweightJava-2013-11-17.tar.gz
	afp-LightweightJava-2013-12-11.tar.gz
	afp-LightweightJava-2014-08-28.tar.gz
	afp-LightweightJava-2015-05-27.tar.gz
	afp-LightweightJava-2016-02-22.tar.gz
	afp-LightweightJava-2016-12-17.tar.gz
	afp-LightweightJava-2017-10-10.tar.gz
	afp-LightweightJava-2018-08-16.tar.gz
	+afp-LightweightJava-2019-06-11.tar.gz
	afp-LinearQuantifierElim-2008-01-11.tar.gz
	afp-LinearQuantifierElim-2008-01-24.tar.gz
	afp-LinearQuantifierElim-2008-02-12.tar.gz
	afp-LinearQuantifierElim-2008-06-10.tar.gz
	afp-LinearQuantifierElim-2009-04-29.tar.gz
	afp-LinearQuantifierElim-2009-12-12.tar.gz
	afp-LinearQuantifierElim-2010-07-01.tar.gz
	afp-LinearQuantifierElim-2011-02-11.tar.gz
	afp-LinearQuantifierElim-2011-10-11.tar.gz
	afp-LinearQuantifierElim-2012-05-24.tar.gz
	afp-LinearQuantifierElim-2013-02-16.tar.gz
	afp-LinearQuantifierElim-2013-03-02.tar.gz
	afp-LinearQuantifierElim-2013-11-17.tar.gz
	afp-LinearQuantifierElim-2013-12-11.tar.gz
	afp-LinearQuantifierElim-2014-08-28.tar.gz
	afp-LinearQuantifierElim-2015-05-27.tar.gz
	afp-LinearQuantifierElim-2016-02-22.tar.gz
	afp-LinearQuantifierElim-2016-12-17.tar.gz
	afp-LinearQuantifierElim-2017-10-10.tar.gz
	afp-LinearQuantifierElim-2018-08-16.tar.gz
	+afp-LinearQuantifierElim-2019-06-11.tar.gz
	afp-Linear_Recurrences-2017-10-17.tar.gz
	afp-Linear_Recurrences-2018-08-16.tar.gz
	+afp-Linear_Recurrences-2019-06-11.tar.gz
	afp-Liouville_Numbers-2016-01-05.tar.gz
	afp-Liouville_Numbers-2016-02-22.tar.gz
	afp-Liouville_Numbers-2016-12-17.tar.gz
	afp-Liouville_Numbers-2017-10-10.tar.gz
	afp-Liouville_Numbers-2018-08-16.tar.gz
	+afp-Liouville_Numbers-2019-06-11.tar.gz
	afp-List-Index-2010-02-20.tar.gz
	afp-List-Index-2010-07-01.tar.gz
	afp-List-Index-2011-02-11.tar.gz
	afp-List-Index-2011-10-11.tar.gz
	afp-List-Index-2012-05-24.tar.gz
	afp-List-Index-2013-02-16.tar.gz
	afp-List-Index-2013-11-17.tar.gz
	afp-List-Index-2013-12-11.tar.gz
	afp-List-Index-2014-08-28.tar.gz
	afp-List-Index-2015-05-27.tar.gz
	afp-List-Index-2016-02-22.tar.gz
	afp-List-Index-2016-12-17.tar.gz
	afp-List-Index-2017-10-10.tar.gz
	afp-List-Index-2018-08-16.tar.gz
	+afp-List-Index-2019-06-11.tar.gz
	afp-List-Infinite-2011-02-24.tar.gz
	afp-List-Infinite-2011-10-11.tar.gz
	afp-List-Infinite-2012-05-24.tar.gz
	afp-List-Infinite-2013-02-16.tar.gz
	afp-List-Infinite-2013-03-02.tar.gz
	afp-List-Infinite-2013-11-17.tar.gz
	afp-List-Infinite-2013-12-11.tar.gz
	afp-List-Infinite-2014-08-28.tar.gz
	afp-List-Infinite-2015-05-27.tar.gz
	afp-List-Infinite-2016-02-22.tar.gz
	afp-List-Infinite-2016-12-17.tar.gz
	afp-List-Infinite-2017-10-10.tar.gz
	afp-List-Infinite-2018-08-16.tar.gz
	+afp-List-Infinite-2019-06-11.tar.gz
	afp-List_Interleaving-2015-06-13.tar.gz
	afp-List_Interleaving-2016-02-22.tar.gz
	afp-List_Interleaving-2016-12-17.tar.gz
	afp-List_Interleaving-2017-10-10.tar.gz
	afp-List_Interleaving-2018-08-16.tar.gz
	+afp-List_Interleaving-2019-06-11.tar.gz
	afp-List_Inversions-2019-02-21.tar.gz
	+afp-List_Inversions-2019-06-11.tar.gz
	afp-List_Update-2016-02-22.tar.gz
	afp-List_Update-2016-02-23.tar.gz
	afp-List_Update-2016-10-15.tar.gz
	afp-List_Update-2016-12-17.tar.gz
	afp-List_Update-2017-10-10.tar.gz
	afp-List_Update-2018-08-16.tar.gz
	+afp-List_Update-2019-06-11.tar.gz
	afp-LLL_Basis_Reduction-2018-02-03.tar.gz
	afp-LLL_Basis_Reduction-2018-08-16.tar.gz
	afp-LLL_Basis_Reduction-2018-09-07.tar.gz
	+afp-LLL_Basis_Reduction-2019-06-11.tar.gz
	afp-LLL_Factorization-2018-02-07.tar.gz
	afp-LLL_Factorization-2018-08-16.tar.gz
	+afp-LLL_Factorization-2019-06-11.tar.gz
	afp-Localization_Ring-2018-06-17.tar.gz
	afp-Localization_Ring-2018-08-16.tar.gz
	+afp-Localization_Ring-2019-06-11.tar.gz
	afp-LocalLexing-2017-04-28.tar.gz
	afp-LocalLexing-2017-10-10.tar.gz
	afp-LocalLexing-2018-08-16.tar.gz
	+afp-LocalLexing-2019-06-11.tar.gz
	afp-Locally-Nameless-Sigma-2010-05-03.tar.gz
	afp-Locally-Nameless-Sigma-2010-07-01.tar.gz
	afp-Locally-Nameless-Sigma-2011-02-11.tar.gz
	afp-Locally-Nameless-Sigma-2011-10-11.tar.gz
	afp-Locally-Nameless-Sigma-2012-05-24.tar.gz
	afp-Locally-Nameless-Sigma-2013-02-16.tar.gz
	afp-Locally-Nameless-Sigma-2013-11-17.tar.gz
	afp-Locally-Nameless-Sigma-2013-12-11.tar.gz
	afp-Locally-Nameless-Sigma-2014-08-28.tar.gz
	afp-Locally-Nameless-Sigma-2015-05-27.tar.gz
	afp-Locally-Nameless-Sigma-2016-02-22.tar.gz
	afp-Locally-Nameless-Sigma-2016-12-17.tar.gz
	afp-Locally-Nameless-Sigma-2017-10-10.tar.gz
	afp-Locally-Nameless-Sigma-2018-08-16.tar.gz
	+afp-Locally-Nameless-Sigma-2019-06-11.tar.gz
	afp-LOFT-2016-10-21.tar.gz
	afp-LOFT-2016-12-17.tar.gz
	afp-LOFT-2017-10-10.tar.gz
	afp-LOFT-2018-08-16.tar.gz
	+afp-LOFT-2019-06-11.tar.gz
	afp-Lowe_Ontological_Argument-2017-10-16.tar.gz
	afp-Lowe_Ontological_Argument-2018-08-16.tar.gz
	+afp-Lowe_Ontological_Argument-2019-06-11.tar.gz
	afp-Lower_Semicontinuous-2011-02-11.tar.gz
	afp-Lower_Semicontinuous-2011-10-11.tar.gz
	afp-Lower_Semicontinuous-2012-05-24.tar.gz
	afp-Lower_Semicontinuous-2013-02-16.tar.gz
	afp-Lower_Semicontinuous-2013-11-17.tar.gz
	afp-Lower_Semicontinuous-2013-12-11.tar.gz
	afp-Lower_Semicontinuous-2014-08-28.tar.gz
	afp-Lower_Semicontinuous-2015-05-27.tar.gz
	afp-Lower_Semicontinuous-2016-02-22.tar.gz
	afp-Lower_Semicontinuous-2016-12-17.tar.gz
	afp-Lower_Semicontinuous-2017-10-10.tar.gz
	afp-Lower_Semicontinuous-2018-08-16.tar.gz
	+afp-Lower_Semicontinuous-2019-06-11.tar.gz
	afp-Lp-2016-12-17.tar.gz
	afp-Lp-2017-10-10.tar.gz
	afp-Lp-2018-08-16.tar.gz
	+afp-Lp-2019-06-11.tar.gz
	afp-LTL-2016-03-02.tar.gz
	afp-LTL-2016-12-17.tar.gz
	afp-LTL-2017-10-10.tar.gz
	afp-LTL-2018-08-16.tar.gz
	+afp-LTL-2019-06-11.tar.gz
	afp-LTL_Master_Theorem-2019-04-17.tar.gz
	+afp-LTL_Master_Theorem-2019-06-11.tar.gz
	afp-LTL_to_DRA-2015-09-04.tar.gz
	afp-LTL_to_DRA-2016-02-22.tar.gz
	afp-LTL_to_DRA-2016-12-17.tar.gz
	afp-LTL_to_DRA-2017-10-10.tar.gz
	afp-LTL_to_DRA-2018-08-16.tar.gz
	+afp-LTL_to_DRA-2019-06-11.tar.gz
	afp-LTL_to_GBA-2014-05-29.tar.gz
	afp-LTL_to_GBA-2014-08-28.tar.gz
	afp-LTL_to_GBA-2015-05-27.tar.gz
	afp-LTL_to_GBA-2016-02-22.tar.gz
	afp-LTL_to_GBA-2016-12-17.tar.gz
	afp-LTL_to_GBA-2017-10-10.tar.gz
	afp-LTL_to_GBA-2018-08-16.tar.gz
	+afp-LTL_to_GBA-2019-06-11.tar.gz
	afp-Markov_Models-2012-01-05.tar.gz
	afp-Markov_Models-2012-01-08.tar.gz
	afp-Markov_Models-2012-05-24.tar.gz
	afp-Markov_Models-2013-02-16.tar.gz
	afp-Markov_Models-2013-11-17.tar.gz
	afp-Markov_Models-2013-12-11.tar.gz
	afp-Markov_Models-2014-08-28.tar.gz
	afp-Markov_Models-2015-05-27.tar.gz
	afp-Markov_Models-2016-02-22.tar.gz
	afp-Markov_Models-2016-12-17.tar.gz
	afp-Markov_Models-2017-10-10.tar.gz
	afp-Markov_Models-2018-08-16.tar.gz
	+afp-Markov_Models-2019-06-11.tar.gz
	afp-Marriage-2010-12-17.tar.gz
	afp-Marriage-2011-02-11.tar.gz
	afp-Marriage-2011-10-11.tar.gz
	afp-Marriage-2012-05-24.tar.gz
	afp-Marriage-2013-02-16.tar.gz
	afp-Marriage-2013-11-17.tar.gz
	afp-Marriage-2013-12-11.tar.gz
	afp-Marriage-2014-08-28.tar.gz
	afp-Marriage-2015-05-27.tar.gz
	afp-Marriage-2016-02-22.tar.gz
	afp-Marriage-2016-12-17.tar.gz
	afp-Marriage-2017-10-10.tar.gz
	afp-Marriage-2018-08-16.tar.gz
	+afp-Marriage-2019-06-11.tar.gz
	afp-Mason_Stothers-2017-12-22.tar.gz
	afp-Mason_Stothers-2018-08-16.tar.gz
	+afp-Mason_Stothers-2019-06-11.tar.gz
	afp-Matrix-2010-06-17.tar.gz
	afp-Matrix-2010-07-01.tar.gz
	afp-Matrix-2011-02-11.tar.gz
	afp-Matrix-2011-10-11.tar.gz
	afp-Matrix-2012-05-24.tar.gz
	afp-Matrix-2013-02-16.tar.gz
	afp-Matrix-2013-11-17.tar.gz
	afp-Matrix-2013-12-11.tar.gz
	afp-Matrix-2014-08-28.tar.gz
	afp-Matrix-2015-05-27.tar.gz
	afp-Matrix-2016-02-22.tar.gz
	afp-Matrix-2016-12-17.tar.gz
	afp-Matrix-2017-10-10.tar.gz
	afp-Matrix-2018-08-16.tar.gz
	+afp-Matrix-2019-06-11.tar.gz
	afp-Matrix_Tensor-2016-01-18.tar.gz
	afp-Matrix_Tensor-2016-01-19.tar.gz
	afp-Matrix_Tensor-2016-02-22.tar.gz
	afp-Matrix_Tensor-2016-12-17.tar.gz
	afp-Matrix_Tensor-2017-10-10.tar.gz
	afp-Matrix_Tensor-2018-08-16.tar.gz
	+afp-Matrix_Tensor-2019-06-11.tar.gz
	afp-Matroids-2018-11-20.tar.gz
	+afp-Matroids-2019-06-11.tar.gz
	afp-Max-Card-Matching-2011-08-15.tar.gz
	afp-Max-Card-Matching-2011-08-19.tar.gz
	afp-Max-Card-Matching-2011-10-11.tar.gz
	afp-Max-Card-Matching-2012-05-24.tar.gz
	afp-Max-Card-Matching-2013-02-16.tar.gz
	afp-Max-Card-Matching-2013-11-17.tar.gz
	afp-Max-Card-Matching-2013-12-11.tar.gz
	afp-Max-Card-Matching-2014-08-28.tar.gz
	afp-Max-Card-Matching-2015-05-27.tar.gz
	afp-Max-Card-Matching-2016-02-22.tar.gz
	afp-Max-Card-Matching-2016-12-17.tar.gz
	afp-Max-Card-Matching-2017-10-10.tar.gz
	afp-Max-Card-Matching-2018-08-16.tar.gz
	+afp-Max-Card-Matching-2019-06-11.tar.gz
	afp-Median_Of_Medians_Selection-2017-12-22.tar.gz
	afp-Median_Of_Medians_Selection-2018-08-16.tar.gz
	+afp-Median_Of_Medians_Selection-2019-06-11.tar.gz
	afp-Menger-2017-02-27.tar.gz
	afp-Menger-2017-10-10.tar.gz
	afp-Menger-2018-08-16.tar.gz
	+afp-Menger-2019-06-11.tar.gz
	afp-MFMC_Countable-2016-05-09.tar.gz
	afp-MFMC_Countable-2016-12-17.tar.gz
	afp-MFMC_Countable-2017-10-10.tar.gz
	afp-MFMC_Countable-2018-08-16.tar.gz
	+afp-MFMC_Countable-2019-06-11.tar.gz
	afp-Minimal_SSA-2017-01-19.tar.gz
	afp-Minimal_SSA-2017-10-10.tar.gz
	afp-Minimal_SSA-2018-08-16.tar.gz
	+afp-Minimal_SSA-2019-06-11.tar.gz
	afp-MiniML-2004-03-23.tar.gz
	afp-MiniML-2004-04-20.tar.gz
	afp-MiniML-2004-05-21.tar.gz
	afp-MiniML-2005-10-14.tar.gz
	afp-MiniML-2007-11-27.tar.gz
	afp-MiniML-2008-06-10.tar.gz
	afp-MiniML-2009-04-29.tar.gz
	afp-MiniML-2009-12-12.tar.gz
	afp-MiniML-2010-07-01.tar.gz
	afp-MiniML-2011-02-11.tar.gz
	afp-MiniML-2011-10-11.tar.gz
	afp-MiniML-2012-05-24.tar.gz
	afp-MiniML-2013-02-16.tar.gz
	afp-MiniML-2013-03-02.tar.gz
	afp-MiniML-2013-11-17.tar.gz
	afp-MiniML-2013-12-11.tar.gz
	afp-MiniML-2014-08-28.tar.gz
	afp-MiniML-2015-05-27.tar.gz
	afp-MiniML-2016-02-22.tar.gz
	afp-MiniML-2016-12-17.tar.gz
	afp-MiniML-2017-10-10.tar.gz
	afp-MiniML-2018-08-16.tar.gz
	afp-MiniML-2019-04-18.tar.gz
	+afp-MiniML-2019-06-11.tar.gz
	afp-Minkowskis_Theorem-2017-07-15.tar.gz
	afp-Minkowskis_Theorem-2017-10-10.tar.gz
	afp-Minkowskis_Theorem-2018-08-16.tar.gz
	+afp-Minkowskis_Theorem-2019-06-11.tar.gz
	afp-Minsky_Machines-2018-08-14.tar.gz
	afp-Minsky_Machines-2018-08-16.tar.gz
	+afp-Minsky_Machines-2019-06-11.tar.gz
	afp-Modal_Logics_for_NTS-2016-10-25.tar.gz
	afp-Modal_Logics_for_NTS-2016-10-27.tar.gz
	afp-Modal_Logics_for_NTS-2016-12-17.tar.gz
	afp-Modal_Logics_for_NTS-2017-10-10.tar.gz
	afp-Modal_Logics_for_NTS-2018-08-16.tar.gz
	+afp-Modal_Logics_for_NTS-2019-06-11.tar.gz
	afp-Modular_Assembly_Kit_Security-2018-05-09.tar.gz
	afp-Modular_Assembly_Kit_Security-2018-08-16.tar.gz
	+afp-Modular_Assembly_Kit_Security-2019-06-11.tar.gz
	afp-Monad_Memo_DP-2018-05-23.tar.gz
	afp-Monad_Memo_DP-2018-08-16.tar.gz
	+afp-Monad_Memo_DP-2019-06-11.tar.gz
	afp-Monad_Normalisation-2017-05-11.tar.gz
	afp-Monad_Normalisation-2017-10-10.tar.gz
	afp-Monad_Normalisation-2018-08-16.tar.gz
	+afp-Monad_Normalisation-2019-06-11.tar.gz
	afp-MonoBoolTranAlgebra-2011-09-27.tar.gz
	afp-MonoBoolTranAlgebra-2011-10-11.tar.gz
	afp-MonoBoolTranAlgebra-2012-05-24.tar.gz
	afp-MonoBoolTranAlgebra-2013-02-16.tar.gz
	afp-MonoBoolTranAlgebra-2013-11-17.tar.gz
	afp-MonoBoolTranAlgebra-2013-12-11.tar.gz
	afp-MonoBoolTranAlgebra-2014-08-28.tar.gz
	afp-MonoBoolTranAlgebra-2015-05-27.tar.gz
	afp-MonoBoolTranAlgebra-2016-02-22.tar.gz
	afp-MonoBoolTranAlgebra-2016-12-17.tar.gz
	afp-MonoBoolTranAlgebra-2017-10-10.tar.gz
	afp-MonoBoolTranAlgebra-2018-08-16.tar.gz
	+afp-MonoBoolTranAlgebra-2019-06-11.tar.gz
	afp-MonoidalCategory-2017-05-05.tar.gz
	afp-MonoidalCategory-2017-10-10.tar.gz
	afp-MonoidalCategory-2018-08-16.tar.gz
	+afp-MonoidalCategory-2019-06-11.tar.gz
	afp-Monomorphic_Monad-2017-05-11.tar.gz
	afp-Monomorphic_Monad-2017-10-10.tar.gz
	afp-Monomorphic_Monad-2018-08-16.tar.gz
	+afp-Monomorphic_Monad-2019-06-11.tar.gz
	afp-MSO_Regex_Equivalence-2014-06-12.tar.gz
	afp-MSO_Regex_Equivalence-2014-08-28.tar.gz
	afp-MSO_Regex_Equivalence-2015-05-27.tar.gz
	afp-MSO_Regex_Equivalence-2016-02-22.tar.gz
	afp-MSO_Regex_Equivalence-2016-12-17.tar.gz
	afp-MSO_Regex_Equivalence-2017-10-10.tar.gz
	afp-MSO_Regex_Equivalence-2018-08-16.tar.gz
	+afp-MSO_Regex_Equivalence-2019-06-11.tar.gz
	afp-MuchAdoAboutTwo-2007-11-27.tar.gz
	afp-MuchAdoAboutTwo-2008-06-10.tar.gz
	afp-MuchAdoAboutTwo-2009-04-29.tar.gz
	afp-MuchAdoAboutTwo-2009-12-12.tar.gz
	afp-MuchAdoAboutTwo-2010-07-01.tar.gz
	afp-MuchAdoAboutTwo-2011-02-11.tar.gz
	afp-MuchAdoAboutTwo-2011-10-11.tar.gz
	afp-MuchAdoAboutTwo-2012-05-24.tar.gz
	afp-MuchAdoAboutTwo-2013-02-16.tar.gz
	afp-MuchAdoAboutTwo-2013-03-02.tar.gz
	afp-MuchAdoAboutTwo-2013-11-17.tar.gz
	afp-MuchAdoAboutTwo-2013-12-11.tar.gz
	afp-MuchAdoAboutTwo-2014-08-28.tar.gz
	afp-MuchAdoAboutTwo-2015-05-27.tar.gz
	afp-MuchAdoAboutTwo-2016-02-22.tar.gz
	afp-MuchAdoAboutTwo-2016-12-17.tar.gz
	afp-MuchAdoAboutTwo-2017-10-10.tar.gz
	afp-MuchAdoAboutTwo-2018-08-16.tar.gz
	+afp-MuchAdoAboutTwo-2019-06-11.tar.gz
	afp-Multi_Party_Computation-2019-05-10.tar.gz
	+afp-Multi_Party_Computation-2019-06-11.tar.gz
	afp-Multirelations-2015-06-13.tar.gz
	afp-Multirelations-2016-02-22.tar.gz
	afp-Multirelations-2016-12-17.tar.gz
	afp-Multirelations-2017-10-10.tar.gz
	afp-Multirelations-2018-08-16.tar.gz
	+afp-Multirelations-2019-06-11.tar.gz
	afp-Myhill-Nerode-2011-10-11.tar.gz
	afp-Myhill-Nerode-2012-05-24.tar.gz
	afp-Myhill-Nerode-2013-02-16.tar.gz
	afp-Myhill-Nerode-2013-03-02.tar.gz
	afp-Myhill-Nerode-2013-11-17.tar.gz
	afp-Myhill-Nerode-2013-12-11.tar.gz
	afp-Myhill-Nerode-2014-08-28.tar.gz
	afp-Myhill-Nerode-2015-05-27.tar.gz
	afp-Myhill-Nerode-2016-02-22.tar.gz
	afp-Myhill-Nerode-2016-12-17.tar.gz
	afp-Myhill-Nerode-2017-10-10.tar.gz
	afp-Myhill-Nerode-2018-08-16.tar.gz
	+afp-Myhill-Nerode-2019-06-11.tar.gz
	afp-Name_Carrying_Type_Inference-2017-07-15.tar.gz
	afp-Name_Carrying_Type_Inference-2017-10-10.tar.gz
	afp-Name_Carrying_Type_Inference-2018-08-16.tar.gz
	+afp-Name_Carrying_Type_Inference-2019-06-11.tar.gz
	afp-Nat-Interval-Logic-2011-02-24.tar.gz
	afp-Nat-Interval-Logic-2011-10-11.tar.gz
	afp-Nat-Interval-Logic-2012-05-24.tar.gz
	afp-Nat-Interval-Logic-2013-02-16.tar.gz
	afp-Nat-Interval-Logic-2013-11-17.tar.gz
	afp-Nat-Interval-Logic-2013-12-11.tar.gz
	afp-Nat-Interval-Logic-2014-08-28.tar.gz
	afp-Nat-Interval-Logic-2015-05-27.tar.gz
	afp-Nat-Interval-Logic-2016-02-22.tar.gz
	afp-Nat-Interval-Logic-2016-12-17.tar.gz
	afp-Nat-Interval-Logic-2017-10-10.tar.gz
	afp-Nat-Interval-Logic-2018-08-16.tar.gz
	+afp-Nat-Interval-Logic-2019-06-11.tar.gz
	afp-Native_Word-2013-11-17.tar.gz
	afp-Native_Word-2013-12-11.tar.gz
	afp-Native_Word-2014-08-28.tar.gz
	afp-Native_Word-2015-05-27.tar.gz
	afp-Native_Word-2016-02-22.tar.gz
	afp-Native_Word-2016-12-17.tar.gz
	afp-Native_Word-2017-10-10.tar.gz
	afp-Native_Word-2018-08-16.tar.gz
	+afp-Native_Word-2019-06-11.tar.gz
	afp-Nested_Multisets_Ordinals-2016-12-17.tar.gz
	afp-Nested_Multisets_Ordinals-2017-10-10.tar.gz
	afp-Nested_Multisets_Ordinals-2018-08-16.tar.gz
	+afp-Nested_Multisets_Ordinals-2019-06-11.tar.gz
	afp-Network_Security_Policy_Verification-2014-07-09.tar.gz
	afp-Network_Security_Policy_Verification-2014-08-28.tar.gz
	afp-Network_Security_Policy_Verification-2015-05-27.tar.gz
	afp-Network_Security_Policy_Verification-2016-02-22.tar.gz
	afp-Network_Security_Policy_Verification-2016-12-17.tar.gz
	afp-Network_Security_Policy_Verification-2017-10-10.tar.gz
	afp-Network_Security_Policy_Verification-2018-08-16.tar.gz
	+afp-Network_Security_Policy_Verification-2019-06-11.tar.gz
	afp-Neumann_Morgenstern_Utility-2018-07-04.tar.gz
	afp-Neumann_Morgenstern_Utility-2018-08-16.tar.gz
	+afp-Neumann_Morgenstern_Utility-2019-06-11.tar.gz
	afp-No_FTL_observers-2016-04-28.tar.gz
	afp-No_FTL_observers-2016-12-17.tar.gz
	afp-No_FTL_observers-2017-10-10.tar.gz
	afp-No_FTL_observers-2018-08-16.tar.gz
	+afp-No_FTL_observers-2019-06-11.tar.gz
	afp-Nominal2-2013-02-24.tar.gz
	afp-Nominal2-2013-11-17.tar.gz
	afp-Nominal2-2016-04-24.tar.gz
	afp-Nominal2-2016-12-17.tar.gz
	afp-Nominal2-2017-10-10.tar.gz
	afp-Nominal2-2018-08-16.tar.gz
	+afp-Nominal2-2019-06-11.tar.gz
	afp-Noninterference_Concurrent_Composition-2016-06-13.tar.gz
	afp-Noninterference_Concurrent_Composition-2016-12-17.tar.gz
	afp-Noninterference_Concurrent_Composition-2017-10-10.tar.gz
	afp-Noninterference_Concurrent_Composition-2018-08-16.tar.gz
	+afp-Noninterference_Concurrent_Composition-2019-06-11.tar.gz
	afp-Noninterference_CSP-2014-05-24.tar.gz
	afp-Noninterference_CSP-2014-08-28.tar.gz
	afp-Noninterference_CSP-2015-05-27.tar.gz
	afp-Noninterference_CSP-2015-06-13.tar.gz
	afp-Noninterference_CSP-2016-02-22.tar.gz
	afp-Noninterference_CSP-2016-12-17.tar.gz
	afp-Noninterference_CSP-2017-10-10.tar.gz
	afp-Noninterference_CSP-2018-08-16.tar.gz
	+afp-Noninterference_CSP-2019-06-11.tar.gz
	afp-Noninterference_Generic_Unwinding-2015-06-13.tar.gz
	afp-Noninterference_Generic_Unwinding-2016-02-22.tar.gz
	afp-Noninterference_Generic_Unwinding-2016-12-17.tar.gz
	afp-Noninterference_Generic_Unwinding-2017-10-10.tar.gz
	afp-Noninterference_Generic_Unwinding-2018-08-16.tar.gz
	+afp-Noninterference_Generic_Unwinding-2019-06-11.tar.gz
	afp-Noninterference_Inductive_Unwinding-2015-08-19.tar.gz
	afp-Noninterference_Inductive_Unwinding-2016-02-22.tar.gz
	afp-Noninterference_Inductive_Unwinding-2016-12-17.tar.gz
	afp-Noninterference_Inductive_Unwinding-2017-10-10.tar.gz
	afp-Noninterference_Inductive_Unwinding-2018-08-16.tar.gz
	+afp-Noninterference_Inductive_Unwinding-2019-06-11.tar.gz
	afp-Noninterference_Ipurge_Unwinding-2015-06-13.tar.gz
	afp-Noninterference_Ipurge_Unwinding-2016-02-22.tar.gz
	afp-Noninterference_Ipurge_Unwinding-2016-12-17.tar.gz
	afp-Noninterference_Ipurge_Unwinding-2017-10-10.tar.gz
	afp-Noninterference_Ipurge_Unwinding-2018-08-16.tar.gz
	+afp-Noninterference_Ipurge_Unwinding-2019-06-11.tar.gz
	afp-Noninterference_Sequential_Composition-2016-04-26.tar.gz
	afp-Noninterference_Sequential_Composition-2016-12-17.tar.gz
	afp-Noninterference_Sequential_Composition-2017-10-10.tar.gz
	afp-Noninterference_Sequential_Composition-2018-08-16.tar.gz
	+afp-Noninterference_Sequential_Composition-2019-06-11.tar.gz
	afp-NormByEval-2008-02-18.tar.gz
	afp-NormByEval-2008-02-22.tar.gz
	afp-NormByEval-2008-06-10.tar.gz
	afp-NormByEval-2009-04-29.tar.gz
	afp-NormByEval-2009-12-12.tar.gz
	afp-NormByEval-2010-07-01.tar.gz
	afp-NormByEval-2011-02-11.tar.gz
	afp-NormByEval-2011-10-11.tar.gz
	afp-NormByEval-2012-05-24.tar.gz
	afp-NormByEval-2013-02-16.tar.gz
	afp-NormByEval-2013-11-17.tar.gz
	afp-NormByEval-2013-12-11.tar.gz
	afp-NormByEval-2014-08-28.tar.gz
	afp-NormByEval-2015-05-27.tar.gz
	afp-NormByEval-2016-02-22.tar.gz
	afp-NormByEval-2016-12-17.tar.gz
	afp-NormByEval-2017-10-10.tar.gz
	afp-NormByEval-2018-08-16.tar.gz
	+afp-NormByEval-2019-06-11.tar.gz
	afp-Octonions-2018-09-16.tar.gz
	+afp-Octonions-2019-06-11.tar.gz
	afp-Open_Induction-2013-02-16.tar.gz
	afp-Open_Induction-2013-03-02.tar.gz
	afp-Open_Induction-2013-11-17.tar.gz
	afp-Open_Induction-2013-12-11.tar.gz
	afp-Open_Induction-2014-08-28.tar.gz
	afp-Open_Induction-2015-05-27.tar.gz
	afp-Open_Induction-2016-02-22.tar.gz
	afp-Open_Induction-2016-12-17.tar.gz
	afp-Open_Induction-2017-10-10.tar.gz
	afp-Open_Induction-2018-08-16.tar.gz
	+afp-Open_Induction-2019-06-11.tar.gz
	afp-OpSets-2018-05-25.tar.gz
	afp-OpSets-2018-08-16.tar.gz
	+afp-OpSets-2019-06-11.tar.gz
	afp-Optics-2017-06-01.tar.gz
	afp-Optics-2017-10-10.tar.gz
	afp-Optics-2018-08-16.tar.gz
	+afp-Optics-2019-06-11.tar.gz
	afp-Optimal_BST-2018-05-29.tar.gz
	afp-Optimal_BST-2018-08-16.tar.gz
	+afp-Optimal_BST-2019-06-11.tar.gz
	afp-Orbit_Stabiliser-2017-08-23.tar.gz
	afp-Orbit_Stabiliser-2017-10-10.tar.gz
	afp-Orbit_Stabiliser-2018-08-16.tar.gz
	+afp-Orbit_Stabiliser-2019-06-11.tar.gz
	afp-Ordered_Resolution_Prover-2018-01-22.tar.gz
	afp-Ordered_Resolution_Prover-2018-08-16.tar.gz
	+afp-Ordered_Resolution_Prover-2019-06-11.tar.gz
	afp-Order_Lattice_Props-2018-12-19.tar.gz
	+afp-Order_Lattice_Props-2019-06-11.tar.gz
	afp-Ordinal-2005-11-16.tar.gz
	afp-Ordinal-2007-11-27.tar.gz
	afp-Ordinal-2008-06-10.tar.gz
	afp-Ordinal-2009-04-29.tar.gz
	afp-Ordinal-2009-12-12.tar.gz
	afp-Ordinal-2010-07-01.tar.gz
	afp-Ordinal-2011-02-11.tar.gz
	afp-Ordinal-2011-10-11.tar.gz
	afp-Ordinal-2012-05-24.tar.gz
	afp-Ordinal-2013-02-16.tar.gz
	afp-Ordinal-2013-11-17.tar.gz
	afp-Ordinal-2013-12-11.tar.gz
	afp-Ordinal-2014-08-28.tar.gz
	afp-Ordinal-2015-05-27.tar.gz
	afp-Ordinal-2016-02-22.tar.gz
	afp-Ordinal-2016-12-17.tar.gz
	afp-Ordinal-2017-10-10.tar.gz
	afp-Ordinal-2018-08-16.tar.gz
	+afp-Ordinal-2019-06-11.tar.gz
	afp-Ordinals_and_Cardinals-2009-09-07.tar.gz
	afp-Ordinals_and_Cardinals-2009-09-09.tar.gz
	afp-Ordinals_and_Cardinals-2009-12-12.tar.gz
	afp-Ordinals_and_Cardinals-2010-07-01.tar.gz
	afp-Ordinals_and_Cardinals-2011-02-11.tar.gz
	afp-Ordinals_and_Cardinals-2011-10-11.tar.gz
	afp-Ordinals_and_Cardinals-2012-05-24.tar.gz
	afp-Ordinals_and_Cardinals-2013-02-16.tar.gz
	afp-Ordinals_and_Cardinals-2013-11-17.tar.gz
	afp-Ordinals_and_Cardinals-2013-12-11.tar.gz
	afp-Ordinals_and_Cardinals-2014-08-28.tar.gz
	afp-Ordinals_and_Cardinals-2015-05-27.tar.gz
	afp-Ordinals_and_Cardinals-2016-02-22.tar.gz
	afp-Ordinals_and_Cardinals-2016-12-17.tar.gz
	afp-Ordinals_and_Cardinals-2017-10-10.tar.gz
	afp-Ordinals_and_Cardinals-2018-08-16.tar.gz
	+afp-Ordinals_and_Cardinals-2019-06-11.tar.gz
	afp-Ordinary_Differential_Equations-2012-05-24.tar.gz
	afp-Ordinary_Differential_Equations-2013-02-16.tar.gz
	afp-Ordinary_Differential_Equations-2013-11-17.tar.gz
	afp-Ordinary_Differential_Equations-2013-12-11.tar.gz
	afp-Ordinary_Differential_Equations-2014-08-28.tar.gz
	afp-Ordinary_Differential_Equations-2015-05-27.tar.gz
	afp-Ordinary_Differential_Equations-2016-02-22.tar.gz
	afp-Ordinary_Differential_Equations-2016-12-17.tar.gz
	afp-Ordinary_Differential_Equations-2017-10-10.tar.gz
	afp-Ordinary_Differential_Equations-2018-08-16.tar.gz
	+afp-Ordinary_Differential_Equations-2019-06-11.tar.gz
	afp-Pairing_Heap-2016-12-17.tar.gz
	afp-Pairing_Heap-2017-10-10.tar.gz
	afp-Pairing_Heap-2018-08-16.tar.gz
	+afp-Pairing_Heap-2019-06-11.tar.gz
	afp-Paraconsistency-2016-12-08.tar.gz
	afp-Paraconsistency-2016-12-17.tar.gz
	afp-Paraconsistency-2017-10-10.tar.gz
	afp-Paraconsistency-2018-08-16.tar.gz
	+afp-Paraconsistency-2019-06-11.tar.gz
	afp-Parity_Game-2015-11-02.tar.gz
	afp-Parity_Game-2016-02-22.tar.gz
	afp-Parity_Game-2016-12-17.tar.gz
	afp-Parity_Game-2017-10-10.tar.gz
	afp-Parity_Game-2018-08-16.tar.gz
	+afp-Parity_Game-2019-06-11.tar.gz
	afp-Partial_Function_MR-2014-02-19.tar.gz
	afp-Partial_Function_MR-2014-08-28.tar.gz
	afp-Partial_Function_MR-2015-05-27.tar.gz
	afp-Partial_Function_MR-2016-02-22.tar.gz
	afp-Partial_Function_MR-2016-12-17.tar.gz
	afp-Partial_Function_MR-2017-10-10.tar.gz
	afp-Partial_Function_MR-2018-08-16.tar.gz
	+afp-Partial_Function_MR-2019-06-11.tar.gz
	afp-Partial_Order_Reduction-2018-08-16.tar.gz
	+afp-Partial_Order_Reduction-2019-06-11.tar.gz
	afp-Password_Authentication_Protocol-2017-01-06.tar.gz
	afp-Password_Authentication_Protocol-2017-10-10.tar.gz
	afp-Password_Authentication_Protocol-2018-08-16.tar.gz
	+afp-Password_Authentication_Protocol-2019-06-11.tar.gz
	afp-PCF-2012-07-03.tar.gz
	afp-PCF-2013-02-16.tar.gz
	afp-PCF-2013-11-17.tar.gz
	afp-PCF-2013-12-11.tar.gz
	afp-PCF-2014-08-28.tar.gz
	afp-PCF-2015-05-27.tar.gz
	afp-PCF-2016-02-22.tar.gz
	afp-PCF-2016-12-17.tar.gz
	afp-PCF-2017-10-10.tar.gz
	afp-PCF-2018-08-16.tar.gz
	+afp-PCF-2019-06-11.tar.gz
	afp-Pell-2018-06-25.tar.gz
	afp-Pell-2018-08-16.tar.gz
	+afp-Pell-2019-06-11.tar.gz
	afp-Perfect-Number-Thm-2009-11-24.tar.gz
	afp-Perfect-Number-Thm-2009-12-12.tar.gz
	afp-Perfect-Number-Thm-2010-07-01.tar.gz
	afp-Perfect-Number-Thm-2011-02-11.tar.gz
	afp-Perfect-Number-Thm-2011-10-11.tar.gz
	afp-Perfect-Number-Thm-2012-05-24.tar.gz
	afp-Perfect-Number-Thm-2013-02-16.tar.gz
	afp-Perfect-Number-Thm-2013-11-17.tar.gz
	afp-Perfect-Number-Thm-2013-12-11.tar.gz
	afp-Perfect-Number-Thm-2014-08-28.tar.gz
	afp-Perfect-Number-Thm-2015-05-27.tar.gz
	afp-Perfect-Number-Thm-2016-02-22.tar.gz
	afp-Perfect-Number-Thm-2016-12-17.tar.gz
	afp-Perfect-Number-Thm-2017-10-10.tar.gz
	afp-Perfect-Number-Thm-2018-08-16.tar.gz
	+afp-Perfect-Number-Thm-2019-06-11.tar.gz
	afp-Perron_Frobenius-2016-05-20.tar.gz
	afp-Perron_Frobenius-2016-12-17.tar.gz
	afp-Perron_Frobenius-2017-10-10.tar.gz
	afp-Perron_Frobenius-2017-10-18.tar.gz
	afp-Perron_Frobenius-2018-08-16.tar.gz
	+afp-Perron_Frobenius-2019-06-11.tar.gz
	afp-pGCL-2014-07-13.tar.gz
	afp-pGCL-2014-08-28.tar.gz
	afp-pGCL-2015-05-27.tar.gz
	afp-pGCL-2016-02-22.tar.gz
	afp-pGCL-2016-12-17.tar.gz
	afp-pGCL-2017-10-10.tar.gz
	afp-pGCL-2018-08-16.tar.gz
	+afp-pGCL-2019-06-11.tar.gz
	afp-Pi_Calculus-2012-06-14.tar.gz
	afp-Pi_Calculus-2013-02-16.tar.gz
	afp-Pi_Calculus-2013-11-17.tar.gz
	afp-Pi_Calculus-2013-12-11.tar.gz
	afp-Pi_Calculus-2014-08-28.tar.gz
	afp-Pi_Calculus-2015-05-27.tar.gz
	afp-Pi_Calculus-2016-02-22.tar.gz
	afp-Pi_Calculus-2016-12-17.tar.gz
	afp-Pi_Calculus-2017-10-10.tar.gz
	afp-Pi_Calculus-2018-08-16.tar.gz
	+afp-Pi_Calculus-2019-06-11.tar.gz
	afp-Pi_Transcendental-2018-10-02.tar.gz
	+afp-Pi_Transcendental-2019-06-11.tar.gz
	afp-Planarity_Certificates-2016-02-22.tar.gz
	afp-Planarity_Certificates-2016-12-17.tar.gz
	afp-Planarity_Certificates-2017-10-10.tar.gz
	afp-Planarity_Certificates-2018-08-16.tar.gz
	+afp-Planarity_Certificates-2019-06-11.tar.gz
	afp-PLM-2017-09-19.tar.gz
	afp-PLM-2017-10-10.tar.gz
	afp-PLM-2018-08-16.tar.gz
	+afp-PLM-2019-06-11.tar.gz
	afp-Polynomial_Factorization-2016-02-22.tar.gz
	afp-Polynomial_Factorization-2016-12-17.tar.gz
	afp-Polynomial_Factorization-2017-10-10.tar.gz
	afp-Polynomial_Factorization-2018-08-16.tar.gz
	+afp-Polynomial_Factorization-2019-06-11.tar.gz
	afp-Polynomial_Interpolation-2016-02-22.tar.gz
	afp-Polynomial_Interpolation-2016-12-17.tar.gz
	afp-Polynomial_Interpolation-2017-10-10.tar.gz
	afp-Polynomial_Interpolation-2018-08-16.tar.gz
	+afp-Polynomial_Interpolation-2019-06-11.tar.gz
	afp-Polynomials-2010-08-11.tar.gz
	afp-Polynomials-2011-02-11.tar.gz
	afp-Polynomials-2011-10-11.tar.gz
	afp-Polynomials-2012-05-24.tar.gz
	afp-Polynomials-2013-02-16.tar.gz
	afp-Polynomials-2013-11-17.tar.gz
	afp-Polynomials-2013-12-11.tar.gz
	afp-Polynomials-2014-08-28.tar.gz
	afp-Polynomials-2015-05-27.tar.gz
	afp-Polynomials-2016-02-22.tar.gz
	afp-Polynomials-2016-12-17.tar.gz
	afp-Polynomials-2017-10-10.tar.gz
	afp-Polynomials-2018-08-16.tar.gz
	+afp-Polynomials-2019-06-11.tar.gz
	afp-POPLmark-deBruijn-2007-11-27.tar.gz
	afp-POPLmark-deBruijn-2008-06-10.tar.gz
	afp-POPLmark-deBruijn-2009-04-29.tar.gz
	afp-POPLmark-deBruijn-2009-12-12.tar.gz
	afp-POPLmark-deBruijn-2010-07-01.tar.gz
	afp-POPLmark-deBruijn-2011-02-11.tar.gz
	afp-POPLmark-deBruijn-2011-10-11.tar.gz
	afp-POPLmark-deBruijn-2012-05-24.tar.gz
	afp-POPLmark-deBruijn-2013-02-16.tar.gz
	afp-POPLmark-deBruijn-2013-03-02.tar.gz
	afp-POPLmark-deBruijn-2013-11-17.tar.gz
	afp-POPLmark-deBruijn-2013-12-11.tar.gz
	afp-POPLmark-deBruijn-2014-08-28.tar.gz
	afp-POPLmark-deBruijn-2015-05-27.tar.gz
	afp-POPLmark-deBruijn-2016-02-22.tar.gz
	afp-POPLmark-deBruijn-2016-12-17.tar.gz
	afp-POPLmark-deBruijn-2017-10-10.tar.gz
	afp-POPLmark-deBruijn-2018-08-16.tar.gz
	+afp-POPLmark-deBruijn-2019-06-11.tar.gz
	afp-Pop_Refinement-2014-07-03.tar.gz
	afp-Pop_Refinement-2014-08-28.tar.gz
	afp-Pop_Refinement-2015-05-27.tar.gz
	afp-Pop_Refinement-2016-02-22.tar.gz
	afp-Pop_Refinement-2016-12-17.tar.gz
	afp-Pop_Refinement-2017-10-10.tar.gz
	afp-Pop_Refinement-2018-08-16.tar.gz
	+afp-Pop_Refinement-2019-06-11.tar.gz
	afp-Posix-Lexing-2016-05-24.tar.gz
	afp-Posix-Lexing-2016-12-17.tar.gz
	afp-Posix-Lexing-2017-10-10.tar.gz
	afp-Posix-Lexing-2018-08-16.tar.gz
	+afp-Posix-Lexing-2019-06-11.tar.gz
	afp-Possibilistic_Noninterference-2012-09-10.tar.gz
	afp-Possibilistic_Noninterference-2013-02-16.tar.gz
	afp-Possibilistic_Noninterference-2013-11-17.tar.gz
	afp-Possibilistic_Noninterference-2013-12-11.tar.gz
	afp-Possibilistic_Noninterference-2014-08-28.tar.gz
	afp-Possibilistic_Noninterference-2015-05-27.tar.gz
	afp-Possibilistic_Noninterference-2016-02-22.tar.gz
	afp-Possibilistic_Noninterference-2016-12-17.tar.gz
	afp-Possibilistic_Noninterference-2017-10-10.tar.gz
	afp-Possibilistic_Noninterference-2018-08-16.tar.gz
	+afp-Possibilistic_Noninterference-2019-06-11.tar.gz
	afp-Pratt_Certificate-2013-07-29.tar.gz
	afp-Pratt_Certificate-2013-11-17.tar.gz
	afp-Pratt_Certificate-2013-12-11.tar.gz
	afp-Pratt_Certificate-2014-08-28.tar.gz
	afp-Pratt_Certificate-2015-05-27.tar.gz
	afp-Pratt_Certificate-2016-02-22.tar.gz
	afp-Pratt_Certificate-2016-12-17.tar.gz
	afp-Pratt_Certificate-2017-10-10.tar.gz
	afp-Pratt_Certificate-2018-08-16.tar.gz
	+afp-Pratt_Certificate-2019-06-11.tar.gz
	afp-Presburger-Automata-2009-12-12.tar.gz
	afp-Presburger-Automata-2010-07-01.tar.gz
	afp-Presburger-Automata-2011-02-11.tar.gz
	afp-Presburger-Automata-2011-10-11.tar.gz
	afp-Presburger-Automata-2012-05-24.tar.gz
	afp-Presburger-Automata-2013-02-16.tar.gz
	afp-Presburger-Automata-2013-03-02.tar.gz
	afp-Presburger-Automata-2013-11-17.tar.gz
	afp-Presburger-Automata-2013-12-11.tar.gz
	afp-Presburger-Automata-2014-08-28.tar.gz
	afp-Presburger-Automata-2015-05-27.tar.gz
	afp-Presburger-Automata-2016-02-22.tar.gz
	afp-Presburger-Automata-2016-12-17.tar.gz
	afp-Presburger-Automata-2017-10-10.tar.gz
	afp-Presburger-Automata-2018-08-16.tar.gz
	+afp-Presburger-Automata-2019-06-11.tar.gz
	afp-Prime_Distribution_Elementary-2019-02-22.tar.gz
	+afp-Prime_Distribution_Elementary-2019-06-11.tar.gz
	afp-Prime_Harmonic_Series-2016-01-05.tar.gz
	afp-Prime_Harmonic_Series-2016-02-22.tar.gz
	afp-Prime_Harmonic_Series-2016-12-17.tar.gz
	afp-Prime_Harmonic_Series-2017-10-10.tar.gz
	afp-Prime_Harmonic_Series-2018-08-16.tar.gz
	+afp-Prime_Harmonic_Series-2019-06-11.tar.gz
	afp-Prime_Number_Theorem-2018-09-20.tar.gz
	+afp-Prime_Number_Theorem-2019-06-11.tar.gz
	afp-Priority_Queue_Braun-2014-09-04.tar.gz
	afp-Priority_Queue_Braun-2015-05-27.tar.gz
	afp-Priority_Queue_Braun-2016-02-22.tar.gz
	afp-Priority_Queue_Braun-2016-12-17.tar.gz
	afp-Priority_Queue_Braun-2017-10-10.tar.gz
	afp-Priority_Queue_Braun-2018-08-16.tar.gz
	+afp-Priority_Queue_Braun-2019-06-11.tar.gz
	afp-Probabilistic_Noninterference-2014-03-16.tar.gz
	afp-Probabilistic_Noninterference-2014-08-28.tar.gz
	afp-Probabilistic_Noninterference-2015-05-27.tar.gz
	afp-Probabilistic_Noninterference-2016-02-22.tar.gz
	afp-Probabilistic_Noninterference-2016-12-17.tar.gz
	afp-Probabilistic_Noninterference-2017-10-10.tar.gz
	afp-Probabilistic_Noninterference-2018-08-16.tar.gz
	+afp-Probabilistic_Noninterference-2019-06-11.tar.gz
	afp-Probabilistic_Prime_Tests-2019-02-15.tar.gz
	+afp-Probabilistic_Prime_Tests-2019-06-11.tar.gz
	afp-Probabilistic_System_Zoo-2015-05-28.tar.gz
	afp-Probabilistic_System_Zoo-2016-02-22.tar.gz
	afp-Probabilistic_System_Zoo-2016-12-17.tar.gz
	afp-Probabilistic_System_Zoo-2017-10-10.tar.gz
	afp-Probabilistic_System_Zoo-2018-08-16.tar.gz
	+afp-Probabilistic_System_Zoo-2019-06-11.tar.gz
	afp-Probabilistic_Timed_Automata-2018-05-25.tar.gz
	afp-Probabilistic_Timed_Automata-2018-08-16.tar.gz
	+afp-Probabilistic_Timed_Automata-2019-06-11.tar.gz
	afp-Probabilistic_While-2017-05-11.tar.gz
	afp-Probabilistic_While-2017-10-10.tar.gz
	afp-Probabilistic_While-2018-08-16.tar.gz
	+afp-Probabilistic_While-2019-06-11.tar.gz
	afp-Program-Conflict-Analysis-2007-12-20.tar.gz
	afp-Program-Conflict-Analysis-2008-06-10.tar.gz
	afp-Program-Conflict-Analysis-2009-04-29.tar.gz
	afp-Program-Conflict-Analysis-2009-12-12.tar.gz
	afp-Program-Conflict-Analysis-2010-07-01.tar.gz
	afp-Program-Conflict-Analysis-2011-02-11.tar.gz
	afp-Program-Conflict-Analysis-2011-10-11.tar.gz
	afp-Program-Conflict-Analysis-2012-05-24.tar.gz
	afp-Program-Conflict-Analysis-2013-02-16.tar.gz
	afp-Program-Conflict-Analysis-2013-03-02.tar.gz
	afp-Program-Conflict-Analysis-2013-11-17.tar.gz
	afp-Program-Conflict-Analysis-2013-12-11.tar.gz
	afp-Program-Conflict-Analysis-2014-08-28.tar.gz
	afp-Program-Conflict-Analysis-2015-05-27.tar.gz
	afp-Program-Conflict-Analysis-2016-02-22.tar.gz
	afp-Program-Conflict-Analysis-2016-12-17.tar.gz
	afp-Program-Conflict-Analysis-2017-10-10.tar.gz
	afp-Program-Conflict-Analysis-2018-08-16.tar.gz
	+afp-Program-Conflict-Analysis-2019-06-11.tar.gz
	afp-Projective_Geometry-2018-06-15.tar.gz
	afp-Projective_Geometry-2018-08-16.tar.gz
	+afp-Projective_Geometry-2019-06-11.tar.gz
	afp-Promela-2014-05-29.tar.gz
	afp-Promela-2014-08-28.tar.gz
	afp-Promela-2015-05-27.tar.gz
	afp-Promela-2016-02-22.tar.gz
	afp-Promela-2016-12-17.tar.gz
	afp-Promela-2017-10-10.tar.gz
	afp-Promela-2018-08-16.tar.gz
	+afp-Promela-2019-06-11.tar.gz
	afp-Proof_Strategy_Language-2016-12-21.tar.gz
	afp-Proof_Strategy_Language-2017-10-10.tar.gz
	afp-Proof_Strategy_Language-2018-08-16.tar.gz
	+afp-Proof_Strategy_Language-2019-06-11.tar.gz
	afp-Propositional_Proof_Systems-2017-06-22.tar.gz
	afp-Propositional_Proof_Systems-2017-10-10.tar.gz
	afp-Propositional_Proof_Systems-2018-08-16.tar.gz
	+afp-Propositional_Proof_Systems-2019-06-11.tar.gz
	afp-PropResPI-2016-03-11.tar.gz
	afp-PropResPI-2016-12-17.tar.gz
	afp-PropResPI-2017-10-10.tar.gz
	afp-PropResPI-2018-08-16.tar.gz
	+afp-PropResPI-2019-06-11.tar.gz
	afp-Prpu_Maxflow-2017-06-02.tar.gz
	afp-Prpu_Maxflow-2017-10-10.tar.gz
	afp-Prpu_Maxflow-2018-08-16.tar.gz
	+afp-Prpu_Maxflow-2019-06-11.tar.gz
	afp-PSemigroupsConvolution-2017-06-13.tar.gz
	afp-PSemigroupsConvolution-2017-10-10.tar.gz
	afp-PSemigroupsConvolution-2018-08-16.tar.gz
	+afp-PSemigroupsConvolution-2019-06-11.tar.gz
	afp-PseudoHoops-2011-09-27.tar.gz
	afp-PseudoHoops-2011-10-11.tar.gz
	afp-PseudoHoops-2012-05-24.tar.gz
	afp-PseudoHoops-2013-02-16.tar.gz
	afp-PseudoHoops-2013-11-17.tar.gz
	afp-PseudoHoops-2013-12-11.tar.gz
	afp-PseudoHoops-2014-08-28.tar.gz
	afp-PseudoHoops-2015-05-27.tar.gz
	afp-PseudoHoops-2016-02-22.tar.gz
	afp-PseudoHoops-2016-12-17.tar.gz
	afp-PseudoHoops-2017-10-10.tar.gz
	afp-PseudoHoops-2018-08-16.tar.gz
	+afp-PseudoHoops-2019-06-11.tar.gz
	afp-Psi_Calculi-2012-06-14.tar.gz
	afp-Psi_Calculi-2013-02-16.tar.gz
	afp-Psi_Calculi-2013-11-17.tar.gz
	afp-Psi_Calculi-2013-12-11.tar.gz
	afp-Psi_Calculi-2014-08-28.tar.gz
	afp-Psi_Calculi-2015-05-27.tar.gz
	afp-Psi_Calculi-2016-02-22.tar.gz
	afp-Psi_Calculi-2016-12-17.tar.gz
	afp-Psi_Calculi-2017-10-10.tar.gz
	afp-Psi_Calculi-2018-08-16.tar.gz
	+afp-Psi_Calculi-2019-06-11.tar.gz
	afp-Ptolemys_Theorem-2016-08-08.tar.gz
	afp-Ptolemys_Theorem-2016-12-17.tar.gz
	afp-Ptolemys_Theorem-2017-10-10.tar.gz
	afp-Ptolemys_Theorem-2018-08-16.tar.gz
	+afp-Ptolemys_Theorem-2019-06-11.tar.gz
	afp-QHLProver-2019-03-25.tar.gz
	+afp-QHLProver-2019-06-11.tar.gz
	afp-QR_Decomposition-2015-02-13.tar.gz
	afp-QR_Decomposition-2015-05-27.tar.gz
	afp-QR_Decomposition-2016-02-22.tar.gz
	afp-QR_Decomposition-2016-12-17.tar.gz
	afp-QR_Decomposition-2017-10-10.tar.gz
	afp-QR_Decomposition-2018-08-16.tar.gz
	+afp-QR_Decomposition-2019-06-11.tar.gz
	afp-Quantales-2018-12-19.tar.gz
	+afp-Quantales-2019-06-11.tar.gz
	afp-Quaternions-2018-09-07.tar.gz
	+afp-Quaternions-2019-06-11.tar.gz
	afp-Quick_Sort_Cost-2017-03-16.tar.gz
	afp-Quick_Sort_Cost-2017-10-10.tar.gz
	afp-Quick_Sort_Cost-2018-08-16.tar.gz
	+afp-Quick_Sort_Cost-2019-06-11.tar.gz
	afp-Ramsey-Infinite-2004-09-20.tar.gz
	afp-Ramsey-Infinite-2004-09-21.tar.gz
	afp-Ramsey-Infinite-2005-10-14.tar.gz
	afp-Ramsey-Infinite-2007-11-27.tar.gz
	afp-Ramsey-Infinite-2008-06-10.tar.gz
	afp-Ramsey-Infinite-2009-04-29.tar.gz
	afp-Ramsey-Infinite-2009-12-12.tar.gz
	afp-Ramsey-Infinite-2010-07-01.tar.gz
	afp-Ramsey-Infinite-2011-02-11.tar.gz
	afp-Ramsey-Infinite-2011-10-11.tar.gz
	afp-Ramsey-Infinite-2012-05-24.tar.gz
	afp-Ramsey-Infinite-2013-02-16.tar.gz
	afp-Ramsey-Infinite-2013-11-17.tar.gz
	afp-Ramsey-Infinite-2013-12-11.tar.gz
	afp-Ramsey-Infinite-2014-08-28.tar.gz
	afp-Ramsey-Infinite-2015-05-27.tar.gz
	afp-Ramsey-Infinite-2016-02-22.tar.gz
	afp-Ramsey-Infinite-2016-12-17.tar.gz
	afp-Ramsey-Infinite-2017-10-10.tar.gz
	afp-Ramsey-Infinite-2018-08-16.tar.gz
	+afp-Ramsey-Infinite-2019-06-11.tar.gz
	afp-Random_BSTs-2017-04-04.tar.gz
	afp-Random_BSTs-2017-10-10.tar.gz
	afp-Random_BSTs-2018-08-16.tar.gz
	+afp-Random_BSTs-2019-06-11.tar.gz
	afp-Random_Graph_Subgraph_Threshold-2014-02-14.tar.gz
	afp-Random_Graph_Subgraph_Threshold-2014-08-28.tar.gz
	afp-Random_Graph_Subgraph_Threshold-2015-05-27.tar.gz
	afp-Random_Graph_Subgraph_Threshold-2016-02-22.tar.gz
	afp-Random_Graph_Subgraph_Threshold-2016-12-17.tar.gz
	afp-Random_Graph_Subgraph_Threshold-2017-10-10.tar.gz
	afp-Random_Graph_Subgraph_Threshold-2018-08-16.tar.gz
	+afp-Random_Graph_Subgraph_Threshold-2019-06-11.tar.gz
	afp-Randomised_BSTs-2018-10-19.tar.gz
	+afp-Randomised_BSTs-2019-06-11.tar.gz
	afp-Randomised_Social_Choice-2016-05-05.tar.gz
	afp-Randomised_Social_Choice-2016-12-17.tar.gz
	afp-Randomised_Social_Choice-2017-10-10.tar.gz
	afp-Randomised_Social_Choice-2018-08-16.tar.gz
	+afp-Randomised_Social_Choice-2019-06-11.tar.gz
	afp-Rank_Nullity_Theorem-2013-01-16.tar.gz
	afp-Rank_Nullity_Theorem-2013-02-16.tar.gz
	afp-Rank_Nullity_Theorem-2013-11-17.tar.gz
	afp-Rank_Nullity_Theorem-2013-12-11.tar.gz
	afp-Rank_Nullity_Theorem-2014-08-28.tar.gz
	afp-Rank_Nullity_Theorem-2015-05-27.tar.gz
	afp-Rank_Nullity_Theorem-2016-02-22.tar.gz
	afp-Rank_Nullity_Theorem-2016-12-17.tar.gz
	afp-Rank_Nullity_Theorem-2017-10-10.tar.gz
	afp-Rank_Nullity_Theorem-2018-08-16.tar.gz
	+afp-Rank_Nullity_Theorem-2019-06-11.tar.gz
	afp-Real_Impl-2014-02-11.tar.gz
	afp-Real_Impl-2014-08-28.tar.gz
	afp-Real_Impl-2015-05-27.tar.gz
	afp-Real_Impl-2016-02-22.tar.gz
	afp-Real_Impl-2016-12-17.tar.gz
	afp-Real_Impl-2017-10-10.tar.gz
	afp-Real_Impl-2018-08-16.tar.gz
	+afp-Real_Impl-2019-06-11.tar.gz
	afp-Recursion-Theory-I-2008-04-11.tar.gz
	afp-Recursion-Theory-I-2008-06-10.tar.gz
	afp-Recursion-Theory-I-2009-04-29.tar.gz
	afp-Recursion-Theory-I-2009-12-12.tar.gz
	afp-Recursion-Theory-I-2010-07-01.tar.gz
	afp-Recursion-Theory-I-2011-02-11.tar.gz
	afp-Recursion-Theory-I-2011-10-11.tar.gz
	afp-Recursion-Theory-I-2012-05-24.tar.gz
	afp-Recursion-Theory-I-2013-02-16.tar.gz
	afp-Recursion-Theory-I-2013-11-17.tar.gz
	afp-Recursion-Theory-I-2013-12-11.tar.gz
	afp-Recursion-Theory-I-2014-08-28.tar.gz
	afp-Recursion-Theory-I-2015-05-27.tar.gz
	afp-Recursion-Theory-I-2016-02-22.tar.gz
	afp-Recursion-Theory-I-2016-12-17.tar.gz
	afp-Recursion-Theory-I-2017-10-10.tar.gz
	afp-Recursion-Theory-I-2018-08-16.tar.gz
	+afp-Recursion-Theory-I-2019-06-11.tar.gz
	afp-Refine_Imperative_HOL-2016-08-08.tar.gz
	afp-Refine_Imperative_HOL-2016-12-17.tar.gz
	afp-Refine_Imperative_HOL-2017-10-10.tar.gz
	afp-Refine_Imperative_HOL-2018-08-16.tar.gz
	+afp-Refine_Imperative_HOL-2019-06-11.tar.gz
	afp-RefinementReactive-2014-10-08.tar.gz
	afp-RefinementReactive-2015-05-27.tar.gz
	afp-RefinementReactive-2016-02-22.tar.gz
	afp-RefinementReactive-2016-12-17.tar.gz
	afp-RefinementReactive-2017-10-10.tar.gz
	afp-RefinementReactive-2018-08-16.tar.gz
	+afp-RefinementReactive-2019-06-11.tar.gz
	afp-Refine_Monadic-2012-02-10.tar.gz
	afp-Refine_Monadic-2012-05-24.tar.gz
	afp-Refine_Monadic-2013-02-16.tar.gz
	afp-Refine_Monadic-2013-11-17.tar.gz
	afp-Refine_Monadic-2013-12-11.tar.gz
	afp-Refine_Monadic-2014-08-28.tar.gz
	afp-Refine_Monadic-2015-05-27.tar.gz
	afp-Refine_Monadic-2016-02-22.tar.gz
	afp-Refine_Monadic-2016-12-17.tar.gz
	afp-Refine_Monadic-2017-10-10.tar.gz
	afp-Refine_Monadic-2018-08-16.tar.gz
	+afp-Refine_Monadic-2019-06-11.tar.gz
	afp-Regex_Equivalence-2014-01-30.tar.gz
	afp-Regex_Equivalence-2014-08-28.tar.gz
	afp-Regex_Equivalence-2014-11-30.tar.gz
	afp-Regex_Equivalence-2015-05-27.tar.gz
	afp-Regex_Equivalence-2016-02-22.tar.gz
	afp-Regex_Equivalence-2016-12-17.tar.gz
	afp-Regex_Equivalence-2017-10-10.tar.gz
	afp-Regex_Equivalence-2018-08-16.tar.gz
	+afp-Regex_Equivalence-2019-06-11.tar.gz
	afp-Regular_Algebras-2014-05-22.tar.gz
	afp-Regular_Algebras-2014-08-28.tar.gz
	afp-Regular_Algebras-2015-05-27.tar.gz
	afp-Regular_Algebras-2016-02-22.tar.gz
	afp-Regular_Algebras-2016-12-17.tar.gz
	afp-Regular_Algebras-2017-10-10.tar.gz
	afp-Regular_Algebras-2018-08-16.tar.gz
	+afp-Regular_Algebras-2019-06-11.tar.gz
	afp-Regular-Sets-2010-07-01.tar.gz
	afp-Regular-Sets-2011-02-11.tar.gz
	afp-Regular-Sets-2011-10-11.tar.gz
	afp-Regular-Sets-2012-05-24.tar.gz
	afp-Regular-Sets-2013-02-16.tar.gz
	afp-Regular-Sets-2013-03-02.tar.gz
	afp-Regular-Sets-2013-11-17.tar.gz
	afp-Regular-Sets-2013-12-11.tar.gz
	afp-Regular-Sets-2014-08-28.tar.gz
	afp-Regular-Sets-2015-05-27.tar.gz
	afp-Regular-Sets-2016-02-22.tar.gz
	afp-Regular-Sets-2016-12-17.tar.gz
	afp-Regular-Sets-2017-10-10.tar.gz
	afp-Regular-Sets-2018-08-16.tar.gz
	+afp-Regular-Sets-2019-06-11.tar.gz
	afp-Relation_Algebra-2014-01-25.tar.gz
	afp-Relation_Algebra-2014-01-31.tar.gz
	afp-Relation_Algebra-2014-08-28.tar.gz
	afp-Relation_Algebra-2015-05-27.tar.gz
	afp-Relation_Algebra-2016-02-22.tar.gz
	afp-Relation_Algebra-2016-12-17.tar.gz
	afp-Relation_Algebra-2017-10-10.tar.gz
	afp-Relation_Algebra-2018-08-16.tar.gz
	+afp-Relation_Algebra-2019-06-11.tar.gz
	afp-Rep_Fin_Groups-2015-08-12.tar.gz
	afp-Rep_Fin_Groups-2016-02-22.tar.gz
	afp-Rep_Fin_Groups-2016-12-17.tar.gz
	afp-Rep_Fin_Groups-2017-10-10.tar.gz
	afp-Rep_Fin_Groups-2018-08-16.tar.gz
	+afp-Rep_Fin_Groups-2019-06-11.tar.gz
	afp-Residuated_Lattices-2015-04-16.tar.gz
	afp-Residuated_Lattices-2015-05-27.tar.gz
	afp-Residuated_Lattices-2016-02-22.tar.gz
	afp-Residuated_Lattices-2016-12-17.tar.gz
	afp-Residuated_Lattices-2017-10-10.tar.gz
	afp-Residuated_Lattices-2018-08-16.tar.gz
	+afp-Residuated_Lattices-2019-06-11.tar.gz
	afp-Resolution_FOL-2016-06-30.tar.gz
	afp-Resolution_FOL-2016-12-17.tar.gz
	afp-Resolution_FOL-2017-10-10.tar.gz
	afp-Resolution_FOL-2018-08-16.tar.gz
	+afp-Resolution_FOL-2019-06-11.tar.gz
	afp-Rewriting_Z-2016-06-30.tar.gz
	afp-Rewriting_Z-2016-12-17.tar.gz
	afp-Rewriting_Z-2017-10-10.tar.gz
	afp-Rewriting_Z-2018-08-16.tar.gz
	+afp-Rewriting_Z-2019-06-11.tar.gz
	afp-Ribbon_Proofs-2013-02-16.tar.gz
	afp-Ribbon_Proofs-2013-03-02.tar.gz
	afp-Ribbon_Proofs-2013-11-17.tar.gz
	afp-Ribbon_Proofs-2013-12-11.tar.gz
	afp-Ribbon_Proofs-2014-08-28.tar.gz
	afp-Ribbon_Proofs-2015-05-27.tar.gz
	afp-Ribbon_Proofs-2016-02-22.tar.gz
	afp-Ribbon_Proofs-2016-12-17.tar.gz
	afp-Ribbon_Proofs-2017-10-10.tar.gz
	afp-Ribbon_Proofs-2018-08-16.tar.gz
	+afp-Ribbon_Proofs-2019-06-11.tar.gz
	afp-RIPEMD-160-SPARK-2011-01-19.tar.gz
	afp-RIPEMD-160-SPARK-2011-02-11.tar.gz
	afp-RIPEMD-160-SPARK-2011-10-11.tar.gz
	afp-RIPEMD-160-SPARK-2012-05-24.tar.gz
	afp-RIPEMD-160-SPARK-2013-02-16.tar.gz
	afp-RIPEMD-160-SPARK-2013-11-17.tar.gz
	afp-RIPEMD-160-SPARK-2013-12-11.tar.gz
	afp-RIPEMD-160-SPARK-2014-08-28.tar.gz
	afp-RIPEMD-160-SPARK-2015-05-27.tar.gz
	afp-RIPEMD-160-SPARK-2016-02-22.tar.gz
	afp-RIPEMD-160-SPARK-2016-12-17.tar.gz
	afp-RIPEMD-160-SPARK-2017-10-10.tar.gz
	afp-RIPEMD-160-SPARK-2018-08-16.tar.gz
	+afp-RIPEMD-160-SPARK-2019-06-11.tar.gz
	afp-Robbins-Conjecture-2010-05-27.tar.gz
	afp-Robbins-Conjecture-2010-07-01.tar.gz
	afp-Robbins-Conjecture-2011-02-11.tar.gz
	afp-Robbins-Conjecture-2011-10-11.tar.gz
	afp-Robbins-Conjecture-2012-05-24.tar.gz
	afp-Robbins-Conjecture-2013-02-16.tar.gz
	afp-Robbins-Conjecture-2013-11-17.tar.gz
	afp-Robbins-Conjecture-2013-12-11.tar.gz
	afp-Robbins-Conjecture-2014-08-28.tar.gz
	afp-Robbins-Conjecture-2015-05-27.tar.gz
	afp-Robbins-Conjecture-2016-02-22.tar.gz
	afp-Robbins-Conjecture-2016-12-17.tar.gz
	afp-Robbins-Conjecture-2017-10-10.tar.gz
	afp-Robbins-Conjecture-2018-08-16.tar.gz
	+afp-Robbins-Conjecture-2019-06-11.tar.gz
	afp-ROBDD-2016-04-27.tar.gz
	afp-ROBDD-2016-12-17.tar.gz
	afp-ROBDD-2017-10-10.tar.gz
	afp-ROBDD-2018-08-16.tar.gz
	+afp-ROBDD-2019-06-11.tar.gz
	afp-Root_Balanced_Tree-2017-08-20.tar.gz
	afp-Root_Balanced_Tree-2017-10-10.tar.gz
	afp-Root_Balanced_Tree-2018-08-16.tar.gz
	+afp-Root_Balanced_Tree-2019-06-11.tar.gz
	afp-Routing-2016-08-31.tar.gz
	afp-Routing-2016-12-17.tar.gz
	afp-Routing-2017-10-10.tar.gz
	afp-Routing-2018-08-16.tar.gz
	+afp-Routing-2019-06-11.tar.gz
	afp-Roy_Floyd_Warshall-2014-05-24.tar.gz
	afp-Roy_Floyd_Warshall-2014-08-28.tar.gz
	afp-Roy_Floyd_Warshall-2015-05-27.tar.gz
	afp-Roy_Floyd_Warshall-2016-02-22.tar.gz
	afp-Roy_Floyd_Warshall-2016-12-17.tar.gz
	afp-Roy_Floyd_Warshall-2017-10-10.tar.gz
	afp-Roy_Floyd_Warshall-2018-08-16.tar.gz
	+afp-Roy_Floyd_Warshall-2019-06-11.tar.gz
	afp-RSAPSS-2005-10-14.tar.gz
	afp-RSAPSS-2007-11-27.tar.gz
	afp-RSAPSS-2008-06-10.tar.gz
	afp-RSAPSS-2009-04-29.tar.gz
	afp-RSAPSS-2009-12-12.tar.gz
	afp-RSAPSS-2010-07-01.tar.gz
	afp-RSAPSS-2011-02-11.tar.gz
	afp-RSAPSS-2011-10-11.tar.gz
	afp-RSAPSS-2012-05-24.tar.gz
	afp-RSAPSS-2013-02-16.tar.gz
	afp-RSAPSS-2013-03-02.tar.gz
	afp-RSAPSS-2013-11-17.tar.gz
	afp-RSAPSS-2013-12-11.tar.gz
	afp-RSAPSS-2014-08-28.tar.gz
	afp-RSAPSS-2015-05-27.tar.gz
	afp-RSAPSS-2016-02-22.tar.gz
	afp-RSAPSS-2016-12-17.tar.gz
	afp-RSAPSS-2017-10-10.tar.gz
	afp-RSAPSS-2018-08-16.tar.gz
	+afp-RSAPSS-2019-06-11.tar.gz
	afp-Safe_OCL-2019-03-14.tar.gz
	+afp-Safe_OCL-2019-06-11.tar.gz
	afp-SATSolverVerification-2008-07-27.tar.gz
	afp-SATSolverVerification-2009-04-29.tar.gz
	afp-SATSolverVerification-2009-12-12.tar.gz
	afp-SATSolverVerification-2010-07-01.tar.gz
	afp-SATSolverVerification-2011-02-11.tar.gz
	afp-SATSolverVerification-2011-10-11.tar.gz
	afp-SATSolverVerification-2012-05-24.tar.gz
	afp-SATSolverVerification-2013-02-16.tar.gz
	afp-SATSolverVerification-2013-03-02.tar.gz
	afp-SATSolverVerification-2013-11-17.tar.gz
	afp-SATSolverVerification-2013-12-11.tar.gz
	afp-SATSolverVerification-2014-08-28.tar.gz
	afp-SATSolverVerification-2015-05-27.tar.gz
	afp-SATSolverVerification-2016-02-22.tar.gz
	afp-SATSolverVerification-2016-12-17.tar.gz
	afp-SATSolverVerification-2017-10-10.tar.gz
	afp-SATSolverVerification-2018-08-16.tar.gz
	+afp-SATSolverVerification-2019-06-11.tar.gz
	afp-SDS_Impossibility-2016-05-05.tar.gz
	afp-SDS_Impossibility-2016-12-17.tar.gz
	afp-SDS_Impossibility-2017-10-10.tar.gz
	afp-SDS_Impossibility-2018-08-16.tar.gz
	+afp-SDS_Impossibility-2019-06-11.tar.gz
	afp-Secondary_Sylow-2014-01-29.tar.gz
	afp-Secondary_Sylow-2014-08-28.tar.gz
	afp-Secondary_Sylow-2015-05-27.tar.gz
	afp-Secondary_Sylow-2016-02-22.tar.gz
	afp-Secondary_Sylow-2016-12-17.tar.gz
	afp-Secondary_Sylow-2017-10-10.tar.gz
	afp-Secondary_Sylow-2018-08-16.tar.gz
	+afp-Secondary_Sylow-2019-06-11.tar.gz
	afp-Security_Protocol_Refinement-2017-05-25.tar.gz
	afp-Security_Protocol_Refinement-2017-10-10.tar.gz
	afp-Security_Protocol_Refinement-2018-08-16.tar.gz
	+afp-Security_Protocol_Refinement-2019-06-11.tar.gz
	afp-Selection_Heap_Sort-2014-02-18.tar.gz
	afp-Selection_Heap_Sort-2014-08-28.tar.gz
	afp-Selection_Heap_Sort-2015-05-27.tar.gz
	afp-Selection_Heap_Sort-2016-02-22.tar.gz
	afp-Selection_Heap_Sort-2016-12-17.tar.gz
	afp-Selection_Heap_Sort-2017-10-10.tar.gz
	afp-Selection_Heap_Sort-2018-08-16.tar.gz
	+afp-Selection_Heap_Sort-2019-06-11.tar.gz
	afp-SenSocialChoice-2008-11-17.tar.gz
	afp-SenSocialChoice-2009-04-29.tar.gz
	afp-SenSocialChoice-2009-12-12.tar.gz
	afp-SenSocialChoice-2010-07-01.tar.gz
	afp-SenSocialChoice-2011-02-11.tar.gz
	afp-SenSocialChoice-2011-10-11.tar.gz
	afp-SenSocialChoice-2012-03-15.tar.gz
	afp-SenSocialChoice-2012-05-24.tar.gz
	afp-SenSocialChoice-2013-02-16.tar.gz
	afp-SenSocialChoice-2013-11-17.tar.gz
	afp-SenSocialChoice-2013-12-11.tar.gz
	afp-SenSocialChoice-2014-08-28.tar.gz
	afp-SenSocialChoice-2015-05-27.tar.gz
	afp-SenSocialChoice-2016-02-22.tar.gz
	afp-SenSocialChoice-2016-12-17.tar.gz
	afp-SenSocialChoice-2017-10-10.tar.gz
	afp-SenSocialChoice-2018-08-16.tar.gz
	+afp-SenSocialChoice-2019-06-11.tar.gz
	afp-Separata-2016-11-17.tar.gz
	afp-Separata-2016-12-17.tar.gz
	afp-Separata-2017-10-10.tar.gz
	afp-Separata-2018-08-16.tar.gz
	+afp-Separata-2019-06-11.tar.gz
	afp-Separation_Algebra-2012-05-11.tar.gz
	afp-Separation_Algebra-2012-05-24.tar.gz
	afp-Separation_Algebra-2013-02-16.tar.gz
	afp-Separation_Algebra-2013-11-17.tar.gz
	afp-Separation_Algebra-2013-12-11.tar.gz
	afp-Separation_Algebra-2014-08-28.tar.gz
	afp-Separation_Algebra-2015-05-27.tar.gz
	afp-Separation_Algebra-2016-02-22.tar.gz
	afp-Separation_Algebra-2016-12-17.tar.gz
	afp-Separation_Algebra-2017-10-10.tar.gz
	afp-Separation_Algebra-2018-08-16.tar.gz
	+afp-Separation_Algebra-2019-06-11.tar.gz
	afp-Separation_Logic_Imperative_HOL-2012-11-15.tar.gz
	afp-Separation_Logic_Imperative_HOL-2013-02-16.tar.gz
	afp-Separation_Logic_Imperative_HOL-2013-03-02.tar.gz
	afp-Separation_Logic_Imperative_HOL-2013-11-17.tar.gz
	afp-Separation_Logic_Imperative_HOL-2013-12-11.tar.gz
	afp-Separation_Logic_Imperative_HOL-2014-08-28.tar.gz
	afp-Separation_Logic_Imperative_HOL-2015-05-27.tar.gz
	afp-Separation_Logic_Imperative_HOL-2016-02-22.tar.gz
	afp-Separation_Logic_Imperative_HOL-2016-12-17.tar.gz
	afp-Separation_Logic_Imperative_HOL-2017-10-10.tar.gz
	afp-Separation_Logic_Imperative_HOL-2018-08-16.tar.gz
	+afp-Separation_Logic_Imperative_HOL-2019-06-11.tar.gz
	afp-SequentInvertibility-2009-09-01.tar.gz
	afp-SequentInvertibility-2009-12-12.tar.gz
	afp-SequentInvertibility-2010-07-01.tar.gz
	afp-SequentInvertibility-2011-02-11.tar.gz
	afp-SequentInvertibility-2011-10-11.tar.gz
	afp-SequentInvertibility-2012-05-24.tar.gz
	afp-SequentInvertibility-2013-02-16.tar.gz
	afp-SequentInvertibility-2013-11-17.tar.gz
	afp-SequentInvertibility-2013-12-11.tar.gz
	afp-SequentInvertibility-2014-08-28.tar.gz
	afp-SequentInvertibility-2015-05-27.tar.gz
	afp-SequentInvertibility-2016-02-22.tar.gz
	afp-SequentInvertibility-2016-12-17.tar.gz
	afp-SequentInvertibility-2017-10-10.tar.gz
	afp-SequentInvertibility-2018-08-16.tar.gz
	+afp-SequentInvertibility-2019-06-11.tar.gz
	afp-Shivers-CFA-2010-11-17.tar.gz
	afp-Shivers-CFA-2010-11-18.tar.gz
	afp-Shivers-CFA-2011-02-11.tar.gz
	afp-Shivers-CFA-2011-10-11.tar.gz
	afp-Shivers-CFA-2012-05-24.tar.gz
	afp-Shivers-CFA-2013-02-16.tar.gz
	afp-Shivers-CFA-2013-11-17.tar.gz
	afp-Shivers-CFA-2013-12-11.tar.gz
	afp-Shivers-CFA-2014-08-28.tar.gz
	afp-Shivers-CFA-2015-05-27.tar.gz
	afp-Shivers-CFA-2016-02-22.tar.gz
	afp-Shivers-CFA-2016-12-17.tar.gz
	afp-Shivers-CFA-2017-10-10.tar.gz
	afp-Shivers-CFA-2018-08-16.tar.gz
	+afp-Shivers-CFA-2019-06-11.tar.gz
	afp-ShortestPath-2013-05-30.tar.gz
	afp-ShortestPath-2013-11-17.tar.gz
	afp-ShortestPath-2013-12-11.tar.gz
	afp-ShortestPath-2014-08-28.tar.gz
	afp-ShortestPath-2015-05-27.tar.gz
	afp-ShortestPath-2016-02-22.tar.gz
	afp-ShortestPath-2016-12-17.tar.gz
	afp-ShortestPath-2017-10-10.tar.gz
	afp-ShortestPath-2018-08-16.tar.gz
	+afp-ShortestPath-2019-06-11.tar.gz
	afp-Show-2014-08-28.tar.gz
	afp-Show-2014-08-29.tar.gz
	afp-Show-2015-05-27.tar.gz
	afp-Show-2016-02-22.tar.gz
	afp-Show-2016-12-17.tar.gz
	afp-Show-2017-10-10.tar.gz
	afp-Show-2018-08-16.tar.gz
	+afp-Show-2019-06-11.tar.gz
	afp-SIFPL-2008-11-13.tar.gz
	afp-SIFPL-2009-04-29.tar.gz
	afp-SIFPL-2009-12-12.tar.gz
	afp-SIFPL-2010-07-01.tar.gz
	afp-SIFPL-2011-02-11.tar.gz
	afp-SIFPL-2011-10-11.tar.gz
	afp-SIFPL-2012-05-24.tar.gz
	afp-SIFPL-2013-02-16.tar.gz
	afp-SIFPL-2013-11-17.tar.gz
	afp-SIFPL-2013-12-11.tar.gz
	afp-SIFPL-2014-08-28.tar.gz
	afp-SIFPL-2015-05-27.tar.gz
	afp-SIFPL-2016-02-22.tar.gz
	afp-SIFPL-2016-12-17.tar.gz
	afp-SIFPL-2017-10-10.tar.gz
	afp-SIFPL-2018-08-16.tar.gz
	+afp-SIFPL-2019-06-11.tar.gz
	afp-SIFUM_Type_Systems-2014-04-24.tar.gz
	afp-SIFUM_Type_Systems-2014-04-25.tar.gz
	afp-SIFUM_Type_Systems-2014-08-28.tar.gz
	afp-SIFUM_Type_Systems-2015-05-27.tar.gz
	afp-SIFUM_Type_Systems-2016-02-22.tar.gz
	afp-SIFUM_Type_Systems-2016-12-17.tar.gz
	afp-SIFUM_Type_Systems-2017-10-10.tar.gz
	afp-SIFUM_Type_Systems-2018-08-16.tar.gz
	+afp-SIFUM_Type_Systems-2019-06-11.tar.gz
	afp-Signature_Groebner-2018-09-20.tar.gz
	+afp-Signature_Groebner-2019-06-11.tar.gz
	afp-Simpl-2008-03-07.tar.gz
	afp-Simpl-2008-06-10.tar.gz
	afp-Simpl-2009-04-29.tar.gz
	afp-Simpl-2009-09-12.tar.gz
	afp-Simpl-2009-12-12.tar.gz
	afp-Simpl-2010-07-01.tar.gz
	afp-Simpl-2011-02-11.tar.gz
	afp-Simpl-2011-10-11.tar.gz
	afp-Simpl-2012-05-24.tar.gz
	afp-Simpl-2013-02-16.tar.gz
	afp-Simpl-2013-11-17.tar.gz
	afp-Simpl-2013-12-11.tar.gz
	afp-Simpl-2014-08-28.tar.gz
	afp-Simpl-2015-05-27.tar.gz
	afp-Simpl-2016-02-22.tar.gz
	afp-Simpl-2016-12-17.tar.gz
	afp-Simpl-2017-10-10.tar.gz
	afp-Simpl-2018-08-16.tar.gz
	+afp-Simpl-2019-06-11.tar.gz
	afp-Simple_Firewall-2016-08-24.tar.gz
	afp-Simple_Firewall-2016-12-17.tar.gz
	afp-Simple_Firewall-2017-10-10.tar.gz
	afp-Simple_Firewall-2018-08-16.tar.gz
	+afp-Simple_Firewall-2019-06-11.tar.gz
	afp-Simplex-2018-08-27.tar.gz
	+afp-Simplex-2019-06-11.tar.gz
	afp-Skew_Heap-2014-08-28.tar.gz
	afp-Skew_Heap-2014-08-29.tar.gz
	afp-Skew_Heap-2015-05-27.tar.gz
	afp-Skew_Heap-2016-02-22.tar.gz
	afp-Skew_Heap-2016-12-17.tar.gz
	afp-Skew_Heap-2017-10-10.tar.gz
	afp-Skew_Heap-2018-08-16.tar.gz
	+afp-Skew_Heap-2019-06-11.tar.gz
	afp-Slicing-2008-09-22.tar.gz
	afp-Slicing-2009-04-29.tar.gz
	afp-Slicing-2009-04-30.tar.gz
	afp-Slicing-2009-12-12.tar.gz
	afp-Slicing-2010-07-01.tar.gz
	afp-Slicing-2011-02-11.tar.gz
	afp-Slicing-2011-10-11.tar.gz
	afp-Slicing-2012-05-24.tar.gz
	afp-Slicing-2013-02-16.tar.gz
	afp-Slicing-2013-11-17.tar.gz
	afp-Slicing-2013-12-11.tar.gz
	afp-Slicing-2014-08-28.tar.gz
	afp-Slicing-2015-05-27.tar.gz
	afp-Slicing-2016-02-22.tar.gz
	afp-Slicing-2016-12-17.tar.gz
	afp-Slicing-2017-10-10.tar.gz
	afp-Slicing-2018-08-16.tar.gz
	+afp-Slicing-2019-06-11.tar.gz
	afp-Smooth_Manifolds-2018-10-23.tar.gz
	+afp-Smooth_Manifolds-2019-06-11.tar.gz
	afp-Sort_Encodings-2013-07-01.tar.gz
	afp-Sort_Encodings-2013-07-04.tar.gz
	afp-Sort_Encodings-2013-11-17.tar.gz
	afp-Sort_Encodings-2013-12-11.tar.gz
	afp-Sort_Encodings-2014-08-28.tar.gz
	afp-Sort_Encodings-2015-05-27.tar.gz
	afp-Sort_Encodings-2016-02-22.tar.gz
	afp-Sort_Encodings-2016-12-17.tar.gz
	afp-Sort_Encodings-2017-10-10.tar.gz
	afp-Sort_Encodings-2018-08-16.tar.gz
	+afp-Sort_Encodings-2019-06-11.tar.gz
	afp-Source_Coding_Theorem-2016-10-19.tar.gz
	afp-Source_Coding_Theorem-2016-12-17.tar.gz
	afp-Source_Coding_Theorem-2017-10-10.tar.gz
	afp-Source_Coding_Theorem-2018-08-16.tar.gz
	+afp-Source_Coding_Theorem-2019-06-11.tar.gz
	afp-SPARCv8-2016-10-19.tar.gz
	afp-SPARCv8-2016-12-17.tar.gz
	afp-SPARCv8-2017-10-10.tar.gz
	afp-SPARCv8-2018-08-16.tar.gz
	+afp-SPARCv8-2019-06-11.tar.gz
	afp-Special_Function_Bounds-2014-08-29.tar.gz
	afp-Special_Function_Bounds-2014-09-05.tar.gz
	afp-Special_Function_Bounds-2015-05-27.tar.gz
	afp-Special_Function_Bounds-2016-02-22.tar.gz
	afp-Special_Function_Bounds-2016-12-17.tar.gz
	afp-Special_Function_Bounds-2017-10-10.tar.gz
	afp-Special_Function_Bounds-2018-08-16.tar.gz
	+afp-Special_Function_Bounds-2019-06-11.tar.gz
	afp-Splay_Tree-2014-08-28.tar.gz
	afp-Splay_Tree-2015-05-27.tar.gz
	afp-Splay_Tree-2016-02-22.tar.gz
	afp-Splay_Tree-2016-12-17.tar.gz
	afp-Splay_Tree-2017-10-10.tar.gz
	afp-Splay_Tree-2018-08-16.tar.gz
	+afp-Splay_Tree-2019-06-11.tar.gz
	afp-Sqrt_Babylonian-2013-01-04.tar.gz
	afp-Sqrt_Babylonian-2013-02-16.tar.gz
	afp-Sqrt_Babylonian-2013-11-17.tar.gz
	afp-Sqrt_Babylonian-2013-12-11.tar.gz
	afp-Sqrt_Babylonian-2014-08-28.tar.gz
	afp-Sqrt_Babylonian-2015-05-27.tar.gz
	afp-Sqrt_Babylonian-2016-02-22.tar.gz
	afp-Sqrt_Babylonian-2016-12-17.tar.gz
	afp-Sqrt_Babylonian-2017-10-10.tar.gz
	afp-Sqrt_Babylonian-2018-08-16.tar.gz
	+afp-Sqrt_Babylonian-2019-06-11.tar.gz
	afp-Stable_Matching-2016-10-24.tar.gz
	afp-Stable_Matching-2016-12-17.tar.gz
	afp-Stable_Matching-2017-10-10.tar.gz
	afp-Stable_Matching-2018-08-16.tar.gz
	+afp-Stable_Matching-2019-06-11.tar.gz
	afp-Statecharts-2010-08-18.tar.gz
	afp-Statecharts-2011-02-11.tar.gz
	afp-Statecharts-2011-10-11.tar.gz
	afp-Statecharts-2012-05-24.tar.gz
	afp-Statecharts-2013-02-16.tar.gz
	afp-Statecharts-2013-11-17.tar.gz
	afp-Statecharts-2013-12-11.tar.gz
	afp-Statecharts-2014-08-28.tar.gz
	afp-Statecharts-2015-05-27.tar.gz
	afp-Statecharts-2016-02-22.tar.gz
	afp-Statecharts-2016-12-17.tar.gz
	afp-Statecharts-2017-10-10.tar.gz
	afp-Statecharts-2018-08-16.tar.gz
	+afp-Statecharts-2019-06-11.tar.gz
	afp-Stern_Brocot-2015-12-22.tar.gz
	afp-Stern_Brocot-2016-02-22.tar.gz
	afp-Stern_Brocot-2016-12-17.tar.gz
	afp-Stern_Brocot-2017-10-10.tar.gz
	afp-Stern_Brocot-2018-08-16.tar.gz
	+afp-Stern_Brocot-2019-06-11.tar.gz
	afp-Stewart_Apollonius-2017-08-01.tar.gz
	afp-Stewart_Apollonius-2017-10-10.tar.gz
	afp-Stewart_Apollonius-2018-08-16.tar.gz
	+afp-Stewart_Apollonius-2019-06-11.tar.gz
	afp-Stirling_Formula-2016-12-17.tar.gz
	afp-Stirling_Formula-2017-10-10.tar.gz
	afp-Stirling_Formula-2018-08-16.tar.gz
	+afp-Stirling_Formula-2019-06-11.tar.gz
	afp-Stochastic_Matrices-2017-11-23.tar.gz
	afp-Stochastic_Matrices-2018-08-16.tar.gz
	+afp-Stochastic_Matrices-2019-06-11.tar.gz
	afp-Stone_Algebras-2016-09-06.tar.gz
	afp-Stone_Algebras-2016-12-17.tar.gz
	afp-Stone_Algebras-2017-10-10.tar.gz
	afp-Stone_Algebras-2018-08-16.tar.gz
	+afp-Stone_Algebras-2019-06-11.tar.gz
	afp-Stone_Kleene_Relation_Algebras-2017-10-10.tar.gz
	afp-Stone_Kleene_Relation_Algebras-2018-08-16.tar.gz
	+afp-Stone_Kleene_Relation_Algebras-2019-06-11.tar.gz
	afp-Stone_Relation_Algebras-2017-02-09.tar.gz
	afp-Stone_Relation_Algebras-2017-10-10.tar.gz
	afp-Stone_Relation_Algebras-2018-08-16.tar.gz
	+afp-Stone_Relation_Algebras-2019-06-11.tar.gz
	afp-Store_Buffer_Reduction-2019-01-11.tar.gz
	+afp-Store_Buffer_Reduction-2019-06-11.tar.gz
	afp-Stream-Fusion-2009-05-11.tar.gz
	afp-Stream-Fusion-2009-05-13.tar.gz
	afp-Stream-Fusion-2009-12-12.tar.gz
	afp-Stream-Fusion-2010-07-01.tar.gz
	afp-Stream-Fusion-2011-02-11.tar.gz
	afp-Stream-Fusion-2011-10-11.tar.gz
	afp-Stream-Fusion-2012-05-24.tar.gz
	afp-Stream-Fusion-2013-02-16.tar.gz
	afp-Stream-Fusion-2013-11-17.tar.gz
	afp-Stream-Fusion-2013-12-11.tar.gz
	afp-Stream-Fusion-2014-08-28.tar.gz
	afp-Stream-Fusion-2015-05-27.tar.gz
	afp-Stream-Fusion-2016-02-22.tar.gz
	afp-Stream-Fusion-2016-12-17.tar.gz
	afp-Stream-Fusion-2017-10-10.tar.gz
	afp-Stream-Fusion-2018-08-16.tar.gz
	+afp-Stream-Fusion-2019-06-11.tar.gz
	afp-Stream_Fusion_Code-2014-10-10.tar.gz
	afp-Stream_Fusion_Code-2014-10-13.tar.gz
	afp-Stream_Fusion_Code-2015-05-27.tar.gz
	afp-Stream_Fusion_Code-2016-02-22.tar.gz
	afp-Stream_Fusion_Code-2016-12-17.tar.gz
	afp-Stream_Fusion_Code-2017-10-10.tar.gz
	afp-Stream_Fusion_Code-2018-08-16.tar.gz
	+afp-Stream_Fusion_Code-2019-06-11.tar.gz
	afp-Strong_Security-2014-04-24.tar.gz
	afp-Strong_Security-2014-08-28.tar.gz
	afp-Strong_Security-2015-05-27.tar.gz
	afp-Strong_Security-2016-02-22.tar.gz
	afp-Strong_Security-2016-12-17.tar.gz
	afp-Strong_Security-2017-10-10.tar.gz
	afp-Strong_Security-2018-08-16.tar.gz
	+afp-Strong_Security-2019-06-11.tar.gz
	afp-Sturm_Sequences-2014-01-12.tar.gz
	afp-Sturm_Sequences-2014-08-28.tar.gz
	afp-Sturm_Sequences-2015-05-27.tar.gz
	afp-Sturm_Sequences-2016-02-22.tar.gz
	afp-Sturm_Sequences-2016-12-17.tar.gz
	afp-Sturm_Sequences-2017-10-10.tar.gz
	afp-Sturm_Sequences-2018-08-16.tar.gz
	+afp-Sturm_Sequences-2019-06-11.tar.gz
	afp-Sturm_Tarski-2014-09-20.tar.gz
	afp-Sturm_Tarski-2014-12-05.tar.gz
	afp-Sturm_Tarski-2015-05-27.tar.gz
	afp-Sturm_Tarski-2016-02-22.tar.gz
	afp-Sturm_Tarski-2016-12-17.tar.gz
	afp-Sturm_Tarski-2017-10-10.tar.gz
	afp-Sturm_Tarski-2018-08-16.tar.gz
	+afp-Sturm_Tarski-2019-06-11.tar.gz
	afp-Stuttering_Equivalence-2012-05-08.tar.gz
	afp-Stuttering_Equivalence-2012-05-24.tar.gz
	afp-Stuttering_Equivalence-2013-02-02.tar.gz
	afp-Stuttering_Equivalence-2013-02-16.tar.gz
	afp-Stuttering_Equivalence-2013-11-17.tar.gz
	afp-Stuttering_Equivalence-2013-12-11.tar.gz
	afp-Stuttering_Equivalence-2014-08-28.tar.gz
	afp-Stuttering_Equivalence-2015-05-27.tar.gz
	afp-Stuttering_Equivalence-2016-02-22.tar.gz
	afp-Stuttering_Equivalence-2016-12-17.tar.gz
	afp-Stuttering_Equivalence-2017-10-10.tar.gz
	afp-Stuttering_Equivalence-2018-08-16.tar.gz
	+afp-Stuttering_Equivalence-2019-06-11.tar.gz
	afp-Subresultants-2017-04-07.tar.gz
	afp-Subresultants-2017-10-10.tar.gz
	afp-Subresultants-2018-08-16.tar.gz
	+afp-Subresultants-2019-06-11.tar.gz
	afp-SumSquares-2007-11-27.tar.gz
	afp-SumSquares-2008-06-10.tar.gz
	afp-SumSquares-2009-04-29.tar.gz
	afp-SumSquares-2009-12-12.tar.gz
	afp-SumSquares-2010-07-01.tar.gz
	afp-SumSquares-2011-02-11.tar.gz
	afp-SumSquares-2011-10-11.tar.gz
	afp-SumSquares-2012-05-24.tar.gz
	afp-SumSquares-2013-02-16.tar.gz
	afp-SumSquares-2013-11-17.tar.gz
	afp-SumSquares-2013-12-11.tar.gz
	afp-SumSquares-2014-08-28.tar.gz
	afp-SumSquares-2015-05-27.tar.gz
	afp-SumSquares-2016-02-22.tar.gz
	afp-SumSquares-2016-12-17.tar.gz
	afp-SumSquares-2017-10-10.tar.gz
	afp-SumSquares-2018-08-16.tar.gz
	+afp-SumSquares-2019-06-11.tar.gz
	afp-SuperCalc-2016-09-06.tar.gz
	afp-SuperCalc-2016-12-17.tar.gz
	afp-SuperCalc-2017-10-10.tar.gz
	afp-SuperCalc-2018-08-16.tar.gz
	+afp-SuperCalc-2019-06-11.tar.gz
	afp-Surprise_Paradox-2016-07-17.tar.gz
	afp-Surprise_Paradox-2016-12-17.tar.gz
	afp-Surprise_Paradox-2017-10-10.tar.gz
	afp-Surprise_Paradox-2018-08-16.tar.gz
	+afp-Surprise_Paradox-2019-06-11.tar.gz
	afp-Symmetric_Polynomials-2018-09-26.tar.gz
	+afp-Symmetric_Polynomials-2019-06-11.tar.gz
	afp-Tail_Recursive_Functions-2013-12-02.tar.gz
	afp-Tail_Recursive_Functions-2013-12-11.tar.gz
	afp-Tail_Recursive_Functions-2014-08-28.tar.gz
	afp-Tail_Recursive_Functions-2015-05-27.tar.gz
	afp-Tail_Recursive_Functions-2015-06-13.tar.gz
	afp-Tail_Recursive_Functions-2016-02-22.tar.gz
	afp-Tail_Recursive_Functions-2016-12-17.tar.gz
	afp-Tail_Recursive_Functions-2017-10-10.tar.gz
	afp-Tail_Recursive_Functions-2018-08-16.tar.gz
	+afp-Tail_Recursive_Functions-2019-06-11.tar.gz
	afp-Tarskis_Geometry-2012-11-08.tar.gz
	afp-Tarskis_Geometry-2012-11-09.tar.gz
	afp-Tarskis_Geometry-2013-02-16.tar.gz
	afp-Tarskis_Geometry-2013-11-17.tar.gz
	afp-Tarskis_Geometry-2013-12-11.tar.gz
	afp-Tarskis_Geometry-2014-08-28.tar.gz
	afp-Tarskis_Geometry-2015-05-27.tar.gz
	afp-Tarskis_Geometry-2016-02-22.tar.gz
	afp-Tarskis_Geometry-2016-12-17.tar.gz
	afp-Tarskis_Geometry-2017-10-10.tar.gz
	afp-Tarskis_Geometry-2018-08-16.tar.gz
	+afp-Tarskis_Geometry-2019-06-11.tar.gz
	afp-Taylor_Models-2018-01-08.tar.gz
	afp-Taylor_Models-2018-08-16.tar.gz
	+afp-Taylor_Models-2019-06-11.tar.gz
	afp-Timed_Automata-2016-03-11.tar.gz
	afp-Timed_Automata-2016-12-17.tar.gz
	afp-Timed_Automata-2017-10-10.tar.gz
	afp-Timed_Automata-2018-08-16.tar.gz
	+afp-Timed_Automata-2019-06-11.tar.gz
	afp-TLA-2011-11-27.tar.gz
	afp-TLA-2012-05-24.tar.gz
	afp-TLA-2013-02-16.tar.gz
	afp-TLA-2013-03-02.tar.gz
	afp-TLA-2013-11-17.tar.gz
	afp-TLA-2013-12-11.tar.gz
	afp-TLA-2014-08-28.tar.gz
	afp-TLA-2015-05-27.tar.gz
	afp-TLA-2016-02-22.tar.gz
	afp-TLA-2016-12-17.tar.gz
	afp-TLA-2017-10-10.tar.gz
	afp-TLA-2018-08-16.tar.gz
	+afp-TLA-2019-06-11.tar.gz
	afp-Topology-2004-04-27.tar.gz
	afp-Topology-2004-05-21.tar.gz
	afp-Topology-2005-10-14.tar.gz
	afp-Topology-2007-11-27.tar.gz
	afp-Topology-2008-06-10.tar.gz
	afp-Topology-2009-04-29.tar.gz
	afp-Topology-2009-12-12.tar.gz
	afp-Topology-2010-07-01.tar.gz
	afp-Topology-2011-02-11.tar.gz
	afp-Topology-2011-10-11.tar.gz
	afp-Topology-2012-05-24.tar.gz
	afp-Topology-2013-02-16.tar.gz
	afp-Topology-2013-03-02.tar.gz
	afp-Topology-2013-11-17.tar.gz
	afp-Topology-2013-12-11.tar.gz
	afp-Topology-2014-08-28.tar.gz
	afp-Topology-2015-05-27.tar.gz
	afp-Topology-2016-02-22.tar.gz
	afp-Topology-2016-12-17.tar.gz
	afp-Topology-2017-10-10.tar.gz
	afp-Topology-2018-08-16.tar.gz
	+afp-Topology-2019-06-11.tar.gz
	afp-TortoiseHare-2016-02-22.tar.gz
	afp-TortoiseHare-2016-12-17.tar.gz
	afp-TortoiseHare-2017-10-10.tar.gz
	afp-TortoiseHare-2018-08-16.tar.gz
	+afp-TortoiseHare-2019-06-11.tar.gz
	afp-Transcendence_Series_Hancl_Rucki-2019-03-28.tar.gz
	+afp-Transcendence_Series_Hancl_Rucki-2019-06-11.tar.gz
	afp-Transformer_Semantics-2018-12-19.tar.gz
	+afp-Transformer_Semantics-2019-06-11.tar.gz
	afp-Transition_Systems_and_Automata-2017-10-27.tar.gz
	afp-Transition_Systems_and_Automata-2018-08-16.tar.gz
	+afp-Transition_Systems_and_Automata-2019-06-11.tar.gz
	afp-Transitive-Closure-2011-03-14.tar.gz
	afp-Transitive-Closure-2011-10-11.tar.gz
	afp-Transitive-Closure-2011-10-12.tar.gz
	afp-Transitive-Closure-2012-05-24.tar.gz
	afp-Transitive-Closure-2013-02-16.tar.gz
	afp-Transitive-Closure-2013-11-17.tar.gz
	afp-Transitive-Closure-2013-12-11.tar.gz
	afp-Transitive-Closure-2014-08-28.tar.gz
	afp-Transitive-Closure-2015-05-27.tar.gz
	afp-Transitive-Closure-2016-02-22.tar.gz
	afp-Transitive-Closure-2016-12-17.tar.gz
	afp-Transitive-Closure-2017-10-10.tar.gz
	afp-Transitive-Closure-2018-08-16.tar.gz
	+afp-Transitive-Closure-2019-06-11.tar.gz
	afp-Transitive-Closure-II-2012-02-29.tar.gz
	afp-Transitive-Closure-II-2012-03-15.tar.gz
	afp-Transitive-Closure-II-2012-05-24.tar.gz
	afp-Transitive-Closure-II-2013-02-16.tar.gz
	afp-Transitive-Closure-II-2013-11-17.tar.gz
	afp-Transitive-Closure-II-2013-12-11.tar.gz
	afp-Transitive-Closure-II-2014-08-28.tar.gz
	afp-Transitive-Closure-II-2015-05-27.tar.gz
	afp-Transitive-Closure-II-2016-02-22.tar.gz
	afp-Transitive-Closure-II-2016-12-17.tar.gz
	afp-Transitive-Closure-II-2017-10-10.tar.gz
	afp-Transitive-Closure-II-2018-08-16.tar.gz
	+afp-Transitive-Closure-II-2019-06-11.tar.gz
	afp-Treaps-2018-02-06.tar.gz
	afp-Treaps-2018-02-07.tar.gz
	afp-Treaps-2018-08-16.tar.gz
	+afp-Treaps-2019-06-11.tar.gz
	afp-Tree-Automata-2009-11-29.tar.gz
	afp-Tree-Automata-2009-12-12.tar.gz
	afp-Tree-Automata-2009-12-13.tar.gz
	afp-Tree-Automata-2010-07-01.tar.gz
	afp-Tree-Automata-2011-02-11.tar.gz
	afp-Tree-Automata-2011-10-11.tar.gz
	afp-Tree-Automata-2011-10-12.tar.gz
	afp-Tree-Automata-2012-03-15.tar.gz
	afp-Tree-Automata-2012-05-24.tar.gz
	afp-Tree-Automata-2013-02-16.tar.gz
	afp-Tree-Automata-2013-03-02.tar.gz
	afp-Tree-Automata-2013-11-17.tar.gz
	afp-Tree-Automata-2013-12-11.tar.gz
	afp-Tree-Automata-2014-08-28.tar.gz
	afp-Tree-Automata-2015-05-27.tar.gz
	afp-Tree-Automata-2016-02-22.tar.gz
	afp-Tree-Automata-2016-12-17.tar.gz
	afp-Tree-Automata-2017-10-10.tar.gz
	afp-Tree-Automata-2018-08-16.tar.gz
	+afp-Tree-Automata-2019-06-11.tar.gz
	afp-Tree_Decomposition-2016-05-31.tar.gz
	afp-Tree_Decomposition-2016-06-01.tar.gz
	afp-Tree_Decomposition-2016-12-17.tar.gz
	afp-Tree_Decomposition-2017-10-10.tar.gz
	afp-Tree_Decomposition-2018-08-16.tar.gz
	+afp-Tree_Decomposition-2019-06-11.tar.gz
	afp-Triangle-2016-01-05.tar.gz
	afp-Triangle-2016-02-22.tar.gz
	afp-Triangle-2016-12-17.tar.gz
	afp-Triangle-2017-10-10.tar.gz
	afp-Triangle-2018-08-16.tar.gz
	+afp-Triangle-2019-06-11.tar.gz
	afp-Trie-2015-03-30.tar.gz
	afp-Trie-2015-05-27.tar.gz
	afp-Trie-2016-02-22.tar.gz
	afp-Trie-2016-12-17.tar.gz
	afp-Trie-2017-10-10.tar.gz
	afp-Trie-2018-08-16.tar.gz
	+afp-Trie-2019-06-11.tar.gz
	afp-Twelvefold_Way-2016-12-30.tar.gz
	afp-Twelvefold_Way-2017-10-10.tar.gz
	afp-Twelvefold_Way-2018-08-16.tar.gz
	+afp-Twelvefold_Way-2019-06-11.tar.gz
	afp-Tycon-2012-06-28.tar.gz
	afp-Tycon-2013-02-16.tar.gz
	afp-Tycon-2013-11-17.tar.gz
	afp-Tycon-2013-12-11.tar.gz
	afp-Tycon-2014-08-28.tar.gz
	afp-Tycon-2015-05-27.tar.gz
	afp-Tycon-2016-02-22.tar.gz
	afp-Tycon-2016-12-17.tar.gz
	afp-Tycon-2017-10-10.tar.gz
	afp-Tycon-2018-08-16.tar.gz
	+afp-Tycon-2019-06-11.tar.gz
	afp-Types_Tableaus_and_Goedels_God-2017-05-02.tar.gz
	afp-Types_Tableaus_and_Goedels_God-2017-10-10.tar.gz
	afp-Types_Tableaus_and_Goedels_God-2018-08-16.tar.gz
	+afp-Types_Tableaus_and_Goedels_God-2019-06-11.tar.gz
	afp-Universal_Turing_Machine-2019-02-12.tar.gz
	+afp-Universal_Turing_Machine-2019-06-11.tar.gz
	afp-UpDown_Scheme-2015-01-30.tar.gz
	afp-UpDown_Scheme-2015-05-27.tar.gz
	afp-UpDown_Scheme-2016-02-22.tar.gz
	afp-UpDown_Scheme-2016-12-17.tar.gz
	afp-UpDown_Scheme-2017-10-10.tar.gz
	afp-UpDown_Scheme-2018-08-16.tar.gz
	+afp-UpDown_Scheme-2019-06-11.tar.gz
	afp-UPF-2014-11-30.tar.gz
	afp-UPF-2015-01-28.tar.gz
	afp-UPF-2015-05-27.tar.gz
	afp-UPF-2016-02-22.tar.gz
	afp-UPF-2016-12-17.tar.gz
	afp-UPF-2017-10-10.tar.gz
	afp-UPF-2018-08-16.tar.gz
	+afp-UPF-2019-06-11.tar.gz
	afp-UPF_Firewall-2017-01-11.tar.gz
	afp-UPF_Firewall-2017-10-10.tar.gz
	afp-UPF_Firewall-2018-08-16.tar.gz
	+afp-UPF_Firewall-2019-06-11.tar.gz
	afp-UTP-2019-02-06.tar.gz
	+afp-UTP-2019-06-11.tar.gz
	afp-Valuation-2007-11-27.tar.gz
	afp-Valuation-2008-06-10.tar.gz
	afp-Valuation-2009-04-29.tar.gz
	afp-Valuation-2009-04-30.tar.gz
	afp-Valuation-2009-12-12.tar.gz
	afp-Valuation-2010-07-01.tar.gz
	afp-Valuation-2011-02-11.tar.gz
	afp-Valuation-2011-10-11.tar.gz
	afp-Valuation-2012-05-24.tar.gz
	afp-Valuation-2013-02-16.tar.gz
	afp-Valuation-2013-03-08.tar.gz
	afp-Valuation-2013-11-17.tar.gz
	afp-Valuation-2013-12-11.tar.gz
	afp-Valuation-2014-08-28.tar.gz
	afp-Valuation-2015-05-27.tar.gz
	afp-Valuation-2016-02-22.tar.gz
	afp-Valuation-2016-12-17.tar.gz
	afp-Valuation-2017-10-10.tar.gz
	afp-Valuation-2018-08-16.tar.gz
	+afp-Valuation-2019-06-11.tar.gz
	afp-VectorSpace-2014-08-29.tar.gz
	afp-VectorSpace-2014-08-31.tar.gz
	afp-VectorSpace-2014-09-07.tar.gz
	afp-VectorSpace-2015-05-27.tar.gz
	afp-VectorSpace-2016-02-22.tar.gz
	afp-VectorSpace-2016-12-17.tar.gz
	afp-VectorSpace-2017-10-10.tar.gz
	afp-VectorSpace-2018-08-16.tar.gz
	+afp-VectorSpace-2019-06-11.tar.gz
	afp-Verified-Prover-2004-09-28.tar.gz
	afp-Verified-Prover-2005-10-14.tar.gz
	afp-Verified-Prover-2007-11-27.tar.gz
	afp-Verified-Prover-2008-06-10.tar.gz
	afp-Verified-Prover-2009-04-29.tar.gz
	afp-Verified-Prover-2009-12-12.tar.gz
	afp-Verified-Prover-2010-07-01.tar.gz
	afp-Verified-Prover-2011-02-11.tar.gz
	afp-Verified-Prover-2011-10-11.tar.gz
	afp-Verified-Prover-2012-05-24.tar.gz
	afp-Verified-Prover-2013-02-16.tar.gz
	afp-Verified-Prover-2013-03-02.tar.gz
	afp-Verified-Prover-2013-11-17.tar.gz
	afp-Verified-Prover-2013-12-11.tar.gz
	afp-Verified-Prover-2014-08-28.tar.gz
	afp-Verified-Prover-2015-05-27.tar.gz
	afp-Verified-Prover-2016-02-22.tar.gz
	afp-Verified-Prover-2016-12-17.tar.gz
	afp-Verified-Prover-2017-10-10.tar.gz
	afp-Verified-Prover-2018-08-16.tar.gz
	+afp-Verified-Prover-2019-06-11.tar.gz
	afp-VerifyThis2018-2018-04-30.tar.gz
	afp-VerifyThis2018-2018-08-16.tar.gz
	+afp-VerifyThis2018-2019-06-11.tar.gz
	afp-Vickrey_Clarke_Groves-2015-04-30.tar.gz
	afp-Vickrey_Clarke_Groves-2015-05-09.tar.gz
	afp-Vickrey_Clarke_Groves-2015-05-27.tar.gz
	afp-Vickrey_Clarke_Groves-2016-02-22.tar.gz
	afp-Vickrey_Clarke_Groves-2016-12-17.tar.gz
	afp-Vickrey_Clarke_Groves-2017-10-10.tar.gz
	afp-Vickrey_Clarke_Groves-2018-08-16.tar.gz
	+afp-Vickrey_Clarke_Groves-2019-06-11.tar.gz
	afp-VolpanoSmith-2008-09-05.tar.gz
	afp-VolpanoSmith-2009-04-29.tar.gz
	afp-VolpanoSmith-2009-12-12.tar.gz
	afp-VolpanoSmith-2010-07-01.tar.gz
	afp-VolpanoSmith-2011-02-11.tar.gz
	afp-VolpanoSmith-2011-10-11.tar.gz
	afp-VolpanoSmith-2012-05-24.tar.gz
	afp-VolpanoSmith-2013-02-16.tar.gz
	afp-VolpanoSmith-2013-11-17.tar.gz
	afp-VolpanoSmith-2013-12-11.tar.gz
	afp-VolpanoSmith-2014-08-28.tar.gz
	afp-VolpanoSmith-2015-05-27.tar.gz
	afp-VolpanoSmith-2016-02-22.tar.gz
	afp-VolpanoSmith-2016-12-17.tar.gz
	afp-VolpanoSmith-2017-10-10.tar.gz
	afp-VolpanoSmith-2018-08-16.tar.gz
	+afp-VolpanoSmith-2019-06-11.tar.gz
	afp-WebAssembly-2018-04-29.tar.gz
	afp-WebAssembly-2018-04-30.tar.gz
	afp-WebAssembly-2018-08-16.tar.gz
	+afp-WebAssembly-2019-06-11.tar.gz
	afp-Weight_Balanced_Trees-2018-03-13.tar.gz
	afp-Weight_Balanced_Trees-2018-08-16.tar.gz
	+afp-Weight_Balanced_Trees-2019-06-11.tar.gz
	afp-Well_Quasi_Orders-2012-05-24.tar.gz
	afp-Well_Quasi_Orders-2013-02-16.tar.gz
	afp-Well_Quasi_Orders-2013-11-17.tar.gz
	afp-Well_Quasi_Orders-2013-12-11.tar.gz
	afp-Well_Quasi_Orders-2014-08-28.tar.gz
	afp-Well_Quasi_Orders-2015-05-27.tar.gz
	afp-Well_Quasi_Orders-2016-02-22.tar.gz
	afp-Well_Quasi_Orders-2016-12-17.tar.gz
	afp-Well_Quasi_Orders-2017-10-10.tar.gz
	afp-Well_Quasi_Orders-2018-08-16.tar.gz
	+afp-Well_Quasi_Orders-2019-06-11.tar.gz
	afp-WHATandWHERE_Security-2014-04-24.tar.gz
	afp-WHATandWHERE_Security-2014-08-28.tar.gz
	afp-WHATandWHERE_Security-2015-05-27.tar.gz
	afp-WHATandWHERE_Security-2016-02-22.tar.gz
	afp-WHATandWHERE_Security-2016-12-17.tar.gz
	afp-WHATandWHERE_Security-2017-10-10.tar.gz
	afp-WHATandWHERE_Security-2018-08-16.tar.gz
	+afp-WHATandWHERE_Security-2019-06-11.tar.gz
	afp-Winding_Number_Eval-2017-10-18.tar.gz
	afp-Winding_Number_Eval-2018-08-16.tar.gz
	+afp-Winding_Number_Eval-2019-06-11.tar.gz
	afp-Word_Lib-2016-06-09.tar.gz
	afp-Word_Lib-2016-12-17.tar.gz
	afp-Word_Lib-2017-10-10.tar.gz
	afp-Word_Lib-2018-08-16.tar.gz
	+afp-Word_Lib-2019-06-11.tar.gz
	afp-WorkerWrapper-2009-10-30.tar.gz
	afp-WorkerWrapper-2009-10-31.tar.gz
	afp-WorkerWrapper-2009-12-12.tar.gz
	afp-WorkerWrapper-2010-07-01.tar.gz
	afp-WorkerWrapper-2011-02-11.tar.gz
	afp-WorkerWrapper-2011-10-11.tar.gz
	afp-WorkerWrapper-2012-05-24.tar.gz
	afp-WorkerWrapper-2013-02-16.tar.gz
	afp-WorkerWrapper-2013-11-17.tar.gz
	afp-WorkerWrapper-2013-12-11.tar.gz
	afp-WorkerWrapper-2014-08-28.tar.gz
	afp-WorkerWrapper-2015-05-27.tar.gz
	afp-WorkerWrapper-2016-02-22.tar.gz
	afp-WorkerWrapper-2016-12-17.tar.gz
	afp-WorkerWrapper-2017-10-10.tar.gz
	afp-WorkerWrapper-2018-08-16.tar.gz
	+afp-WorkerWrapper-2019-06-11.tar.gz
	afp-XML-2014-10-08.tar.gz
	afp-XML-2015-05-27.tar.gz
	afp-XML-2016-02-22.tar.gz
	afp-XML-2016-12-17.tar.gz
	afp-XML-2017-10-10.tar.gz
	afp-XML-2018-08-16.tar.gz
	+afp-XML-2019-06-11.tar.gz
	afp-Zeta_Function-2017-10-16.tar.gz
	afp-Zeta_Function-2018-08-16.tar.gz
	+afp-Zeta_Function-2019-06-11.tar.gz
	diff --git a/metadata/templates/using.tpl b/metadata/templates/using.tpl
	--- a/metadata/templates/using.tpl
	+++ b/metadata/templates/using.tpl
	@@ -1,50 +1,50 @@
	{% extends "base.tpl" %}

	{% block headline %}
	<font class="first">R</font>eferring to
	<font class="first">A</font>FP
	<font class="first">E</font>ntries
	{% endblock %}

	{% block content %}
	<table width="80%" class="descr">
	<tbody>
	<tr><td>

	<p>
	Once you have downloaded the AFP, you can include its articles and theories in
	your own developments. If you would like to make your work available to others
	<i>without</i> having to include the AFP articles you depend on, here is how to do it.
	</p>
	<p>
	-If you are using Isabelle2018, and have downloaded your AFP directory to
	+If you are using Isabelle2019, and have downloaded your AFP directory to
	<code>/home/myself/afp</code>, you should run the following command
	<a href="#1">[1]</a> to make the AFP session ROOTS available to Isabelle:</p>
	<p>
	<pre class="code">
	- echo "/home/myself/afp/thys" >> ~/.isabelle/Isabelle2018/ROOTS
	+ echo "/home/myself/afp/thys" >> ~/.isabelle/Isabelle2019/ROOTS
	</pre>

	<p>
	You can now refer to article <code>ABC</code> from the AFP in some theory of
	yours via</p>

	<pre class="code">
	imports "ABC.Some_ABC_Theory"
	</pre>

	<p>This allows you to distribute your material separately from any AFP
	theories. Users of your distribution also need to install the AFP in the above
	manner.</p>

	<p> </p>

	<p>
	<a name="1">[1]:</a> Tested for Linux and Mac installations &dash; it should be the same under cygwin on Windows.
	</p>
	<p>
	</td></tr>
	</tbody>
	</table>
	{% endblock %}

	diff --git a/thys/Groebner_Macaulay/Binomial_Int.thy b/thys/Groebner_Macaulay/Binomial_Int.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Binomial_Int.thy
	@@ -0,0 +1,520 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Integer Binomial Coefficients\<close>
	+
	+theory Binomial_Int
	+ imports Complex_Main
	+begin
	+
	+lemma upper_le_binomial:
	+ assumes "0 < k" and "k < n"
	+ shows "n \<le> n choose k"
	+proof -
	+ from assms have "1 \<le> n" by simp
	+ define k' where "k' = (if n div 2 \<le> k then k else n - k)"
	+ from assms have 1: "k' \<le> n - 1" and 2: "n div 2 \<le> k'" by (auto simp: k'_def)
	+ from assms(2) have "k \<le> n" by simp
	+ have "n choose k = n choose k'" by (simp add: k'_def binomial_symmetric[OF \<open>k \<le> n\<close>])
	+ have "n = n choose 1" by (simp only: choose_one)
	+ also from \<open>1 \<le> n\<close> have "\<dots> = n choose (n - 1)" by (rule binomial_symmetric)
	+ also from 1 2 have "\<dots> \<le> n choose k'" by (rule binomial_antimono) simp
	+ also have "\<dots> = n choose k" by (simp add: k'_def binomial_symmetric[OF \<open>k \<le> n\<close>])
	+ finally show ?thesis .
	+qed
	+
	+text \<open>Restore original sort constraints:\<close>
	+setup \<open>Sign.add_const_constraint (@{const_name gbinomial}, SOME @{typ "'a::{semidom_divide,semiring_char_0} \<Rightarrow> nat \<Rightarrow> 'a"})\<close>
	+
	+lemma gbinomial_0_left: "0 gchoose k = (if k = 0 then 1 else 0)"
	+ by (cases k) simp_all
	+
	+lemma gbinomial_eq_0_int:
	+ assumes "n < k"
	+ shows "(int n) gchoose k = 0"
	+proof -
	+ have "\<exists>a\<in>{0..<k}. int n - int a = 0"
	+ proof
	+ show "int n - int n = 0" by simp
	+ next
	+ from assms show "n \<in> {0..<k}" by simp
	+ qed
	+ with finite_atLeastLessThan have eq: "prod (\<lambda>i. int n - int i) {0..<k} = 0" by (rule prod_zero)
	+ show ?thesis by (simp add: gbinomial_prod_rev eq)
	+qed
	+
	+corollary gbinomial_eq_0: "0 \<le> a \<Longrightarrow> a < int k \<Longrightarrow> a gchoose k = 0"
	+ by (metis nat_eq_iff2 nat_less_iff gbinomial_eq_0_int)
	+
	+lemma int_binomial: "int (n choose k) = (int n) gchoose k"
	+proof (cases "k \<le> n")
	+ case True
	+ from refl have eq: "(\<Prod>i = 0..<k. int (n - i)) = (\<Prod>i = 0..<k. int n - int i)"
	+ proof (rule prod.cong)
	+ fix i
	+ assume "i \<in> {0..<k}"
	+ with True show "int (n - i) = int n - int i" by simp
	+ qed
	+ show ?thesis
	+ by (simp add: gbinomial_binomial[symmetric] gbinomial_prod_rev zdiv_int eq)
	+next
	+ case False
	+ thus ?thesis by (simp add: gbinomial_eq_0_int)
	+qed
	+
	+lemma falling_fact_pochhammer: "prod (\<lambda>i. a - int i) {0..<k} = (- 1) ^ k * pochhammer (- a) k"
	+proof -
	+ have eq: "z ^ Suc n * prod f {0..n} = prod (\<lambda>x. z * f x) {0..n}" for z::int and n f
	+ by (induct n) (simp_all add: ac_simps)
	+ show ?thesis
	+ proof (cases k)
	+ case 0
	+ thus ?thesis by (simp add: pochhammer_minus)
	+ next
	+ case (Suc n)
	+ thus ?thesis
	+ by (simp only: pochhammer_prod atLeastLessThanSuc_atLeastAtMost
	+ prod.atLeast_Suc_atMost_Suc_shift eq flip: power_mult_distrib) (simp add: of_nat_diff)
	+ qed
	+qed
	+
	+lemma falling_fact_pochhammer': "prod (\<lambda>i. a - int i) {0..<k} = pochhammer (a - int k + 1) k"
	+ by (simp add: falling_fact_pochhammer pochhammer_minus')
	+
	+lemma gbinomial_int_pochhammer: "(a::int) gchoose k = (- 1) ^ k * pochhammer (- a) k div fact k"
	+ by (simp only: gbinomial_prod_rev falling_fact_pochhammer)
	+
	+lemma gbinomial_int_pochhammer': "a gchoose k = pochhammer (a - int k + 1) k div fact k"
	+ by (simp only: gbinomial_prod_rev falling_fact_pochhammer')
	+
	+lemma fact_dvd_pochhammer: "fact k dvd pochhammer (a::int) k"
	+proof -
	+ have dvd: "y \<noteq> 0 \<Longrightarrow> ((of_int (x div y))::'a::field_char_0) = of_int x / of_int y \<Longrightarrow> y dvd x"
	+ for x y :: int
	+ by (smt dvd_triv_left mult.commute nonzero_eq_divide_eq of_int_eq_0_iff of_int_eq_iff of_int_mult)
	+ show ?thesis
	+ proof (cases "0 < a")
	+ case True
	+ moreover define n where "n = nat (a - 1) + k"
	+ ultimately have a: "a = int n - int k + 1" by simp
	+ from fact_nonzero show ?thesis unfolding a
	+ proof (rule dvd)
	+ have "of_int (pochhammer (int n - int k + 1) k div fact k) = (of_int (int n gchoose k)::rat)"
	+ by (simp only: gbinomial_int_pochhammer')
	+ also have "\<dots> = of_int (int (n choose k))" by (simp only: int_binomial)
	+ also have "\<dots> = of_nat (n choose k)" by simp
	+ also have "\<dots> = (of_nat n) gchoose k" by (fact binomial_gbinomial)
	+ also have "\<dots> = pochhammer (of_nat n - of_nat k + 1) k / fact k"
	+ by (fact gbinomial_pochhammer')
	+ also have "\<dots> = pochhammer (of_int (int n - int k + 1)) k / fact k" by simp
	+ also have "\<dots> = (of_int (pochhammer (int n - int k + 1) k)) / (of_int (fact k))"
	+ by (simp only: of_int_fact pochhammer_of_int)
	+ finally show "of_int (pochhammer (int n - int k + 1) k div fact k) =
	+ of_int (pochhammer (int n - int k + 1) k) / rat_of_int (fact k)" .
	+ qed
	+ next
	+ case False
	+ moreover define n where "n = nat (- a)"
	+ ultimately have a: "a = - int n" by simp
	+ from fact_nonzero have "fact k dvd (-1)^k * pochhammer (- int n) k"
	+ proof (rule dvd)
	+ have "of_int ((-1)^k * pochhammer (- int n) k div fact k) = (of_int (int n gchoose k)::rat)"
	+ by (simp only: gbinomial_int_pochhammer)
	+ also have "\<dots> = of_int (int (n choose k))" by (simp only: int_binomial)
	+ also have "\<dots> = of_nat (n choose k)" by simp
	+ also have "\<dots> = (of_nat n) gchoose k" by (fact binomial_gbinomial)
	+ also have "\<dots> = (-1)^k * pochhammer (- of_nat n) k / fact k"
	+ by (fact gbinomial_pochhammer)
	+ also have "\<dots> = (-1)^k * pochhammer (of_int (- int n)) k / fact k" by simp
	+ also have "\<dots> = (-1)^k * (of_int (pochhammer (- int n) k)) / (of_int (fact k))"
	+ by (simp only: of_int_fact pochhammer_of_int)
	+ also have "\<dots> = (of_int ((-1)^k * pochhammer (- int n) k)) / (of_int (fact k))" by simp
	+ finally show "of_int ((- 1) ^ k * pochhammer (- int n) k div fact k) =
	+ of_int ((- 1) ^ k * pochhammer (- int n) k) / rat_of_int (fact k)" .
	+ qed
	+ thus ?thesis unfolding a by (metis dvdI dvd_mult_unit_iff' minus_one_mult_self)
	+ qed
	+qed
	+
	+lemma gbinomial_int_negated_upper: "(a gchoose k) = (-1) ^ k * ((int k - a - 1) gchoose k)"
	+ by (simp add: gbinomial_int_pochhammer pochhammer_minus algebra_simps fact_dvd_pochhammer div_mult_swap)
	+
	+lemma gbinomial_int_mult_fact: "fact k * (a gchoose k) = (\<Prod>i = 0..<k. a - int i)"
	+ by (simp only: gbinomial_int_pochhammer' fact_dvd_pochhammer dvd_mult_div_cancel falling_fact_pochhammer')
	+
	+corollary gbinomial_int_mult_fact': "(a gchoose k) * fact k = (\<Prod>i = 0..<k. a - int i)"
	+ using gbinomial_int_mult_fact[of k a] by (simp add: ac_simps)
	+
	+lemma gbinomial_int_binomial:
	+ "a gchoose k = (if 0 \<le> a then int ((nat a) choose k) else (-1::int)^k * int ((k + (nat (- a)) - 1) choose k))"
	+ by (auto simp: int_binomial gbinomial_int_negated_upper[of a] int_ops(6))
	+
	+corollary gbinomial_nneg: "0 \<le> a \<Longrightarrow> a gchoose k = int ((nat a) choose k)"
	+ by (simp add: gbinomial_int_binomial)
	+
	+corollary gbinomial_neg: "a < 0 \<Longrightarrow> a gchoose k = (-1::int)^k * int ((k + (nat (- a)) - 1) choose k)"
	+ by (simp add: gbinomial_int_binomial)
	+
	+lemma of_int_gbinomial: "of_int (a gchoose k) = (of_int a :: 'a::field_char_0) gchoose k"
	+proof -
	+ have of_int_div: "y dvd x \<Longrightarrow> of_int (x div y) = of_int x / (of_int y :: 'a)" for x y :: int by auto
	+ show ?thesis
	+ by (simp add: gbinomial_int_pochhammer' gbinomial_pochhammer' of_int_div fact_dvd_pochhammer
	+ pochhammer_of_int[symmetric])
	+qed
	+
	+lemma uminus_one_gbinomial [simp]: "(- 1::int) gchoose k = (- 1) ^ k"
	+ by (simp add: gbinomial_int_binomial)
	+
	+lemma gbinomial_int_Suc_Suc: "(x + 1::int) gchoose (Suc k) = (x gchoose k) + (x gchoose (Suc k))"
	+proof (rule linorder_cases)
	+ assume 1: "x + 1 < 0"
	+ hence 2: "x < 0" by simp
	+ then obtain n where 3: "nat (- x) = Suc n" using not0_implies_Suc by fastforce
	+ hence 4: "nat (- x - 1) = n" by simp
	+ show ?thesis
	+ proof (cases k)
	+ case 0
	+ show ?thesis by (simp add: \<open>k = 0\<close>)
	+ next
	+ case (Suc k')
	+ from 1 2 3 4 show ?thesis by (simp add: \<open>k = Suc k'\<close> gbinomial_int_binomial int_distrib(2))
	+ qed
	+next
	+ assume "x + 1 = 0"
	+ hence "x = - 1" by simp
	+ thus ?thesis by simp
	+next
	+ assume "0 < x + 1"
	+ hence "0 \<le> x + 1" and "0 \<le> x" and "nat (x + 1) = Suc (nat x)" by simp_all
	+ thus ?thesis by (simp add: gbinomial_int_binomial)
	+qed
	+
	+corollary plus_Suc_gbinomial:
	+ "(x + (1 + int k)) gchoose (Suc k) = ((x + int k) gchoose k) + ((x + int k) gchoose (Suc k))"
	+ (is "?l = ?r")
	+proof -
	+ have "?l = (x + int k + 1) gchoose (Suc k)" by (simp only: ac_simps)
	+ also have "\<dots> = ?r" by (fact gbinomial_int_Suc_Suc)
	+ finally show ?thesis .
	+qed
	+
	+lemma gbinomial_int_n_n [simp]: "(int n) gchoose n = 1"
	+proof (induct n)
	+ case 0
	+ show ?case by simp
	+next
	+ case (Suc n)
	+ have "int (Suc n) gchoose Suc n = (int n + 1) gchoose Suc n" by (simp add: add.commute)
	+ also have "\<dots> = (int n gchoose n) + (int n gchoose (Suc n))" by (fact gbinomial_int_Suc_Suc)
	+ finally show ?case by (simp add: Suc gbinomial_eq_0)
	+qed
	+
	+lemma gbinomial_int_Suc_n [simp]: "(1 + int n) gchoose n = 1 + int n"
	+proof (induct n)
	+ case 0
	+ show ?case by simp
	+next
	+ case (Suc n)
	+ have "1 + int (Suc n) gchoose Suc n = (1 + int n) + 1 gchoose Suc n" by simp
	+ also have "\<dots> = (1 + int n gchoose n) + (1 + int n gchoose (Suc n))" by (fact gbinomial_int_Suc_Suc)
	+ also have "\<dots> = 1 + int n + (int (Suc n) gchoose (Suc n))" by (simp add: Suc)
	+ also have "\<dots> = 1 + int (Suc n)" by (simp only: gbinomial_int_n_n)
	+ finally show ?case .
	+qed
	+
	+lemma zbinomial_eq_0_iff [simp]: "a gchoose k = 0 \<longleftrightarrow> (0 \<le> a \<and> a < int k)"
	+proof
	+ assume a: "a gchoose k = 0"
	+ have 1: "b < int k" if "b gchoose k = 0" for b
	+ proof (rule ccontr)
	+ assume "\<not> b < int k"
	+ hence "0 \<le> b" and "k \<le> nat b" by simp_all
	+ from this(1) have "int ((nat b) choose k) = b gchoose k" by (simp add: gbinomial_int_binomial)
	+ also have "\<dots> = 0" by (fact that)
	+ finally show False using \<open>k \<le> nat b\<close> by simp
	+ qed
	+ show "0 \<le> a \<and> a < int k"
	+ proof
	+ show "0 \<le> a"
	+ proof (rule ccontr)
	+ assume "\<not> 0 \<le> a"
	+ hence "(-1) ^ k * ((int k - a - 1) gchoose k) = a gchoose k"
	+ by (simp add: gbinomial_int_negated_upper[of a])
	+ also have "\<dots> = 0" by (fact a)
	+ finally have "(int k - a - 1) gchoose k = 0" by simp
	+ hence "int k - a - 1 < int k" by (rule 1)
	+ with \<open>\<not> 0 \<le> a\<close> show False by simp
	+ qed
	+ next
	+ from a show "a < int k" by (rule 1)
	+ qed
	+qed (auto intro: gbinomial_eq_0)
	+
	+subsection \<open>Sums\<close>
	+
	+lemma gchoose_rising_sum_nat: "(\<Sum>j\<le>n. int j + int k gchoose k) = (int n + int k + 1) gchoose (Suc k)"
	+proof -
	+ have "(\<Sum>j\<le>n. int j + int k gchoose k) = int (\<Sum>j\<le>n. k + j choose k)"
	+ by (simp add: int_binomial add.commute)
	+ also have "(\<Sum>j\<le>n. k + j choose k) = (k + n + 1) choose (k + 1)" by (fact choose_rising_sum(1))
	+ also have "int \<dots> = (int n + int k + 1) gchoose (Suc k)"
	+ by (simp add: int_binomial ac_simps del: binomial_Suc_Suc)
	+ finally show ?thesis .
	+qed
	+
	+lemma gchoose_rising_sum:
	+ assumes "0 \<le> n" \<comment>\<open>Necessary condition.\<close>
	+ shows "(\<Sum>j=0..n. j + int k gchoose k) = (n + int k + 1) gchoose (Suc k)"
	+proof -
	+ from _ refl have "(\<Sum>j=0..n. j + int k gchoose k) = (\<Sum>j\<in>int ` {0..nat n}. j + int k gchoose k)"
	+ proof (rule sum.cong)
	+ from assms show "{0..n} = int ` {0..nat n}" by (simp add: image_int_atLeastAtMost)
	+ qed
	+ also have "\<dots> = (\<Sum>j\<le>nat n. int j + int k gchoose k)" by (simp add: sum.reindex atMost_atLeast0)
	+ also have "\<dots> = (int (nat n) + int k + 1) gchoose (Suc k)" by (fact gchoose_rising_sum_nat)
	+ also from assms have "\<dots> = (n + int k + 1) gchoose (Suc k)" by (simp add: add.assoc add.commute)
	+ finally show ?thesis .
	+qed
	+
	+subsection \<open>Inequalities\<close>
	+
	+lemma binomial_mono:
	+ assumes "m \<le> n"
	+ shows "m choose k \<le> n choose k"
	+proof -
	+ define l where "l = n - m"
	+ with assms have n: "n = m + l" by simp
	+ have "m choose k \<le> (m + l) choose k"
	+ proof (induct l)
	+ case 0
	+ show ?case by simp
	+ next
	+ case *: (Suc l)
	+ show ?case
	+ proof (cases k)
	+ case 0
	+ thus ?thesis by simp
	+ next
	+ case k: (Suc k0)
	+ note *
	+ also have "m + l choose k \<le> m + l choose k + (m + l choose k0)" by simp
	+ also have "\<dots> = m + Suc l choose k" by (simp add: k)
	+ finally show ?thesis .
	+ qed
	+ qed
	+ thus ?thesis by (simp only: n)
	+qed
	+
	+lemma binomial_plus_le:
	+ assumes "0 < k"
	+ shows "(m choose k) + (n choose k) \<le> (m + n) choose k"
	+proof -
	+ define k0 where "k0 = k - 1"
	+ with assms have k: "k = Suc k0" by simp
	+ show ?thesis unfolding k
	+ proof (induct n)
	+ case 0
	+ show ?case by simp
	+ next
	+ case (Suc n)
	+ have "m choose Suc k0 + (Suc n choose Suc k0) = m choose Suc k0 + (n choose Suc k0) + (n choose k0)"
	+ by (simp only: binomial_Suc_Suc)
	+ also from Suc have "\<dots> \<le> (m + n) choose Suc k0 + ((m + n) choose k0)"
	+ proof (rule add_mono)
	+ have "n \<le> m + n" by simp
	+ thus "n choose k0 \<le> m + n choose k0" by (rule binomial_mono)
	+ qed
	+ also have "\<dots> = m + Suc n choose Suc k0" by simp
	+ finally show ?case .
	+ qed
	+qed
	+
	+lemma binomial_ineq_1: "2 * ((n + i) choose k) \<le> n choose k + ((n + 2 * i) choose k)"
	+proof (cases k)
	+ case 0
	+ thus ?thesis by simp
	+next
	+ case k: (Suc k0)
	+ show ?thesis unfolding k
	+ proof (induct i)
	+ case 0
	+ thus ?case by simp
	+ next
	+ case (Suc i)
	+ have "2 * (n + Suc i choose Suc k0) = 2 * (n + i choose k0) + 2 * (n + i choose Suc k0)"
	+ by simp
	+ also have "\<dots> \<le> (n + 2 * i choose k0 + (Suc (n + 2 * i) choose k0)) + (n choose Suc k0 + (n + 2 * i choose Suc k0))"
	+ proof (rule add_mono)
	+ have "n + i choose k0 \<le> n + 2 * i choose k0" by (rule binomial_mono) simp
	+ moreover have "n + 2 * i choose k0 \<le> Suc (n + 2 * i) choose k0" by (rule binomial_mono) simp
	+ ultimately show "2 * (n + i choose k0) \<le> n + 2 * i choose k0 + (Suc (n + 2 * i) choose k0)"
	+ by simp
	+ qed (fact Suc)
	+ also have "\<dots> = n choose Suc k0 + (n + 2 * Suc i choose Suc k0)" by simp
	+ finally show ?case .
	+ qed
	+qed
	+
	+lemma gbinomial_int_nonneg:
	+ assumes "0 \<le> (x::int)"
	+ shows "0 \<le> x gchoose k"
	+proof -
	+ have "0 \<le> int (nat x choose k)" by simp
	+ also from assms have "\<dots> = x gchoose k" by (simp add: int_binomial)
	+ finally show ?thesis .
	+qed
	+
	+lemma gbinomial_int_mono:
	+ assumes "0 \<le> x" and "x \<le> (y::int)"
	+ shows "x gchoose k \<le> y gchoose k"
	+proof -
	+ from assms have "nat x \<le> nat y" by simp
	+ hence "nat x choose k \<le> nat y choose k" by (rule binomial_mono)
	+ hence "int (nat x choose k) \<le> int (nat y choose k)" by (simp only: zle_int)
	+ hence "int (nat x) gchoose k \<le> int (nat y) gchoose k" by (simp only: int_binomial)
	+ with assms show ?thesis by simp
	+qed
	+
	+lemma gbinomial_int_plus_le:
	+ assumes "0 < k" and "0 \<le> x" and "0 \<le> (y::int)"
	+ shows "(x gchoose k) + (y gchoose k) \<le> (x + y) gchoose k"
	+proof -
	+ from assms(1) have "nat x choose k + (nat y choose k) \<le> nat x + nat y choose k"
	+ by (rule binomial_plus_le)
	+ hence "int (nat x choose k + (nat y choose k)) \<le> int (nat x + nat y choose k)"
	+ by (simp only: zle_int)
	+ hence "int (nat x) gchoose k + (int (nat y) gchoose k) \<le> int (nat x) + int (nat y) gchoose k"
	+ by (simp only: int_plus int_binomial)
	+ with assms(2, 3) show ?thesis by simp
	+qed
	+
	+lemma binomial_int_ineq_1:
	+ assumes "0 \<le> x" and "0 \<le> (y::int)"
	+ shows "2 * (x + y gchoose k) \<le> x gchoose k + ((x + 2 * y) gchoose k)"
	+proof -
	+ from binomial_ineq_1[of "nat x" "nat y" k]
	+ have "int (2 * (nat x + nat y choose k)) \<le> int (nat x choose k + (nat x + 2 * nat y choose k))"
	+ by (simp only: zle_int)
	+ hence "2 * (int (nat x) + int (nat y) gchoose k) \<le> int (nat x) gchoose k + (int (nat x) + 2 * int (nat y) gchoose k)"
	+ by (simp only: int_binomial int_plus int_ops(7)) simp
	+ with assms show ?thesis by simp
	+qed
	+
	+corollary binomial_int_ineq_2:
	+ assumes "0 \<le> y" and "y \<le> (x::int)"
	+ shows "2 * (x gchoose k) \<le> x - y gchoose k + (x + y gchoose k)"
	+proof -
	+ from assms(2) have "0 \<le> x - y" by simp
	+ hence "2 * ((x - y) + y gchoose k) \<le> x - y gchoose k + ((x - y + 2 * y) gchoose k)"
	+ using assms(1) by (rule binomial_int_ineq_1)
	+ thus ?thesis by smt
	+qed
	+
	+corollary binomial_int_ineq_3:
	+ assumes "0 \<le> y" and "y \<le> 2 * (x::int)"
	+ shows "2 * (x gchoose k) \<le> y gchoose k + (2 * x - y gchoose k)"
	+proof (cases "y \<le> x")
	+ case True
	+ hence "0 \<le> x - y" by simp
	+ moreover from assms(1) have "x - y \<le> x" by simp
	+ ultimately have "2 * (x gchoose k) \<le> x - (x - y) gchoose k + (x + (x - y) gchoose k)"
	+ by (rule binomial_int_ineq_2)
	+ thus ?thesis by simp
	+next
	+ case False
	+ hence "0 \<le> y - x" by simp
	+ moreover from assms(2) have "y - x \<le> x" by simp
	+ ultimately have "2 * (x gchoose k) \<le> x - (y - x) gchoose k + (x + (y - x) gchoose k)"
	+ by (rule binomial_int_ineq_2)
	+ thus ?thesis by simp
	+qed
	+
	+subsection \<open>Backward Difference Operator\<close>
	+
	+definition bw_diff :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a \<Rightarrow> 'a::{ab_group_add,one}"
	+ where "bw_diff f x = f x - f (x - 1)"
	+
	+lemma bw_diff_const [simp]: "bw_diff (\<lambda>_. c) = (\<lambda>_. 0)"
	+ by (rule ext) (simp add: bw_diff_def)
	+
	+lemma bw_diff_id [simp]: "bw_diff (\<lambda>x. x) = (\<lambda>_. 1)"
	+ by (rule ext) (simp add: bw_diff_def)
	+
	+lemma bw_diff_plus [simp]: "bw_diff (\<lambda>x. f x + g x) = (\<lambda>x. bw_diff f x + bw_diff g x)"
	+ by (rule ext) (simp add: bw_diff_def)
	+
	+lemma bw_diff_uminus [simp]: "bw_diff (\<lambda>x. - f x) = (\<lambda>x. - bw_diff f x)"
	+ by (rule ext) (simp add: bw_diff_def)
	+
	+lemma bw_diff_minus [simp]: "bw_diff (\<lambda>x. f x - g x) = (\<lambda>x. bw_diff f x - bw_diff g x)"
	+ by (rule ext) (simp add: bw_diff_def)
	+
	+lemma bw_diff_const_pow: "(bw_diff ^^ k) (\<lambda>_. c) = (if k = 0 then \<lambda>_. c else (\<lambda>_. 0))"
	+ by (induct k, simp_all)
	+
	+lemma bw_diff_id_pow:
	+ "(bw_diff ^^ k) (\<lambda>x. x) = (if k = 0 then (\<lambda>x. x) else if k = 1 then (\<lambda>_. 1) else (\<lambda>_. 0))"
	+ by (induct k, simp_all)
	+
	+lemma bw_diff_plus_pow [simp]:
	+ "(bw_diff ^^ k) (\<lambda>x. f x + g x) = (\<lambda>x. (bw_diff ^^ k) f x + (bw_diff ^^ k) g x)"
	+ by (induct k, simp_all)
	+
	+lemma bw_diff_uminus_pow [simp]: "(bw_diff ^^ k) (\<lambda>x. - f x) = (\<lambda>x. - (bw_diff ^^ k) f x)"
	+ by (induct k, simp_all)
	+
	+lemma bw_diff_minus_pow [simp]:
	+ "(bw_diff ^^ k) (\<lambda>x. f x - g x) = (\<lambda>x. (bw_diff ^^ k) f x - (bw_diff ^^ k) g x)"
	+ by (induct k, simp_all)
	+
	+lemma bw_diff_sum_pow [simp]:
	+ "(bw_diff ^^ k) (\<lambda>x. (\<Sum>i\<in>I. f i x)) = (\<lambda>x. (\<Sum>i\<in>I. (bw_diff ^^ k) (f i) x))"
	+ by (induct I rule: infinite_finite_induct, simp_all add: bw_diff_const_pow)
	+
	+lemma bw_diff_gbinomial:
	+ assumes "0 < k"
	+ shows "bw_diff (\<lambda>x::int. (x + n) gchoose k) = (\<lambda>x. (x + n - 1) gchoose (k - 1))"
	+proof (rule ext)
	+ fix x::int
	+ from assms have eq: "Suc (k - Suc 0) = k" by simp
	+ have "x + n gchoose k = (x + n - 1) + 1 gchoose (Suc (k - 1))" by (simp add: eq)
	+ also have "\<dots> = (x + n - 1) gchoose (k - 1) + ((x + n - 1) gchoose (Suc (k - 1)))"
	+ by (fact gbinomial_int_Suc_Suc)
	+ finally show "bw_diff (\<lambda>x. x + n gchoose k) x = x + n - 1 gchoose (k - 1)"
	+ by (simp add: eq bw_diff_def algebra_simps)
	+qed
	+
	+lemma bw_diff_gbinomial_pow:
	+ "(bw_diff ^^ l) (\<lambda>x::int. (x + n) gchoose k) =
	+ (if l \<le> k then (\<lambda>x. (x + n - int l) gchoose (k - l)) else (\<lambda>_. 0))"
	+proof -
	+ have *: "l0 \<le> k \<Longrightarrow> (bw_diff ^^ l0) (\<lambda>x::int. (x + n) gchoose k) = (\<lambda>x. (x + n - int l0) gchoose (k - l0))"
	+ for l0
	+ proof (induct l0)
	+ case 0
	+ show ?case by simp
	+ next
	+ case (Suc l0)
	+ from Suc.prems have "0 < k - l0" and "l0 \<le> k" by simp_all
	+ from this(2) have eq: "(bw_diff ^^ l0) (\<lambda>x. x + n gchoose k) = (\<lambda>x. x + n - int l0 gchoose (k - l0))"
	+ by (rule Suc.hyps)
	+ have "(bw_diff ^^ Suc l0) (\<lambda>x. x + n gchoose k) = bw_diff (\<lambda>x. x + (n - int l0) gchoose (k - l0))"
	+ by (simp add: eq algebra_simps)
	+ also from \<open>0 < k - l0\<close> have "\<dots> = (\<lambda>x. (x + (n - int l0) - 1) gchoose (k - l0 - 1))"
	+ by (rule bw_diff_gbinomial)
	+ also have "\<dots> = (\<lambda>x. x + n - int (Suc l0) gchoose (k - Suc l0))" by (simp add: algebra_simps)
	+ finally show ?case .
	+ qed
	+ show ?thesis
	+ proof (simp add: * split: if_split, intro impI)
	+ assume "\<not> l \<le> k"
	+ hence "(l - k) + k = l" and "l - k \<noteq> 0" by simp_all
	+ hence "(bw_diff ^^ l) (\<lambda>x. x + n gchoose k) = (bw_diff ^^ ((l - k) + k)) (\<lambda>x. x + n gchoose k)"
	+ by (simp only:)
	+ also have "\<dots> = (bw_diff ^^ (l - k)) (\<lambda>_. 1)" by (simp add: * funpow_add)
	+ also from \<open>l - k \<noteq> 0\<close> have "\<dots> = (\<lambda>_. 0)" by (simp add: bw_diff_const_pow)
	+ finally show "(bw_diff ^^ l) (\<lambda>x. x + n gchoose k) = (\<lambda>_. 0)" .
	+ qed
	+qed
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Cone_Decomposition.thy b/thys/Groebner_Macaulay/Cone_Decomposition.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Cone_Decomposition.thy
	@@ -0,0 +1,4893 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Cone Decompositions\<close>
	+
	+theory Cone_Decomposition
	+ imports Groebner_Bases.Groebner_PM Monomial_Module Hilbert_Function
	+begin
	+
	+subsection \<open>More Properties of Reduced Gr\"obner Bases\<close>
	+
	+context pm_powerprod
	+begin
	+
	+lemmas reduced_GB_subset_monic_Polys =
	+ punit.reduced_GB_subset_monic_dgrad_p_set[simplified, OF dickson_grading_varnum, where m=0, simplified dgrad_p_set_varnum]
	+lemmas reduced_GB_is_monomial_set_Polys =
	+ punit.reduced_GB_is_monomial_set_dgrad_p_set[simplified, OF dickson_grading_varnum, where m=0, simplified dgrad_p_set_varnum]
	+lemmas is_red_reduced_GB_monomial_lt_GB_Polys =
	+ punit.is_red_reduced_GB_monomial_lt_GB_dgrad_p_set[simplified, OF dickson_grading_varnum, where m=0, simplified dgrad_p_set_varnum]
	+lemmas reduced_GB_monomial_lt_reduced_GB_Polys =
	+ punit.reduced_GB_monomial_lt_reduced_GB_dgrad_p_set[simplified, OF dickson_grading_varnum, where m=0, simplified dgrad_p_set_varnum]
	+
	+end
	+
	+subsection \<open>Quotient Ideals\<close>
	+
	+definition quot_set :: "'a set \<Rightarrow> 'a \<Rightarrow> 'a::semigroup_mult set" (infixl "\<div>" 55)
	+ where "quot_set A x = (*) x -` A"
	+
	+lemma quot_set_iff: "a \<in> A \<div> x \<longleftrightarrow> x * a \<in> A"
	+ by (simp add: quot_set_def)
	+
	+lemma quot_setI: "x * a \<in> A \<Longrightarrow> a \<in> A \<div> x"
	+ by (simp only: quot_set_iff)
	+
	+lemma quot_setD: "a \<in> A \<div> x \<Longrightarrow> x * a \<in> A"
	+ by (simp only: quot_set_iff)
	+
	+lemma quot_set_quot_set [simp]: "A \<div> x \<div> y = A \<div> x * y"
	+ by (rule set_eqI) (simp add: quot_set_iff mult.assoc)
	+
	+lemma quot_set_one [simp]: "A \<div> (1::_::monoid_mult) = A"
	+ by (rule set_eqI) (simp add: quot_set_iff)
	+
	+lemma ideal_quot_set_ideal [simp]: "ideal (ideal B \<div> x) = (ideal B) \<div> (x::_::comm_ring)"
	+proof
	+ show "ideal (ideal B \<div> x) \<subseteq> ideal B \<div> x"
	+ proof
	+ fix b
	+ assume "b \<in> ideal (ideal B \<div> x)"
	+ thus "b \<in> ideal B \<div> x"
	+ proof (induct b rule: ideal.span_induct')
	+ case base
	+ show ?case by (simp add: quot_set_iff ideal.span_zero)
	+ next
	+ case (step b q p)
	+ hence "x * b \<in> ideal B" and "x * p \<in> ideal B" by (simp_all add: quot_set_iff)
	+ hence "x * b + q * (x * p) \<in> ideal B"
	+ by (intro ideal.span_add ideal.span_scale[where c=q])
	+ thus ?case by (simp only: quot_set_iff algebra_simps)
	+ qed
	+ qed
	+qed (fact ideal.span_superset)
	+
	+lemma quot_set_image_times: "inj (() x) \<Longrightarrow> (() x ` A) \<div> x = A"
	+ by (simp add: quot_set_def inj_vimage_image_eq)
	+
	+subsection \<open>Direct Decompositions of Polynomial Rings\<close>
	+
	+context pm_powerprod
	+begin
	+
	+definition normal_form :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) set \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::field) \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::field)"
	+ where "normal_form F p = (SOME q. (punit.red (punit.reduced_GB F))\<^sup>\<^sup> p q \<and> \<not> punit.is_red (punit.reduced_GB F) q)"
	+
	+text \<open>Of course, @{const normal_form} could be defined in a much more general context.\<close>
	+
	+context
	+ fixes X :: "'x set"
	+ assumes fin_X: "finite X"
	+begin
	+
	+context
	+ fixes F :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::field) set"
	+ assumes F_sub: "F \<subseteq> P[X]"
	+begin
	+
	+lemma normal_form:
	+ shows "(punit.red (punit.reduced_GB F))\<^sup>\<^sup> p (normal_form F p)" (is ?thesis1)
	+ and "\<not> punit.is_red (punit.reduced_GB F) (normal_form F p)" (is ?thesis2)
	+proof -
	+ from fin_X F_sub have "finite (punit.reduced_GB F)" by (rule finite_reduced_GB_Polys)
	+ hence "wfP (punit.red (punit.reduced_GB F))\<inverse>\<inverse>" by (rule punit.red_wf_finite)
	+ then obtain q where "(punit.red (punit.reduced_GB F))\<^sup>\<^sup> p q"
	+ and "\<not> punit.is_red (punit.reduced_GB F) q" unfolding punit.is_red_def not_not
	+ by (rule relation.wf_imp_nf_ex)
	+ hence "(punit.red (punit.reduced_GB F))\<^sup>\<^sup> p q \<and> \<not> punit.is_red (punit.reduced_GB F) q" ..
	+ hence "?thesis1 \<and> ?thesis2" unfolding normal_form_def by (rule someI)
	+ thus ?thesis1 and ?thesis2 by simp_all
	+qed
	+
	+lemma normal_form_unique:
	+ assumes "(punit.red (punit.reduced_GB F))\<^sup>\<^sup> p q" and "\<not> punit.is_red (punit.reduced_GB F) q"
	+ shows "normal_form F p = q"
	+proof (rule relation.ChurchRosser_unique_final)
	+ from fin_X F_sub have "punit.is_Groebner_basis (punit.reduced_GB F)" by (rule reduced_GB_is_GB_Polys)
	+ thus "relation.is_ChurchRosser (punit.red (punit.reduced_GB F))"
	+ by (simp only: punit.is_Groebner_basis_def)
	+next
	+ show "(punit.red (punit.reduced_GB F))\<^sup>\<^sup> p (normal_form F p)" by (rule normal_form)
	+next
	+ have "\<not> punit.is_red (punit.reduced_GB F) (normal_form F p)" by (rule normal_form)
	+ thus "relation.is_final (punit.red (punit.reduced_GB F)) (normal_form F p)"
	+ by (simp add: punit.is_red_def)
	+next
	+ from assms(2) show "relation.is_final (punit.red (punit.reduced_GB F)) q"
	+ by (simp add: punit.is_red_def)
	+qed fact
	+
	+lemma normal_form_id_iff: "normal_form F p = p \<longleftrightarrow> (\<not> punit.is_red (punit.reduced_GB F) p)"
	+proof
	+ assume "normal_form F p = p"
	+ with normal_form(2)[of p] show "\<not> punit.is_red (punit.reduced_GB F) p" by simp
	+next
	+ assume "\<not> punit.is_red (punit.reduced_GB F) p"
	+ with rtranclp.rtrancl_refl show "normal_form F p = p" by (rule normal_form_unique)
	+qed
	+
	+lemma normal_form_normal_form: "normal_form F (normal_form F p) = normal_form F p"
	+ by (simp add: normal_form_id_iff normal_form)
	+
	+lemma normal_form_zero: "normal_form F 0 = 0"
	+ by (simp add: normal_form_id_iff punit.irred_0)
	+
	+lemma normal_form_map_scale: "normal_form F (c \<cdot> p) = c \<cdot> (normal_form F p)"
	+ by (intro normal_form_unique punit.is_irred_map_scale normal_form)
	+ (simp add: punit.map_scale_eq_monom_mult punit.red_rtrancl_mult normal_form)
	+
	+lemma normal_form_uminus: "normal_form F (- p) = - normal_form F p"
	+ by (intro normal_form_unique punit.red_rtrancl_uminus normal_form)
	+ (simp add: punit.is_red_uminus normal_form)
	+
	+lemma normal_form_plus_normal_form:
	+ "normal_form F (normal_form F p + normal_form F q) = normal_form F p + normal_form F q"
	+ by (intro normal_form_unique rtranclp.rtrancl_refl punit.is_irred_plus normal_form)
	+
	+lemma normal_form_minus_normal_form:
	+ "normal_form F (normal_form F p - normal_form F q) = normal_form F p - normal_form F q"
	+ by (intro normal_form_unique rtranclp.rtrancl_refl punit.is_irred_minus normal_form)
	+
	+lemma normal_form_ideal_Polys: "normal_form (ideal F \<inter> P[X]) = normal_form F"
	+proof -
	+ let ?F = "ideal F \<inter> P[X]"
	+ from fin_X have eq: "punit.reduced_GB ?F = punit.reduced_GB F"
	+ proof (rule reduced_GB_unique_Polys)
	+ from fin_X F_sub show "punit.is_reduced_GB (punit.reduced_GB F)"
	+ by (rule reduced_GB_is_reduced_GB_Polys)
	+ next
	+ from fin_X F_sub have "ideal (punit.reduced_GB F) = ideal F" by (rule reduced_GB_ideal_Polys)
	+ also have "\<dots> = ideal (ideal F \<inter> P[X])"
	+ proof (intro subset_antisym ideal.span_subset_spanI)
	+ from ideal.span_superset[of F] F_sub have "F \<subseteq> ideal F \<inter> P[X]" by simp
	+ thus "F \<subseteq> ideal (ideal F \<inter> P[X])" using ideal.span_superset by (rule subset_trans)
	+ qed blast
	+ finally show "ideal (punit.reduced_GB F) = ideal (ideal F \<inter> P[X])" .
	+ qed blast
	+ show ?thesis by (rule ext) (simp only: normal_form_def eq)
	+qed
	+
	+lemma normal_form_diff_in_ideal: "p - normal_form F p \<in> ideal F"
	+proof -
	+ from normal_form(1) have "p - normal_form F p \<in> ideal (punit.reduced_GB F)"
	+ by (rule punit.red_rtranclp_diff_in_pmdl[simplified])
	+ also from fin_X F_sub have "\<dots> = ideal F" by (rule reduced_GB_ideal_Polys)
	+ finally show ?thesis .
	+qed
	+
	+lemma normal_form_zero_iff: "normal_form F p = 0 \<longleftrightarrow> p \<in> ideal F"
	+proof
	+ assume "normal_form F p = 0"
	+ with normal_form_diff_in_ideal[of p] show "p \<in> ideal F" by simp
	+next
	+ assume "p \<in> ideal F"
	+ hence "p - (p - normal_form F p) \<in> ideal F" using normal_form_diff_in_ideal
	+ by (rule ideal.span_diff)
	+ also from fin_X F_sub have "\<dots> = ideal (punit.reduced_GB F)" by (rule reduced_GB_ideal_Polys[symmetric])
	+ finally have *: "normal_form F p \<in> ideal (punit.reduced_GB F)" by simp
	+ show "normal_form F p = 0"
	+ proof (rule ccontr)
	+ from fin_X F_sub have "punit.is_Groebner_basis (punit.reduced_GB F)" by (rule reduced_GB_is_GB_Polys)
	+ moreover note *
	+ moreover assume "normal_form F p \<noteq> 0"
	+ ultimately obtain g where "g \<in> punit.reduced_GB F" and "g \<noteq> 0"
	+ and a: "lpp g adds lpp (normal_form F p)" by (rule punit.GB_adds_lt[simplified])
	+ note this(1, 2)
	+ moreover from \<open>normal_form F p \<noteq> 0\<close> have "lpp (normal_form F p) \<in> keys (normal_form F p)"
	+ by (rule punit.lt_in_keys)
	+ ultimately have "punit.is_red (punit.reduced_GB F) (normal_form F p)"
	+ using a by (rule punit.is_red_addsI[simplified])
	+ with normal_form(2) show False ..
	+ qed
	+qed
	+
	+lemma normal_form_eq_iff: "normal_form F p = normal_form F q \<longleftrightarrow> p - q \<in> ideal F"
	+proof -
	+ have "p - q - (normal_form F p - normal_form F q) = (p - normal_form F p) - (q - normal_form F q)"
	+ by simp
	+ also from normal_form_diff_in_ideal normal_form_diff_in_ideal have "\<dots> \<in> ideal F"
	+ by (rule ideal.span_diff)
	+ finally have *: "p - q - (normal_form F p - normal_form F q) \<in> ideal F" .
	+ show ?thesis
	+ proof
	+ assume "normal_form F p = normal_form F q"
	+ with * show "p - q \<in> ideal F" by simp
	+ next
	+ assume "p - q \<in> ideal F"
	+ hence "p - q - (p - q - (normal_form F p - normal_form F q)) \<in> ideal F" using *
	+ by (rule ideal.span_diff)
	+ hence "normal_form F (normal_form F p - normal_form F q) = 0" by (simp add: normal_form_zero_iff)
	+ thus "normal_form F p = normal_form F q" by (simp add: normal_form_minus_normal_form)
	+ qed
	+qed
	+
	+lemma Polys_closed_normal_form:
	+ assumes "p \<in> P[X]"
	+ shows "normal_form F p \<in> P[X]"
	+proof -
	+ from fin_X F_sub have "punit.reduced_GB F \<subseteq> P[X]" by (rule reduced_GB_Polys)
	+ with fin_X show ?thesis using assms normal_form(1)
	+ by (rule punit.dgrad_p_set_closed_red_rtrancl[OF dickson_grading_varnum, where m=0, simplified dgrad_p_set_varnum])
	+qed
	+
	+lemma image_normal_form_iff:
	+ "p \<in> normal_form F ` P[X] \<longleftrightarrow> (p \<in> P[X] \<and> \<not> punit.is_red (punit.reduced_GB F) p)"
	+proof
	+ assume "p \<in> normal_form F ` P[X]"
	+ then obtain q where "q \<in> P[X]" and p: "p = normal_form F q" ..
	+ from this(1) show "p \<in> P[X] \<and> \<not> punit.is_red (punit.reduced_GB F) p" unfolding p
	+ by (intro conjI Polys_closed_normal_form normal_form)
	+next
	+ assume "p \<in> P[X] \<and> \<not> punit.is_red (punit.reduced_GB F) p"
	+ hence "p \<in> P[X]" and "\<not> punit.is_red (punit.reduced_GB F) p" by simp_all
	+ from this(2) have "normal_form F p = p" by (simp add: normal_form_id_iff)
	+ from this[symmetric] \<open>p \<in> P[X]\<close> show "p \<in> normal_form F ` P[X]" by (rule image_eqI)
	+qed
	+
	+end
	+
	+lemma direct_decomp_ideal_insert:
	+ fixes F and f
	+ defines "I \<equiv> ideal (insert f F)"
	+ defines "L \<equiv> (ideal F \<div> f) \<inter> P[X]"
	+ assumes "F \<subseteq> P[X]" and "f \<in> P[X]"
	+ shows "direct_decomp (I \<inter> P[X]) [ideal F \<inter> P[X], (*) f ` normal_form L ` P[X]]"
	+ (is "direct_decomp _ ?ss")
	+proof (rule direct_decompI_alt)
	+ fix qs
	+ assume "qs \<in> listset ?ss"
	+ then obtain x y where x: "x \<in> ideal F \<inter> P[X]" and y: "y \<in> (*) f ` normal_form L ` P[X]"
	+ and qs: "qs = [x, y]" by (rule listset_doubletonE)
	+ have "sum_list qs = x + y" by (simp add: qs)
	+ also have "\<dots> \<in> I \<inter> P[X]" unfolding I_def
	+ proof (intro IntI ideal.span_add Polys_closed_plus)
	+ have "ideal F \<subseteq> ideal (insert f F)" by (rule ideal.span_mono) blast
	+ with x show "x \<in> ideal (insert f F)" and "x \<in> P[X]" by blast+
	+ next
	+ from y obtain p where "p \<in> P[X]" and y: "y = f * normal_form L p" by blast
	+ have "f \<in> ideal (insert f F)" by (rule ideal.span_base) simp
	+ hence "normal_form L p * f \<in> ideal (insert f F)" by (rule ideal.span_scale)
	+ thus "y \<in> ideal (insert f F)" by (simp only: mult.commute y)
	+
	+ have "L \<subseteq> P[X]" by (simp add: L_def)
	+ hence "normal_form L p \<in> P[X]" using \<open>p \<in> P[X]\<close> by (rule Polys_closed_normal_form)
	+ with assms(4) show "y \<in> P[X]" unfolding y by (rule Polys_closed_times)
	+ qed
	+ finally show "sum_list qs \<in> I \<inter> P[X]" .
	+next
	+ fix a
	+ assume "a \<in> I \<inter> P[X]"
	+ hence "a \<in> I" and "a \<in> P[X]" by simp_all
	+ from assms(3, 4) have "insert f F \<subseteq> P[X]" by simp
	+ then obtain F0 q0 where "F0 \<subseteq> insert f F" and "finite F0" and q0: "\<And>f0. q0 f0 \<in> P[X]"
	+ and a: "a = (\<Sum>f0\<in>F0. q0 f0 * f0)"
	+ using \<open>a \<in> P[X]\<close> \<open>a \<in> I\<close> unfolding I_def by (rule in_idealE_Polys) blast
	+ obtain q a' where a': "a' \<in> ideal F" and "a' \<in> P[X]" and "q \<in> P[X]" and a: "a = q * f + a'"
	+ proof (cases "f \<in> F0")
	+ case True
	+ with \<open>F0 \<subseteq> insert f F\<close> have "F0 - {f} \<subseteq> F" by blast
	+ show ?thesis
	+ proof
	+ have "(\<Sum>f0\<in>F0 - {f}. q0 f0 * f0) \<in> ideal (F0 - {f})" by (rule ideal.sum_in_spanI)
	+ also from \<open>F0 - {f} \<subseteq> F\<close> have "\<dots> \<subseteq> ideal F" by (rule ideal.span_mono)
	+ finally show "(\<Sum>f0\<in>F0 - {f}. q0 f0 * f0) \<in> ideal F" .
	+ next
	+ show "(\<Sum>f0\<in>F0 - {f}. q0 f0 * f0) \<in> P[X]"
	+ proof (intro Polys_closed_sum Polys_closed_times q0)
	+ fix f0
	+ assume "f0 \<in> F0 - {f}"
	+ also have "\<dots> \<subseteq> F0" by blast
	+ also have "\<dots> \<subseteq> insert f F" by fact
	+ also have "\<dots> \<subseteq> P[X]" by fact
	+ finally show "f0 \<in> P[X]" .
	+ qed
	+ next
	+ from \<open>finite F0\<close> True show "a = q0 f * f + (\<Sum>f0\<in>F0 - {f}. q0 f0 * f0)"
	+ by (simp only: a sum.remove)
	+ qed fact
	+ next
	+ case False
	+ with \<open>F0 \<subseteq> insert f F\<close> have "F0 \<subseteq> F" by blast
	+ show ?thesis
	+ proof
	+ have "a \<in> ideal F0" unfolding a by (rule ideal.sum_in_spanI)
	+ also from \<open>F0 \<subseteq> F\<close> have "\<dots> \<subseteq> ideal F" by (rule ideal.span_mono)
	+ finally show "a \<in> ideal F" .
	+ next
	+ show "a = 0 * f + a" by simp
	+ qed (fact \<open>a \<in> P[X]\<close>, fact zero_in_Polys)
	+ qed
	+ let ?a = "f * (normal_form L q)"
	+ have "L \<subseteq> P[X]" by (simp add: L_def)
	+ hence "normal_form L q \<in> P[X]" using \<open>q \<in> P[X]\<close> by (rule Polys_closed_normal_form)
	+ with assms(4) have "?a \<in> P[X]" by (rule Polys_closed_times)
	+ from \<open>L \<subseteq> P[X]\<close> have "q - normal_form L q \<in> ideal L" by (rule normal_form_diff_in_ideal)
	+ also have "\<dots> \<subseteq> ideal (ideal F \<div> f)" unfolding L_def by (rule ideal.span_mono) blast
	+ finally have "f * (q - normal_form L q) \<in> ideal F" by (simp add: quot_set_iff)
	+ with \<open>a' \<in> ideal F\<close> have "a' + f * (q - normal_form L q) \<in> ideal F" by (rule ideal.span_add)
	+ hence "a - ?a \<in> ideal F" by (simp add: a algebra_simps)
	+
	+ define qs where "qs = [a - ?a, ?a]"
	+ show "\<exists>!qs\<in>listset ?ss. a = sum_list qs"
	+ proof (intro ex1I conjI allI impI)
	+ have "a - ?a \<in> ideal F \<inter> P[X]"
	+ proof
	+ from assms(4) \<open>a \<in> P[X]\<close> \<open>normal_form L q \<in> P[X]\<close> show "a - ?a \<in> P[X]"
	+ by (intro Polys_closed_minus Polys_closed_times)
	+ qed fact
	+ moreover from \<open>q \<in> P[X]\<close> have "?a \<in> (*) f ` normal_form L ` P[X]" by (intro imageI)
	+ ultimately show "qs \<in> listset ?ss" using qs_def by (rule listset_doubletonI)
	+ next
	+ fix qs0
	+ assume "qs0 \<in> listset ?ss \<and> a = sum_list qs0"
	+ hence "qs0 \<in> listset ?ss" and "a = sum_list qs0" by simp_all
	+ from this(1) obtain x y where "x \<in> ideal F \<inter> P[X]" and "y \<in> (*) f ` normal_form L ` P[X]"
	+ and qs0: "qs0 = [x, y]" by (rule listset_doubletonE)
	+ from this(2) obtain a0 where "a0 \<in> P[X]" and y: "y = f * normal_form L a0" by blast
	+ from \<open>x \<in> ideal F \<inter> P[X]\<close> have "x \<in> ideal F" by simp
	+ have x: "x = a - y" by (simp add: \<open>a = sum_list qs0\<close> qs0)
	+ have "f * (normal_form L q - normal_form L a0) = x - (a - ?a)" by (simp add: x y a algebra_simps)
	+ also from \<open>x \<in> ideal F\<close> \<open>a - ?a \<in> ideal F\<close> have "\<dots> \<in> ideal F" by (rule ideal.span_diff)
	+ finally have "normal_form L q - normal_form L a0 \<in> ideal F \<div> f" by (rule quot_setI)
	+ moreover from \<open>L \<subseteq> P[X]\<close> \<open>q \<in> P[X]\<close> \<open>a0 \<in> P[X]\<close> have "normal_form L q - normal_form L a0 \<in> P[X]"
	+ by (intro Polys_closed_minus Polys_closed_normal_form)
	+ ultimately have "normal_form L q - normal_form L a0 \<in> L" by (simp add: L_def)
	+ also have "\<dots> \<subseteq> ideal L" by (fact ideal.span_superset)
	+ finally have "normal_form L q - normal_form L a0 = 0" using \<open>L \<subseteq> P[X]\<close>
	+ by (simp only: normal_form_minus_normal_form flip: normal_form_zero_iff)
	+ thus "qs0 = qs" by (simp add: qs0 qs_def x y)
	+ qed (simp_all add: qs_def)
	+qed
	+
	+corollary direct_decomp_ideal_normal_form:
	+ assumes "F \<subseteq> P[X]"
	+ shows "direct_decomp P[X] [ideal F \<inter> P[X], normal_form F ` P[X]]"
	+proof -
	+ from assms one_in_Polys have "direct_decomp (ideal (insert 1 F) \<inter> P[X]) [ideal F \<inter> P[X],
	+ (*) 1 ` normal_form ((ideal F \<div> 1) \<inter> P[X]) ` P[X]]"
	+ by (rule direct_decomp_ideal_insert)
	+ moreover have "ideal (insert 1 F) = UNIV"
	+ by (simp add: ideal_eq_UNIV_iff_contains_one ideal.span_base)
	+ moreover from refl have "((*) 1 \<circ> normal_form F) ` P[X] = normal_form F ` P[X]"
	+ by (rule image_cong) simp
	+ ultimately show ?thesis using assms by (simp add: image_comp normal_form_ideal_Polys)
	+qed
	+
	+end
	+
	+subsection \<open>Basic Cone Decompositions\<close>
	+
	+definition cone :: "((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::comm_semiring_0) set"
	+ where "cone hU = (*) (fst hU) ` P[snd hU]"
	+
	+lemma coneI: "p = a * h \<Longrightarrow> a \<in> P[U] \<Longrightarrow> p \<in> cone (h, U)"
	+ by (auto simp: cone_def mult.commute[of a])
	+
	+lemma coneE:
	+ assumes "p \<in> cone (h, U)"
	+ obtains a where "a \<in> P[U]" and "p = a * h"
	+ using assms by (auto simp: cone_def mult.commute)
	+
	+lemma cone_empty: "cone (h, {}) = range (\<lambda>c. c \<cdot> h)"
	+ by (auto simp: Polys_empty map_scale_eq_times intro: coneI elim!: coneE)
	+
	+lemma cone_zero [simp]: "cone (0, U) = {0}"
	+ by (auto simp: cone_def intro: zero_in_Polys)
	+
	+lemma cone_one [simp]: "cone (1::_ \<Rightarrow>\<^sub>0 'a::comm_semiring_1, U) = P[U]"
	+ by (auto simp: cone_def)
	+
	+lemma zero_in_cone: "0 \<in> cone hU"
	+ by (auto simp: cone_def intro!: image_eqI zero_in_Polys)
	+
	+corollary empty_not_in_map_cone: "{} \<notin> set (map cone ps)"
	+ using zero_in_cone by fastforce
	+
	+lemma tip_in_cone: "h \<in> cone (h::_ \<Rightarrow>\<^sub>0 _::comm_semiring_1, U)"
	+ using _ one_in_Polys by (rule coneI) simp
	+
	+lemma cone_closed_plus:
	+ assumes "a \<in> cone hU" and "b \<in> cone hU"
	+ shows "a + b \<in> cone hU"
	+proof -
	+ obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ with assms have "a \<in> cone (h, U)" and "b \<in> cone (h, U)" by simp_all
	+ from this(1) obtain a' where "a' \<in> P[U]" and a: "a = a' * h" by (rule coneE)
	+ from \<open>b \<in> cone (h, U)\<close> obtain b' where "b' \<in> P[U]" and b: "b = b' * h" by (rule coneE)
	+ have "a + b = (a' + b') * h" by (simp only: a b algebra_simps)
	+ moreover from \<open>a' \<in> P[U]\<close> \<open>b' \<in> P[U]\<close> have "a' + b' \<in> P[U]" by (rule Polys_closed_plus)
	+ ultimately show ?thesis unfolding hU by (rule coneI)
	+qed
	+
	+lemma cone_closed_uminus:
	+ assumes "(a::_ \<Rightarrow>\<^sub>0 _::comm_ring) \<in> cone hU"
	+ shows "- a \<in> cone hU"
	+proof -
	+ obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ with assms have "a \<in> cone (h, U)" by simp
	+ from this(1) obtain a' where "a' \<in> P[U]" and a: "a = a' * h" by (rule coneE)
	+ have "- a = (- a') * h" by (simp add: a)
	+ moreover from \<open>a' \<in> P[U]\<close> have "- a' \<in> P[U]" by (rule Polys_closed_uminus)
	+ ultimately show ?thesis unfolding hU by (rule coneI)
	+qed
	+
	+lemma cone_closed_minus:
	+ assumes "(a::_ \<Rightarrow>\<^sub>0 _::comm_ring) \<in> cone hU" and "b \<in> cone hU"
	+ shows "a - b \<in> cone hU"
	+proof -
	+ from assms(2) have "- b \<in> cone hU" by (rule cone_closed_uminus)
	+ with assms(1) have "a + (- b) \<in> cone hU" by (rule cone_closed_plus)
	+ thus ?thesis by simp
	+qed
	+
	+lemma cone_closed_times:
	+ assumes "a \<in> cone (h, U)" and "q \<in> P[U]"
	+ shows "q * a \<in> cone (h, U)"
	+proof -
	+ from assms(1) obtain a' where "a' \<in> P[U]" and a: "a = a' * h" by (rule coneE)
	+ have "q * a = (q * a') * h" by (simp only: a ac_simps)
	+ moreover from assms(2) \<open>a' \<in> P[U]\<close> have "q * a' \<in> P[U]" by (rule Polys_closed_times)
	+ ultimately show ?thesis by (rule coneI)
	+qed
	+
	+corollary cone_closed_monom_mult:
	+ assumes "a \<in> cone (h, U)" and "t \<in> .[U]"
	+ shows "punit.monom_mult c t a \<in> cone (h, U)"
	+proof -
	+ from assms(2) have "monomial c t \<in> P[U]" by (rule Polys_closed_monomial)
	+ with assms(1) have "monomial c t * a \<in> cone (h, U)" by (rule cone_closed_times)
	+ thus ?thesis by (simp only: times_monomial_left)
	+qed
	+
	+lemma coneD:
	+ assumes "p \<in> cone (h, U)" and "p \<noteq> 0"
	+ shows "lpp h adds lpp (p::_ \<Rightarrow>\<^sub>0 _::{comm_semiring_0,semiring_no_zero_divisors})"
	+proof -
	+ from assms(1) obtain a where p: "p = a * h" by (rule coneE)
	+ with assms(2) have "a \<noteq> 0" and "h \<noteq> 0" by auto
	+ hence "lpp p = lpp a + lpp h" unfolding p by (rule lp_times)
	+ also have "\<dots> = lpp h + lpp a" by (rule add.commute)
	+ finally show ?thesis by (rule addsI)
	+qed
	+
	+lemma cone_mono_1:
	+ assumes "h' \<in> P[U]"
	+ shows "cone (h' * h, U) \<subseteq> cone (h, U)"
	+proof
	+ fix p
	+ assume "p \<in> cone (h' * h, U)"
	+ then obtain a' where "a' \<in> P[U]" and "p = a' * (h' * h)" by (rule coneE)
	+ from this(2) have "p = a' * h' * h" by (simp only: mult.assoc)
	+ moreover from \<open>a' \<in> P[U]\<close> assms have "a' * h' \<in> P[U]" by (rule Polys_closed_times)
	+ ultimately show "p \<in> cone (h, U)" by (rule coneI)
	+qed
	+
	+lemma cone_mono_2:
	+ assumes "U1 \<subseteq> U2"
	+ shows "cone (h, U1) \<subseteq> cone (h, U2)"
	+proof
	+ from assms have "P[U1] \<subseteq> P[U2]" by (rule Polys_mono)
	+ fix p
	+ assume "p \<in> cone (h, U1)"
	+ then obtain a where "a \<in> P[U1]" and "p = a * h" by (rule coneE)
	+ note this(2)
	+ moreover from \<open>a \<in> P[U1]\<close> \<open>P[U1] \<subseteq> P[U2]\<close> have "a \<in> P[U2]" ..
	+ ultimately show "p \<in> cone (h, U2)" by (rule coneI)
	+qed
	+
	+lemma cone_subsetD:
	+ assumes "cone (h1, U1) \<subseteq> cone (h2::_ \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors}, U2)"
	+ shows "h2 dvd h1" and "h1 \<noteq> 0 \<Longrightarrow> U1 \<subseteq> U2"
	+proof -
	+ from tip_in_cone assms have "h1 \<in> cone (h2, U2)" ..
	+ then obtain a1' where "a1' \<in> P[U2]" and h1: "h1 = a1' * h2" by (rule coneE)
	+ from this(2) have "h1 = h2 * a1'" by (simp only: mult.commute)
	+ thus "h2 dvd h1" ..
	+
	+ assume "h1 \<noteq> 0"
	+ with h1 have "a1' \<noteq> 0" and "h2 \<noteq> 0" by auto
	+ show "U1 \<subseteq> U2"
	+ proof
	+ fix x
	+ assume "x \<in> U1"
	+ hence "monomial (1::'a) (Poly_Mapping.single x 1) \<in> P[U1]" (is "?p \<in> _")
	+ by (intro Polys_closed_monomial PPs_closed_single)
	+ with refl have "?p * h1 \<in> cone (h1, U1)" by (rule coneI)
	+ hence "?p * h1 \<in> cone (h2, U2)" using assms ..
	+ then obtain a where "a \<in> P[U2]" and "?p * h1 = a * h2" by (rule coneE)
	+ from this(2) have "(?p * a1') * h2 = a * h2" by (simp only: h1 ac_simps)
	+ hence "?p * a1' = a" using \<open>h2 \<noteq> 0\<close> by (rule times_canc_right)
	+ with \<open>a \<in> P[U2]\<close> have "a1' * ?p \<in> P[U2]" by (simp add: mult.commute)
	+ hence "?p \<in> P[U2]" using \<open>a1' \<in> P[U2]\<close> \<open>a1' \<noteq> 0\<close> by (rule times_in_PolysD)
	+ thus "x \<in> U2" by (simp add: Polys_def PPs_def)
	+ qed
	+qed
	+
	+lemma cone_subset_PolysD:
	+ assumes "cone (h::_ \<Rightarrow>\<^sub>0 'a::{comm_semiring_1,semiring_no_zero_divisors}, U) \<subseteq> P[X]"
	+ shows "h \<in> P[X]" and "h \<noteq> 0 \<Longrightarrow> U \<subseteq> X"
	+proof -
	+ from tip_in_cone assms show "h \<in> P[X]" ..
	+
	+ assume "h \<noteq> 0"
	+ show "U \<subseteq> X"
	+ proof
	+ fix x
	+ assume "x \<in> U"
	+ hence "monomial (1::'a) (Poly_Mapping.single x 1) \<in> P[U]" (is "?p \<in> _")
	+ by (intro Polys_closed_monomial PPs_closed_single)
	+ with refl have "?p * h \<in> cone (h, U)" by (rule coneI)
	+ hence "?p * h \<in> P[X]" using assms ..
	+ hence "h * ?p \<in> P[X]" by (simp only: mult.commute)
	+ hence "?p \<in> P[X]" using \<open>h \<in> P[X]\<close> \<open>h \<noteq> 0\<close> by (rule times_in_PolysD)
	+ thus "x \<in> X" by (simp add: Polys_def PPs_def)
	+ qed
	+qed
	+
	+lemma cone_subset_PolysI:
	+ assumes "h \<in> P[X]" and "h \<noteq> 0 \<Longrightarrow> U \<subseteq> X"
	+ shows "cone (h, U) \<subseteq> P[X]"
	+proof (cases "h = 0")
	+ case True
	+ thus ?thesis by (simp add: zero_in_Polys)
	+next
	+ case False
	+ hence "U \<subseteq> X" by (rule assms(2))
	+ hence "P[U] \<subseteq> P[X]" by (rule Polys_mono)
	+ show ?thesis
	+ proof
	+ fix a
	+ assume "a \<in> cone (h, U)"
	+ then obtain q where "q \<in> P[U]" and a: "a = q * h" by (rule coneE)
	+ from this(1) \<open>P[U] \<subseteq> P[X]\<close> have "q \<in> P[X]" ..
	+ from this assms(1) show "a \<in> P[X]" unfolding a by (rule Polys_closed_times)
	+ qed
	+qed
	+
	+lemma cone_image_times: "() a ` cone (h, U) = cone (a h, U)"
	+ by (auto simp: ac_simps image_image intro!: image_eqI coneI elim!: coneE)
	+
	+lemma cone_image_times': "() a ` cone hU = cone (apfst (() a) hU)"
	+proof -
	+ obtain h U where "hU = (h, U)" using prod.exhaust by blast
	+ thus ?thesis by (simp add: cone_image_times)
	+qed
	+
	+lemma homogeneous_set_coneI:
	+ assumes "homogeneous h"
	+ shows "homogeneous_set (cone (h, U))"
	+proof (rule homogeneous_setI)
	+ fix a n
	+ assume "a \<in> cone (h, U)"
	+ then obtain q where "q \<in> P[U]" and a: "a = q * h" by (rule coneE)
	+ from this(1) show "hom_component a n \<in> cone (h, U)" unfolding a
	+ proof (induct q rule: poly_mapping_plus_induct)
	+ case 1
	+ show ?case by (simp add: zero_in_cone)
	+ next
	+ case (2 p c t)
	+ have "p \<in> P[U]"
	+ proof (intro PolysI subsetI)
	+ fix s
	+ assume "s \<in> keys p"
	+ moreover from 2(2) this have "s \<notin> keys (monomial c t)" by auto
	+ ultimately have "s \<in> keys (monomial c t + p)" by (rule in_keys_plusI2)
	+ also from 2(4) have "\<dots> \<subseteq> .[U]" by (rule PolysD)
	+ finally show "s \<in> .[U]" .
	+ qed
	+ hence : "hom_component (p h) n \<in> cone (h, U)" by (rule 2(3))
	+ from 2(1) have "t \<in> keys (monomial c t)" by simp
	+ hence "t \<in> keys (monomial c t + p)" using 2(2) by (rule in_keys_plusI1)
	+ also from 2(4) have "\<dots> \<subseteq> .[U]" by (rule PolysD)
	+ finally have "monomial c t \<in> P[U]" by (rule Polys_closed_monomial)
	+ with refl have "monomial c t * h \<in> cone (h, U)" (is "?h \<in> _") by (rule coneI)
	+ from assms have "homogeneous ?h" by (simp add: homogeneous_times)
	+ hence "hom_component ?h n = (?h when n = poly_deg ?h)" by (rule hom_component_of_homogeneous)
	+ with \<open>?h \<in> cone (h, U)\<close> have **: "hom_component ?h n \<in> cone (h, U)"
	+ by (simp add: when_def zero_in_cone)
	+ have "hom_component ((monomial c t + p) * h) n = hom_component ?h n + hom_component (p * h) n"
	+ by (simp only: distrib_right hom_component_plus)
	+ also from ** * have "\<dots> \<in> cone (h, U)" by (rule cone_closed_plus)
	+ finally show ?case .
	+ qed
	+qed
	+
	+lemma subspace_cone: "phull.subspace (cone hU)"
	+ using zero_in_cone cone_closed_plus
	+proof (rule phull.subspaceI)
	+ fix c a
	+ assume "a \<in> cone hU"
	+ moreover obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ ultimately have "a \<in> cone (h, U)" by simp
	+ thus "c \<cdot> a \<in> cone hU" unfolding hU punit.map_scale_eq_monom_mult using zero_in_PPs
	+ by (rule cone_closed_monom_mult)
	+qed
	+
	+lemma direct_decomp_cone_insert:
	+ fixes h :: "_ \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors}"
	+ assumes "x \<notin> U"
	+ shows "direct_decomp (cone (h, insert x U))
	+ [cone (h, U), cone (monomial 1 (Poly_Mapping.single x (Suc 0)) * h, insert x U)]"
	+proof -
	+ let ?x = "Poly_Mapping.single x (Suc 0)"
	+ define xx where "xx = monomial (1::'a) ?x"
	+ show "direct_decomp (cone (h, insert x U)) [cone (h, U), cone (xx * h, insert x U)]"
	+ (is "direct_decomp _ ?ss")
	+ proof (rule direct_decompI_alt)
	+ fix qs
	+ assume "qs \<in> listset ?ss"
	+ then obtain a b where "a \<in> cone (h, U)" and b: "b \<in> cone (xx * h, insert x U)"
	+ and qs: "qs = [a, b]" by (rule listset_doubletonE)
	+ note this(1)
	+ also have "cone (h, U) \<subseteq> cone (h, insert x U)" by (rule cone_mono_2) blast
	+ finally have a: "a \<in> cone (h, insert x U)" .
	+ have "cone (xx * h, insert x U) \<subseteq> cone (h, insert x U)"
	+ by (rule cone_mono_1) (simp add: xx_def Polys_def PPs_closed_single)
	+ with b have "b \<in> cone (h, insert x U)" ..
	+ with a have "a + b \<in> cone (h, insert x U)" by (rule cone_closed_plus)
	+ thus "sum_list qs \<in> cone (h, insert x U)" by (simp add: qs)
	+ next
	+ fix a
	+ assume "a \<in> cone (h, insert x U)"
	+ then obtain q where "q \<in> P[insert x U]" and a: "a = q * h" by (rule coneE)
	+ define qU where "qU = except q (- .[U])"
	+ define qx where "qx = except q .[U]"
	+ have q: "q = qU + qx" by (simp only: qU_def qx_def add.commute flip: except_decomp)
	+ have "qU \<in> P[U]" by (rule PolysI) (simp add: qU_def keys_except)
	+ have x_adds: "?x adds t" if "t \<in> keys qx" for t unfolding adds_poly_mapping le_fun_def
	+ proof
	+ fix y
	+ show "lookup ?x y \<le> lookup t y"
	+ proof (cases "y = x")
	+ case True
	+ from that have "t \<in> keys q" and "t \<notin> .[U]" by (simp_all add: qx_def keys_except)
	+ from \<open>q \<in> P[insert x U]\<close> have "keys q \<subseteq> .[insert x U]" by (rule PolysD)
	+ with \<open>t \<in> keys q\<close> have "t \<in> .[insert x U]" ..
	+ hence "keys t \<subseteq> insert x U" by (rule PPsD)
	+ moreover from \<open>t \<notin> .[U]\<close> have "\<not> keys t \<subseteq> U" by (simp add: PPs_def)
	+ ultimately have "x \<in> keys t" by blast
	+ thus ?thesis by (simp add: lookup_single True in_keys_iff)
	+ next
	+ case False
	+ thus ?thesis by (simp add: lookup_single)
	+ qed
	+ qed
	+ define qx' where "qx' = Poly_Mapping.map_key ((+) ?x) qx"
	+ have lookup_qx': "lookup qx' = (\<lambda>t. lookup qx (?x + t))"
	+ by (rule ext) (simp add: qx'_def map_key.rep_eq)
	+ have "qx' * xx = punit.monom_mult 1 ?x qx'"
	+ by (simp only: xx_def mult.commute flip: times_monomial_left)
	+ also have "\<dots> = qx"
	+ by (auto simp: punit.lookup_monom_mult lookup_qx' add.commute[of ?x] adds_minus
	+ simp flip: not_in_keys_iff_lookup_eq_zero dest: x_adds intro!: poly_mapping_eqI)
	+ finally have qx: "qx = qx' * xx" by (rule sym)
	+ have "qx' \<in> P[insert x U]"
	+ proof (intro PolysI subsetI)
	+ fix t
	+ assume "t \<in> keys qx'"
	+ hence "t + ?x \<in> keys qx" by (simp only: lookup_qx' in_keys_iff not_False_eq_True add.commute)
	+ also have "\<dots> \<subseteq> keys q" by (auto simp: qx_def keys_except)
	+ also from \<open>q \<in> P[insert x U]\<close> have "\<dots> \<subseteq> .[insert x U]" by (rule PolysD)
	+ finally have "(t + ?x) - ?x \<in> .[insert x U]" by (rule PPs_closed_minus)
	+ thus "t \<in> .[insert x U]" by simp
	+ qed
	+ define qs where "qs = [qU * h, qx' * (xx * h)]"
	+ show "\<exists>!qs\<in>listset ?ss. a = sum_list qs"
	+ proof (intro ex1I conjI allI impI)
	+ from refl \<open>qU \<in> P[U]\<close> have "qU * h \<in> cone (h, U)" by (rule coneI)
	+ moreover from refl \<open>qx' \<in> P[insert x U]\<close> have "qx' * (xx * h) \<in> cone (xx * h, insert x U)"
	+ by (rule coneI)
	+ ultimately show "qs \<in> listset ?ss" using qs_def by (rule listset_doubletonI)
	+ next
	+ fix qs0
	+ assume "qs0 \<in> listset ?ss \<and> a = sum_list qs0"
	+ hence "qs0 \<in> listset ?ss" and a0: "a = sum_list qs0" by simp_all
	+ from this(1) obtain p1 p2 where "p1 \<in> cone (h, U)" and p2: "p2 \<in> cone (xx * h, insert x U)"
	+ and qs0: "qs0 = [p1, p2]" by (rule listset_doubletonE)
	+ from this(1) obtain qU0 where "qU0 \<in> P[U]" and p1: "p1 = qU0 * h" by (rule coneE)
	+ from p2 obtain qx0 where p2: "p2 = qx0 * (xx * h)" by (rule coneE)
	+ show "qs0 = qs"
	+ proof (cases "h = 0")
	+ case True
	+ thus ?thesis by (simp add: qs_def qs0 p1 p2)
	+ next
	+ case False
	+ from a0 have "(qU - qU0) * h = (qx0 - qx') * xx * h"
	+ by (simp add: a qs0 p1 p2 q qx algebra_simps)
	+ hence eq: "qU - qU0 = (qx0 - qx') * xx" using False by (rule times_canc_right)
	+ have "qx0 = qx'"
	+ proof (rule ccontr)
	+ assume "qx0 \<noteq> qx'"
	+ hence "qx0 - qx' \<noteq> 0" by simp
	+ moreover have "xx \<noteq> 0" by (simp add: xx_def monomial_0_iff)
	+ ultimately have "lpp ((qx0 - qx') * xx) = lpp (qx0 - qx') + lpp xx"
	+ by (rule lp_times)
	+ also have "lpp xx = ?x" by (simp add: xx_def punit.lt_monomial)
	+ finally have "?x adds lpp (qU - qU0)" by (simp add: eq)
	+ hence "lookup ?x x \<le> lookup (lpp (qU - qU0)) x" by (simp only: adds_poly_mapping le_fun_def)
	+ hence "x \<in> keys (lpp (qU - qU0))" by (simp add: in_keys_iff lookup_single)
	+ moreover have "lpp (qU - qU0) \<in> keys (qU - qU0)"
	+ proof (rule punit.lt_in_keys)
	+ from \<open>qx0 - qx' \<noteq> 0\<close> \<open>xx \<noteq> 0\<close> show "qU - qU0 \<noteq> 0" unfolding eq by (rule times_not_zero)
	+ qed
	+ ultimately have "x \<in> indets (qU - qU0)" by (rule in_indetsI)
	+ from \<open>qU \<in> P[U]\<close> \<open>qU0 \<in> P[U]\<close> have "qU - qU0 \<in> P[U]" by (rule Polys_closed_minus)
	+ hence "indets (qU - qU0) \<subseteq> U" by (rule PolysD)
	+ with \<open>x \<in> indets (qU - qU0)\<close> have "x \<in> U" ..
	+ with assms show False ..
	+ qed
	+ moreover from this eq have "qU0 = qU" by simp
	+ ultimately show ?thesis by (simp only: qs_def qs0 p1 p2)
	+ qed
	+ qed (simp_all add: qs_def a q qx, simp only: algebra_simps)
	+ qed
	+qed
	+
	+definition valid_decomp :: "'x set \<Rightarrow> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::zero) \<times> 'x set) list \<Rightarrow> bool"
	+ where "valid_decomp X ps \<longleftrightarrow> ((\<forall>(h, U)\<in>set ps. h \<in> P[X] \<and> h \<noteq> 0 \<and> U \<subseteq> X))"
	+
	+definition monomial_decomp :: "((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{one,zero}) \<times> 'x set) list \<Rightarrow> bool"
	+ where "monomial_decomp ps \<longleftrightarrow> (\<forall>hU\<in>set ps. is_monomial (fst hU) \<and> punit.lc (fst hU) = 1)"
	+
	+definition hom_decomp :: "((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{one,zero}) \<times> 'x set) list \<Rightarrow> bool"
	+ where "hom_decomp ps \<longleftrightarrow> (\<forall>hU\<in>set ps. homogeneous (fst hU))"
	+
	+definition cone_decomp :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) set \<Rightarrow>
	+ ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::comm_semiring_0) \<times> 'x set) list \<Rightarrow> bool"
	+ where "cone_decomp T ps \<longleftrightarrow> direct_decomp T (map cone ps)"
	+
	+lemma valid_decompI:
	+ "(\<And>h U. (h, U) \<in> set ps \<Longrightarrow> h \<in> P[X]) \<Longrightarrow> (\<And>h U. (h, U) \<in> set ps \<Longrightarrow> h \<noteq> 0) \<Longrightarrow>
	+ (\<And>h U. (h, U) \<in> set ps \<Longrightarrow> U \<subseteq> X) \<Longrightarrow> valid_decomp X ps"
	+ unfolding valid_decomp_def by blast
	+
	+lemma valid_decompD:
	+ assumes "valid_decomp X ps" and "(h, U) \<in> set ps"
	+ shows "h \<in> P[X]" and "h \<noteq> 0" and "U \<subseteq> X"
	+ using assms unfolding valid_decomp_def by blast+
	+
	+lemma valid_decompD_finite:
	+ assumes "finite X" and "valid_decomp X ps" and "(h, U) \<in> set ps"
	+ shows "finite U"
	+proof -
	+ from assms(2, 3) have "U \<subseteq> X" by (rule valid_decompD)
	+ thus ?thesis using assms(1) by (rule finite_subset)
	+qed
	+
	+lemma valid_decomp_Nil: "valid_decomp X []"
	+ by (simp add: valid_decomp_def)
	+
	+lemma valid_decomp_concat:
	+ assumes "\<And>ps. ps \<in> set pss \<Longrightarrow> valid_decomp X ps"
	+ shows "valid_decomp X (concat pss)"
	+proof (rule valid_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set (concat pss)"
	+ then obtain ps where "ps \<in> set pss" and "(h, U) \<in> set ps" unfolding set_concat ..
	+ from this(1) have "valid_decomp X ps" by (rule assms)
	+ thus "h \<in> P[X]" and "h \<noteq> 0" and "U \<subseteq> X" using \<open>(h, U) \<in> set ps\<close> by (rule valid_decompD)+
	+qed
	+
	+corollary valid_decomp_append:
	+ assumes "valid_decomp X ps" and "valid_decomp X qs"
	+ shows "valid_decomp X (ps @ qs)"
	+proof -
	+ have "valid_decomp X (concat [ps, qs])" by (rule valid_decomp_concat) (auto simp: assms)
	+ thus ?thesis by simp
	+qed
	+
	+lemma valid_decomp_map_times:
	+ assumes "valid_decomp X ps" and "s \<in> P[X]" and "s \<noteq> (0::_ \<Rightarrow>\<^sub>0 _::semiring_no_zero_divisors)"
	+ shows "valid_decomp X (map (apfst ((*) s)) ps)"
	+proof (rule valid_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set (map (apfst ((*) s)) ps)"
	+ then obtain x where "x \<in> set ps" and "(h, U) = apfst ((*) s) x" unfolding set_map ..
	+ moreover obtain a b where "x = (a, b)" using prod.exhaust by blast
	+ ultimately have h: "h = s * a" and "(a, U) \<in> set ps" by simp_all
	+ from assms(1) this(2) have "a \<in> P[X]" and "a \<noteq> 0" and "U \<subseteq> X" by (rule valid_decompD)+
	+ from assms(2) this(1) show "h \<in> P[X]" unfolding h by (rule Polys_closed_times)
	+ from assms(3) \<open>a \<noteq> 0\<close> show "h \<noteq> 0" unfolding h by (rule times_not_zero)
	+ from \<open>U \<subseteq> X\<close> show "U \<subseteq> X" .
	+qed
	+
	+lemma monomial_decompI:
	+ "(\<And>h U. (h, U) \<in> set ps \<Longrightarrow> is_monomial h) \<Longrightarrow> (\<And>h U. (h, U) \<in> set ps \<Longrightarrow> punit.lc h = 1) \<Longrightarrow>
	+ monomial_decomp ps"
	+ by (auto simp: monomial_decomp_def)
	+
	+lemma monomial_decompD:
	+ assumes "monomial_decomp ps" and "(h, U) \<in> set ps"
	+ shows "is_monomial h" and "punit.lc h = 1"
	+ using assms by (auto simp: monomial_decomp_def)
	+
	+lemma monomial_decomp_append_iff:
	+ "monomial_decomp (ps @ qs) \<longleftrightarrow> monomial_decomp ps \<and> monomial_decomp qs"
	+ by (auto simp: monomial_decomp_def)
	+
	+lemma monomial_decomp_concat:
	+ "(\<And>ps. ps \<in> set pss \<Longrightarrow> monomial_decomp ps) \<Longrightarrow> monomial_decomp (concat pss)"
	+ by (induct pss) (auto simp: monomial_decomp_def)
	+
	+lemma monomial_decomp_map_times:
	+ assumes "monomial_decomp ps" and "is_monomial f" and "punit.lc f = (1::'a::semiring_1)"
	+ shows "monomial_decomp (map (apfst ((*) f)) ps)"
	+proof (rule monomial_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set (map (apfst ((*) f)) ps)"
	+ then obtain x where "x \<in> set ps" and "(h, U) = apfst ((*) f) x" unfolding set_map ..
	+ moreover obtain a b where "x = (a, b)" using prod.exhaust by blast
	+ ultimately have h: "h = f * a" and "(a, U) \<in> set ps" by simp_all
	+ from assms(1) this(2) have "is_monomial a" and "punit.lc a = 1" by (rule monomial_decompD)+
	+ from this(1) have "monomial (punit.lc a) (lpp a) = a" by (rule punit.monomial_eq_itself)
	+ moreover define t where "t = lpp a"
	+ ultimately have a: "a = monomial 1 t" by (simp only: \<open>punit.lc a = 1\<close>)
	+ from assms(2) have "monomial (punit.lc f) (lpp f) = f" by (rule punit.monomial_eq_itself)
	+ moreover define s where "s = lpp f"
	+ ultimately have f: "f = monomial 1 s" by (simp only: assms(3))
	+ show "is_monomial h" by (simp add: h a f times_monomial_monomial monomial_is_monomial)
	+ show "punit.lc h = 1" by (simp add: h a f times_monomial_monomial)
	+qed
	+
	+lemma monomial_decomp_monomial_in_cone:
	+ assumes "monomial_decomp ps" and "hU \<in> set ps" and "a \<in> cone hU"
	+ shows "monomial (lookup a t) t \<in> cone hU"
	+proof (cases "t \<in> keys a")
	+ case True
	+ obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ with assms(2) have "(h, U) \<in> set ps" by simp
	+ with assms(1) have "is_monomial h" by (rule monomial_decompD)
	+ then obtain c s where h: "h = monomial c s" by (rule is_monomial_monomial)
	+ from assms(3) obtain q where "q \<in> P[U]" and "a = q * h" unfolding hU by (rule coneE)
	+ from this(2) have "a = h * q" by (simp only: mult.commute)
	+ also have "\<dots> = punit.monom_mult c s q" by (simp only: h times_monomial_left)
	+ finally have a: "a = punit.monom_mult c s q" .
	+ with True have "t \<in> keys (punit.monom_mult c s q)" by simp
	+ hence "t \<in> (+) s ` keys q" using punit.keys_monom_mult_subset[simplified] ..
	+ then obtain u where "u \<in> keys q" and t: "t = s + u" ..
	+ note this(1)
	+ also from \<open>q \<in> P[U]\<close> have "keys q \<subseteq> .[U]" by (rule PolysD)
	+ finally have "u \<in> .[U]" .
	+ have "monomial (lookup a t) t = monomial (lookup q u) u * h"
	+ by (simp add: a t punit.lookup_monom_mult h times_monomial_monomial mult.commute)
	+ moreover from \<open>u \<in> .[U]\<close> have "monomial (lookup q u) u \<in> P[U]" by (rule Polys_closed_monomial)
	+ ultimately show ?thesis unfolding hU by (rule coneI)
	+next
	+ case False
	+ thus ?thesis by (simp add: zero_in_cone in_keys_iff)
	+qed
	+
	+lemma monomial_decomp_sum_list_monomial_in_cone:
	+ assumes "monomial_decomp ps" and "a \<in> sum_list ` listset (map cone ps)" and "t \<in> keys a"
	+ obtains c h U where "(h, U) \<in> set ps" and "c \<noteq> 0" and "monomial c t \<in> cone (h, U)"
	+proof -
	+ from assms(2) obtain qs where qs_in: "qs \<in> listset (map cone ps)" and a: "a = sum_list qs" ..
	+ from assms(3) keys_sum_list_subset have "t \<in> Keys (set qs)" unfolding a ..
	+ then obtain q where "q \<in> set qs" and "t \<in> keys q" by (rule in_KeysE)
	+ from this(1) obtain i where "i < length qs" and q: "q = qs ! i" by (metis in_set_conv_nth)
	+ moreover from qs_in have "length qs = length (map cone ps)" by (rule listsetD)
	+ ultimately have "i < length (map cone ps)" by simp
	+ moreover from qs_in this have "qs ! i \<in> (map cone ps) ! i" by (rule listsetD)
	+ ultimately have "ps ! i \<in> set ps" and "q \<in> cone (ps ! i)" by (simp_all add: q)
	+ with assms(1) have *: "monomial (lookup q t) t \<in> cone (ps ! i)"
	+ by (rule monomial_decomp_monomial_in_cone)
	+ obtain h U where psi: "ps ! i = (h, U)" using prod.exhaust by blast
	+ show ?thesis
	+ proof
	+ from \<open>ps ! i \<in> set ps\<close> show "(h, U) \<in> set ps" by (simp only: psi)
	+ next
	+ from \<open>t \<in> keys q\<close> show "lookup q t \<noteq> 0" by (simp add: in_keys_iff)
	+ next
	+ from * show "monomial (lookup q t) t \<in> cone (h, U)" by (simp only: psi)
	+ qed
	+qed
	+
	+lemma hom_decompI: "(\<And>h U. (h, U) \<in> set ps \<Longrightarrow> homogeneous h) \<Longrightarrow> hom_decomp ps"
	+ by (auto simp: hom_decomp_def)
	+
	+lemma hom_decompD: "hom_decomp ps \<Longrightarrow> (h, U) \<in> set ps \<Longrightarrow> homogeneous h"
	+ by (auto simp: hom_decomp_def)
	+
	+lemma hom_decomp_append_iff: "hom_decomp (ps @ qs) \<longleftrightarrow> hom_decomp ps \<and> hom_decomp qs"
	+ by (auto simp: hom_decomp_def)
	+
	+lemma hom_decomp_concat: "(\<And>ps. ps \<in> set pss \<Longrightarrow> hom_decomp ps) \<Longrightarrow> hom_decomp (concat pss)"
	+ by (induct pss) (auto simp: hom_decomp_def)
	+
	+lemma hom_decomp_map_times:
	+ assumes "hom_decomp ps" and "homogeneous f"
	+ shows "hom_decomp (map (apfst ((*) f)) ps)"
	+proof (rule hom_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set (map (apfst ((*) f)) ps)"
	+ then obtain x where "x \<in> set ps" and "(h, U) = apfst ((*) f) x" unfolding set_map ..
	+ moreover obtain a b where "x = (a, b)" using prod.exhaust by blast
	+ ultimately have h: "h = f * a" and "(a, U) \<in> set ps" by simp_all
	+ from assms(1) this(2) have "homogeneous a" by (rule hom_decompD)
	+ with assms(2) show "homogeneous h" unfolding h by (rule homogeneous_times)
	+qed
	+
	+lemma monomial_decomp_imp_hom_decomp:
	+ assumes "monomial_decomp ps"
	+ shows "hom_decomp ps"
	+proof (rule hom_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set ps"
	+ with assms have "is_monomial h" by (rule monomial_decompD)
	+ then obtain c t where h: "h = monomial c t" by (rule is_monomial_monomial)
	+ show "homogeneous h" unfolding h by (fact homogeneous_monomial)
	+qed
	+
	+lemma cone_decompI: "direct_decomp T (map cone ps) \<Longrightarrow> cone_decomp T ps"
	+ unfolding cone_decomp_def by blast
	+
	+lemma cone_decompD: "cone_decomp T ps \<Longrightarrow> direct_decomp T (map cone ps)"
	+ unfolding cone_decomp_def by blast
	+
	+lemma cone_decomp_cone_subset:
	+ assumes "cone_decomp T ps" and "hU \<in> set ps"
	+ shows "cone hU \<subseteq> T"
	+proof
	+ fix p
	+ assume "p \<in> cone hU"
	+ from assms(2) obtain i where "i < length ps" and hU: "hU = ps ! i" by (metis in_set_conv_nth)
	+ define qs where "qs = (map 0 ps)[i := p]"
	+ have "sum_list qs \<in> T"
	+ proof (intro direct_decompD listsetI)
	+ from assms(1) show "direct_decomp T (map cone ps)" by (rule cone_decompD)
	+ next
	+ fix j
	+ assume "j < length (map cone ps)"
	+ with \<open>i < length ps\<close> \<open>p \<in> cone hU\<close> show "qs ! j \<in> map cone ps ! j"
	+ by (auto simp: qs_def nth_list_update zero_in_cone hU)
	+ qed (simp add: qs_def)
	+ also have "sum_list qs = qs ! i" by (rule sum_list_eq_nthI) (simp_all add: qs_def \<open>i < length ps\<close>)
	+ also from \<open>i < length ps\<close> have "\<dots> = p" by (simp add: qs_def)
	+ finally show "p \<in> T" .
	+qed
	+
	+lemma cone_decomp_indets:
	+ assumes "cone_decomp T ps" and "T \<subseteq> P[X]" and "(h, U) \<in> set ps"
	+ shows "h \<in> P[X]" and "h \<noteq> (0::_ \<Rightarrow>\<^sub>0 _::{comm_semiring_1,semiring_no_zero_divisors}) \<Longrightarrow> U \<subseteq> X"
	+proof -
	+ from assms(1, 3) have "cone (h, U) \<subseteq> T" by (rule cone_decomp_cone_subset)
	+ hence "cone (h, U) \<subseteq> P[X]" using assms(2) by (rule subset_trans)
	+ thus "h \<in> P[X]" and "h \<noteq> 0 \<Longrightarrow> U \<subseteq> X" by (rule cone_subset_PolysD)+
	+qed
	+
	+lemma cone_decomp_closed_plus:
	+ assumes "cone_decomp T ps" and "a \<in> T" and "b \<in> T"
	+ shows "a + b \<in> T"
	+proof -
	+ from assms(1) have dd: "direct_decomp T (map cone ps)" by (rule cone_decompD)
	+ then obtain qsa where qsa: "qsa \<in> listset (map cone ps)" and a: "a = sum_list qsa" using assms(2)
	+ by (rule direct_decompE)
	+ from dd assms(3) obtain qsb where qsb: "qsb \<in> listset (map cone ps)" and b: "b = sum_list qsb"
	+ by (rule direct_decompE)
	+ from qsa have "length qsa = length (map cone ps)" by (rule listsetD)
	+ moreover from qsb have "length qsb = length (map cone ps)" by (rule listsetD)
	+ ultimately have "a + b = sum_list (map2 (+) qsa qsb)" by (simp only: sum_list_map2_plus a b)
	+ also from dd have "sum_list (map2 (+) qsa qsb) \<in> T"
	+ proof (rule direct_decompD)
	+ from qsa qsb show "map2 (+) qsa qsb \<in> listset (map cone ps)"
	+ proof (rule listset_closed_map2)
	+ fix c p1 p2
	+ assume "c \<in> set (map cone ps)"
	+ then obtain hU where c: "c = cone hU" by auto
	+ assume "p1 \<in> c" and "p2 \<in> c"
	+ thus "p1 + p2 \<in> c" unfolding c by (rule cone_closed_plus)
	+ qed
	+ qed
	+ finally show ?thesis .
	+qed
	+
	+lemma cone_decomp_closed_uminus:
	+ assumes "cone_decomp T ps" and "(a::_ \<Rightarrow>\<^sub>0 _::comm_ring) \<in> T"
	+ shows "- a \<in> T"
	+proof -
	+ from assms(1) have dd: "direct_decomp T (map cone ps)" by (rule cone_decompD)
	+ then obtain qsa where qsa: "qsa \<in> listset (map cone ps)" and a: "a = sum_list qsa" using assms(2)
	+ by (rule direct_decompE)
	+ from qsa have "length qsa = length (map cone ps)" by (rule listsetD)
	+ have "- a = sum_list (map uminus qsa)" unfolding a by (induct qsa, simp_all)
	+ also from dd have "\<dots> \<in> T"
	+ proof (rule direct_decompD)
	+ from qsa show "map uminus qsa \<in> listset (map cone ps)"
	+ proof (rule listset_closed_map)
	+ fix c p
	+ assume "c \<in> set (map cone ps)"
	+ then obtain hU where c: "c = cone hU" by auto
	+ assume "p \<in> c"
	+ thus "- p \<in> c" unfolding c by (rule cone_closed_uminus)
	+ qed
	+ qed
	+ finally show ?thesis .
	+qed
	+
	+corollary cone_decomp_closed_minus:
	+ assumes "cone_decomp T ps" and "(a::_ \<Rightarrow>\<^sub>0 _::comm_ring) \<in> T" and "b \<in> T"
	+ shows "a - b \<in> T"
	+proof -
	+ from assms(1, 3) have "- b \<in> T" by (rule cone_decomp_closed_uminus)
	+ with assms(1, 2) have "a + (- b) \<in> T" by (rule cone_decomp_closed_plus)
	+ thus ?thesis by simp
	+qed
	+
	+lemma cone_decomp_Nil: "cone_decomp {0} []"
	+ by (auto simp: cone_decomp_def intro: direct_decompI_alt)
	+
	+lemma cone_decomp_singleton: "cone_decomp (cone (t, U)) [(t, U)]"
	+ by (simp add: cone_decomp_def direct_decomp_singleton)
	+
	+lemma cone_decomp_append:
	+ assumes "direct_decomp T [S1, S2]" and "cone_decomp S1 ps" and "cone_decomp S2 qs"
	+ shows "cone_decomp T (ps @ qs)"
	+proof (rule cone_decompI)
	+ from assms(2) have "direct_decomp S1 (map cone ps)" by (rule cone_decompD)
	+ with assms(1) have "direct_decomp T ([S2] @ map cone ps)" by (rule direct_decomp_direct_decomp)
	+ hence "direct_decomp T (S2 # map cone ps)" by simp
	+ moreover from assms(3) have "direct_decomp S2 (map cone qs)" by (rule cone_decompD)
	+ ultimately have "direct_decomp T (map cone ps @ map cone qs)" by (intro direct_decomp_direct_decomp)
	+ thus "direct_decomp T (map cone (ps @ qs))" by simp
	+qed
	+
	+lemma cone_decomp_concat:
	+ assumes "direct_decomp T ss" and "length pss = length ss"
	+ and "\<And>i. i < length ss \<Longrightarrow> cone_decomp (ss ! i) (pss ! i)"
	+ shows "cone_decomp T (concat pss)"
	+ using assms(2, 1, 3)
	+proof (induct pss ss arbitrary: T rule: list_induct2)
	+ case Nil
	+ from Nil(1) show ?case by (simp add: cone_decomp_def)
	+next
	+ case (Cons ps pss s ss)
	+ have "0 < length (s # ss)" by simp
	+ hence "cone_decomp ((s # ss) ! 0) ((ps # pss) ! 0)" by (rule Cons.prems)
	+ hence "cone_decomp s ps" by simp
	+ hence *: "direct_decomp s (map cone ps)" by (rule cone_decompD)
	+ with Cons.prems(1) have "direct_decomp T (ss @ map cone ps)" by (rule direct_decomp_direct_decomp)
	+ hence 1: "direct_decomp T [sum_list ` listset ss, sum_list ` listset (map cone ps)]"
	+ and 2: "direct_decomp (sum_list ` listset ss) ss"
	+ by (auto dest: direct_decomp_appendD intro!: empty_not_in_map_cone)
	+ note 1
	+ moreover from 2 have "cone_decomp (sum_list ` listset ss) (concat pss)"
	+ proof (rule Cons.hyps)
	+ fix i
	+ assume "i < length ss"
	+ hence "Suc i < length (s # ss)" by simp
	+ hence "cone_decomp ((s # ss) ! Suc i) ((ps # pss) ! Suc i)" by (rule Cons.prems)
	+ thus "cone_decomp (ss ! i) (pss ! i)" by simp
	+ qed
	+ moreover have "cone_decomp (sum_list ` listset (map cone ps)) ps"
	+ proof (intro cone_decompI direct_decompI refl)
	+ from * show "inj_on sum_list (listset (map cone ps))"
	+ by (simp only: direct_decomp_def bij_betw_def)
	+ qed
	+ ultimately have "cone_decomp T (concat pss @ ps)" by (rule cone_decomp_append)
	+ hence "direct_decomp T (map cone (concat pss) @ map cone ps)" by (simp add: cone_decomp_def)
	+ hence "direct_decomp T (map cone ps @ map cone (concat pss))"
	+ using perm_append_swap by (rule direct_decomp_perm)
	+ thus ?case by (simp add: cone_decomp_def)
	+qed
	+
	+lemma cone_decomp_map_times:
	+ assumes "cone_decomp T ps"
	+ shows "cone_decomp (() s ` T) (map (apfst (() (s::_ \<Rightarrow>\<^sub>0 _::{comm_ring_1,ring_no_zero_divisors}))) ps)"
	+proof (rule cone_decompI)
	+ from assms have "direct_decomp T (map cone ps)" by (rule cone_decompD)
	+ hence "direct_decomp (() s ` T) (map ((`) (() s)) (map cone ps))"
	+ by (rule direct_decomp_image_times) (rule times_canc_left)
	+ also have "map ((`) (() s)) (map cone ps) = map cone (map (apfst (() s)) ps)"
	+ by (simp add: cone_image_times')
	+ finally show "direct_decomp (() s ` T) (map cone (map (apfst (() s)) ps))" .
	+qed
	+
	+lemma cone_decomp_perm:
	+ assumes "cone_decomp T ps" and "perm ps qs"
	+ shows "cone_decomp T qs"
	+ using assms(1) unfolding cone_decomp_def
	+proof (rule direct_decomp_perm)
	+ from assms(2) show "perm (map cone ps) (map cone qs)"
	+ by (induct ps qs rule: perm.induct) auto
	+qed
	+
	+lemma valid_cone_decomp_subset_Polys:
	+ assumes "valid_decomp X ps" and "cone_decomp T ps"
	+ shows "T \<subseteq> P[X]"
	+proof
	+ fix p
	+ assume "p \<in> T"
	+ from assms(2) have "direct_decomp T (map cone ps)" by (rule cone_decompD)
	+ then obtain qs where "qs \<in> listset (map cone ps)" and p: "p = sum_list qs" using \<open>p \<in> T\<close>
	+ by (rule direct_decompE)
	+ from assms(1) this(1) show "p \<in> P[X]" unfolding p
	+ proof (induct ps arbitrary: qs)
	+ case Nil
	+ from Nil(2) show ?case by (simp add: zero_in_Polys)
	+ next
	+ case (Cons a ps)
	+ obtain h U where a: "a = (h, U)" using prod.exhaust by blast
	+ hence "(h, U) \<in> set (a # ps)" by simp
	+ with Cons.prems(1) have "h \<in> P[X]" and "U \<subseteq> X" by (rule valid_decompD)+
	+ hence "cone a \<subseteq> P[X]" unfolding a by (rule cone_subset_PolysI)
	+ from Cons.prems(1) have "valid_decomp X ps" by (simp add: valid_decomp_def)
	+ from Cons.prems(2) have "qs \<in> listset (cone a # map cone ps)" by simp
	+ then obtain q qs' where "q \<in> cone a" and qs': "qs' \<in> listset (map cone ps)" and qs: "qs = q # qs'"
	+ by (rule listset_ConsE)
	+ from this(1) \<open>cone a \<subseteq> P[X]\<close> have "q \<in> P[X]" ..
	+ moreover from \<open>valid_decomp X ps\<close> qs' have "sum_list qs' \<in> P[X]" by (rule Cons.hyps)
	+ ultimately have "q + sum_list qs' \<in> P[X]" by (rule Polys_closed_plus)
	+ thus ?case by (simp add: qs)
	+ qed
	+qed
	+
	+lemma homogeneous_set_cone_decomp:
	+ assumes "cone_decomp T ps" and "hom_decomp ps"
	+ shows "homogeneous_set T"
	+proof (rule homogeneous_set_direct_decomp)
	+ from assms(1) show "direct_decomp T (map cone ps)" by (rule cone_decompD)
	+next
	+ fix cn
	+ assume "cn \<in> set (map cone ps)"
	+ then obtain hU where "hU \<in> set ps" and cn: "cn = cone hU" unfolding set_map ..
	+ moreover obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ ultimately have "(h, U) \<in> set ps" by simp
	+ with assms(2) have "homogeneous h" by (rule hom_decompD)
	+ thus "homogeneous_set cn" unfolding cn hU by (rule homogeneous_set_coneI)
	+qed
	+
	+lemma subspace_cone_decomp:
	+ assumes "cone_decomp T ps"
	+ shows "phull.subspace (T::(_ \<Rightarrow>\<^sub>0 _::field) set)"
	+proof (rule phull.subspace_direct_decomp)
	+ from assms show "direct_decomp T (map cone ps)" by (rule cone_decompD)
	+next
	+ fix cn
	+ assume "cn \<in> set (map cone ps)"
	+ then obtain hU where "hU \<in> set ps" and cn: "cn = cone hU" unfolding set_map ..
	+ show "phull.subspace cn" unfolding cn by (rule subspace_cone)
	+qed
	+
	+definition pos_decomp :: "((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list \<Rightarrow> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list"
	+ ("(_\<^sub>+)" [1000] 999)
	+ where "pos_decomp ps = filter (\<lambda>p. snd p \<noteq> {}) ps"
	+
	+definition standard_decomp :: "nat \<Rightarrow> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::zero) \<times> 'x set) list \<Rightarrow> bool"
	+ where "standard_decomp k ps \<longleftrightarrow> (\<forall>(h, U)\<in>set (ps\<^sub>+). k \<le> poly_deg h \<and>
	+ (\<forall>d. k \<le> d \<longrightarrow> d \<le> poly_deg h \<longrightarrow>
	+ (\<exists>(h', U')\<in>set ps. poly_deg h' = d \<and> card U \<le> card U')))"
	+
	+lemma pos_decomp_Nil [simp]: "[]\<^sub>+ = []"
	+ by (simp add: pos_decomp_def)
	+
	+lemma pos_decomp_subset: "set (ps\<^sub>+) \<subseteq> set ps"
	+ by (simp add: pos_decomp_def)
	+
	+lemma pos_decomp_append: "(ps @ qs)\<^sub>+ = ps\<^sub>+ @ qs\<^sub>+"
	+ by (simp add: pos_decomp_def)
	+
	+lemma pos_decomp_concat: "(concat pss)\<^sub>+ = concat (map pos_decomp pss)"
	+ by (metis (mono_tags, lifting) filter_concat map_eq_conv pos_decomp_def)
	+
	+lemma pos_decomp_map: "(map (apfst f) ps)\<^sub>+ = map (apfst f) (ps\<^sub>+)"
	+ by (metis (mono_tags, lifting) pos_decomp_def filter_cong filter_map o_apply snd_apfst)
	+
	+lemma card_Diff_pos_decomp: "card {(h, U) \<in> set qs - set (qs\<^sub>+). P h} = card {h. (h, {}) \<in> set qs \<and> P h}"
	+proof -
	+ have "{h. (h, {}) \<in> set qs \<and> P h} = fst ` {(h, U) \<in> set qs - set (qs\<^sub>+). P h}"
	+ by (auto simp: pos_decomp_def image_Collect)
	+ also have "card \<dots> = card {(h, U) \<in> set qs - set (qs\<^sub>+). P h}"
	+ by (rule card_image, auto simp: pos_decomp_def intro: inj_onI)
	+ finally show ?thesis by (rule sym)
	+qed
	+
	+lemma standard_decompI:
	+ assumes "\<And>h U. (h, U) \<in> set (ps\<^sub>+) \<Longrightarrow> k \<le> poly_deg h"
	+ and "\<And>h U d. (h, U) \<in> set (ps\<^sub>+) \<Longrightarrow> k \<le> d \<Longrightarrow> d \<le> poly_deg h \<Longrightarrow>
	+ (\<exists>h' U'. (h', U') \<in> set ps \<and> poly_deg h' = d \<and> card U \<le> card U')"
	+ shows "standard_decomp k ps"
	+ unfolding standard_decomp_def using assms by blast
	+
	+lemma standard_decompD: "standard_decomp k ps \<Longrightarrow> (h, U) \<in> set (ps\<^sub>+) \<Longrightarrow> k \<le> poly_deg h"
	+ unfolding standard_decomp_def by blast
	+
	+lemma standard_decompE:
	+ assumes "standard_decomp k ps" and "(h, U) \<in> set (ps\<^sub>+)" and "k \<le> d" and "d \<le> poly_deg h"
	+ obtains h' U' where "(h', U') \<in> set ps" and "poly_deg h' = d" and "card U \<le> card U'"
	+ using assms unfolding standard_decomp_def by blast
	+
	+lemma standard_decomp_Nil: "ps\<^sub>+ = [] \<Longrightarrow> standard_decomp k ps"
	+ by (simp add: standard_decomp_def)
	+
	+lemma standard_decomp_singleton: "standard_decomp (poly_deg h) [(h, U)]"
	+ by (simp add: standard_decomp_def pos_decomp_def)
	+
	+lemma standard_decomp_concat:
	+ assumes "\<And>ps. ps \<in> set pss \<Longrightarrow> standard_decomp k ps"
	+ shows "standard_decomp k (concat pss)"
	+proof (rule standard_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set ((concat pss)\<^sub>+)"
	+ then obtain ps where "ps \<in> set pss" and *: "(h, U) \<in> set (ps\<^sub>+)" by (auto simp: pos_decomp_concat)
	+ from this(1) have "standard_decomp k ps" by (rule assms)
	+ thus "k \<le> poly_deg h" using * by (rule standard_decompD)
	+
	+ fix d
	+ assume "k \<le> d" and "d \<le> poly_deg h"
	+ with \<open>standard_decomp k ps\<close> * obtain h' U' where "(h', U') \<in> set ps" and "poly_deg h' = d"
	+ and "card U \<le> card U'" by (rule standard_decompE)
	+ note this(2, 3)
	+ moreover from \<open>(h', U') \<in> set ps\<close> \<open>ps \<in> set pss\<close> have "(h', U') \<in> set (concat pss)" by auto
	+ ultimately show "\<exists>h' U'. (h', U') \<in> set (concat pss) \<and> poly_deg h' = d \<and> card U \<le> card U'"
	+ by blast
	+qed
	+
	+corollary standard_decomp_append:
	+ assumes "standard_decomp k ps" and "standard_decomp k qs"
	+ shows "standard_decomp k (ps @ qs)"
	+proof -
	+ have "standard_decomp k (concat [ps, qs])" by (rule standard_decomp_concat) (auto simp: assms)
	+ thus ?thesis by simp
	+qed
	+
	+lemma standard_decomp_map_times:
	+ assumes "standard_decomp k ps" and "valid_decomp X ps" and "s \<noteq> (0::_ \<Rightarrow>\<^sub>0 'a::semiring_no_zero_divisors)"
	+ shows "standard_decomp (k + poly_deg s) (map (apfst ((*) s)) ps)"
	+proof (rule standard_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set ((map (apfst ((*) s)) ps)\<^sub>+)"
	+ then obtain h0 where 1: "(h0, U) \<in> set (ps\<^sub>+)" and h: "h = s * h0" by (fastforce simp: pos_decomp_map)
	+ from this(1) pos_decomp_subset have "(h0, U) \<in> set ps" ..
	+ with assms(2) have "h0 \<noteq> 0" by (rule valid_decompD)
	+ with assms(3) have deg_h: "poly_deg h = poly_deg s + poly_deg h0" unfolding h by (rule poly_deg_times)
	+ moreover from assms(1) 1 have "k \<le> poly_deg h0" by (rule standard_decompD)
	+ ultimately show "k + poly_deg s \<le> poly_deg h" by simp
	+
	+ fix d
	+ assume "k + poly_deg s \<le> d" and "d \<le> poly_deg h"
	+ hence "k \<le> d - poly_deg s" and "d - poly_deg s \<le> poly_deg h0" by (simp_all add: deg_h)
	+ with assms(1) 1 obtain h' U' where 2: "(h', U') \<in> set ps" and "poly_deg h' = d - poly_deg s"
	+ and "card U \<le> card U'" by (rule standard_decompE)
	+ from assms(2) this(1) have "h' \<noteq> 0" by (rule valid_decompD)
	+ with assms(3) have deg_h': "poly_deg (s * h') = poly_deg s + poly_deg h'" by (rule poly_deg_times)
	+ from 2 have "(s * h', U') \<in> set (map (apfst ((*) s)) ps)" by force
	+ moreover from \<open>k + poly_deg s \<le> d\<close> \<open>poly_deg h' = d - poly_deg s\<close> have "poly_deg (s * h') = d"
	+ by (simp add: deg_h')
	+ ultimately show "\<exists>h' U'. (h', U') \<in> set (map (apfst ((*) s)) ps) \<and> poly_deg h' = d \<and> card U \<le> card U'"
	+ using \<open>card U \<le> card U'\<close> by fastforce
	+qed
	+
	+lemma standard_decomp_nonempty_unique:
	+ assumes "finite X" and "valid_decomp X ps" and "standard_decomp k ps" and "ps\<^sub>+ \<noteq> []"
	+ shows "k = Min (poly_deg ` fst ` set (ps\<^sub>+))"
	+proof -
	+ let ?A = "poly_deg ` fst ` set (ps\<^sub>+)"
	+ define m where "m = Min ?A"
	+ have "finite ?A" by simp
	+ moreover from assms(4) have "?A \<noteq> {}" by simp
	+ ultimately have "m \<in> ?A" unfolding m_def by (rule Min_in)
	+ then obtain h U where "(h, U) \<in> set (ps\<^sub>+)" and m: "m = poly_deg h" by fastforce
	+ have m_min: "m \<le> poly_deg h'" if "(h', U') \<in> set (ps\<^sub>+)" for h' U'
	+ proof -
	+ from that have "poly_deg (fst (h', U')) \<in> ?A" by (intro imageI)
	+ with \<open>finite ?A\<close> have "m \<le> poly_deg (fst (h', U'))" unfolding m_def by (rule Min_le)
	+ thus ?thesis by simp
	+ qed
	+ show ?thesis
	+ proof (rule linorder_cases)
	+ assume "k < m"
	+ hence "k \<le> poly_deg h" by (simp add: m)
	+ with assms(3) \<open>(h, U) \<in> set (ps\<^sub>+)\<close> le_refl obtain h' U'
	+ where "(h', U') \<in> set ps" and "poly_deg h' = k" and "card U \<le> card U'" by (rule standard_decompE)
	+ from this(2) \<open>k < m\<close> have "\<not> m \<le> poly_deg h'" by simp
	+ with m_min have "(h', U') \<notin> set (ps\<^sub>+)" by blast
	+ with \<open>(h', U') \<in> set ps\<close> have "U' = {}" by (simp add: pos_decomp_def)
	+ with \<open>card U \<le> card U'\<close> have "U = {} \<or> infinite U" by (simp add: card_eq_0_iff)
	+ thus ?thesis
	+ proof
	+ assume "U = {}"
	+ with \<open>(h, U) \<in> set (ps\<^sub>+)\<close> show ?thesis by (simp add: pos_decomp_def)
	+ next
	+ assume "infinite U"
	+ moreover from assms(1, 2) have "finite U"
	+ proof (rule valid_decompD_finite)
	+ from \<open>(h, U) \<in> set (ps\<^sub>+)\<close> show "(h, U) \<in> set ps" by (simp add: pos_decomp_def)
	+ qed
	+ ultimately show ?thesis ..
	+ qed
	+ next
	+ assume "m < k"
	+ hence "\<not> k \<le> m" by simp
	+ moreover from assms(3) \<open>(h, U) \<in> set (ps\<^sub>+)\<close> have "k \<le> m" unfolding m by (rule standard_decompD)
	+ ultimately show ?thesis ..
	+ qed (simp only: m_def)
	+qed
	+
	+lemma standard_decomp_SucE:
	+ assumes "finite X" and "U \<subseteq> X" and "h \<in> P[X]" and "h \<noteq> (0::_ \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors})"
	+ obtains ps where "valid_decomp X ps" and "cone_decomp (cone (h, U)) ps"
	+ and "standard_decomp (Suc (poly_deg h)) ps"
	+ and "is_monomial h \<Longrightarrow> punit.lc h = 1 \<Longrightarrow> monomial_decomp ps" and "homogeneous h \<Longrightarrow> hom_decomp ps"
	+proof -
	+ from assms(2, 1) have "finite U" by (rule finite_subset)
	+ thus ?thesis using assms(2) that
	+ proof (induct U arbitrary: thesis rule: finite_induct)
	+ case empty
	+ from assms(3, 4) have "valid_decomp X [(h, {})]" by (simp add: valid_decomp_def)
	+ moreover note cone_decomp_singleton
	+ moreover have "standard_decomp (Suc (poly_deg h)) [(h, {})]"
	+ by (rule standard_decomp_Nil) (simp add: pos_decomp_def)
	+ ultimately show ?case by (rule empty) (simp_all add: monomial_decomp_def hom_decomp_def)
	+ next
	+ case (insert x U)
	+ from insert.prems(1) have "x \<in> X" and "U \<subseteq> X" by simp_all
	+ from this(2) obtain ps where 0: "valid_decomp X ps" and 1: "cone_decomp (cone (h, U)) ps"
	+ and 2: "standard_decomp (Suc (poly_deg h)) ps"
	+ and 3: "is_monomial h \<Longrightarrow> punit.lc h = 1 \<Longrightarrow> monomial_decomp ps"
	+ and 4: "homogeneous h \<Longrightarrow> hom_decomp ps" by (rule insert.hyps) blast
	+ let ?x = "monomial (1::'a) (Poly_Mapping.single x (Suc 0))"
	+ have "?x \<noteq> 0" by (simp add: monomial_0_iff)
	+ with assms(4) have deg: "poly_deg (?x * h) = Suc (poly_deg h)"
	+ by (simp add: poly_deg_times poly_deg_monomial deg_pm_single)
	+ define qs where "qs = [(?x * h, insert x U)]"
	+ show ?case
	+ proof (rule insert.prems)
	+ from \<open>x \<in> X\<close> have "?x \<in> P[X]" by (intro Polys_closed_monomial PPs_closed_single)
	+ hence "?x * h \<in> P[X]" using assms(3) by (rule Polys_closed_times)
	+ moreover from \<open>?x \<noteq> 0\<close> assms(4) have "?x * h \<noteq> 0" by (rule times_not_zero)
	+ ultimately have "valid_decomp X qs" using insert.hyps(1) \<open>x \<in> X\<close> \<open>U \<subseteq> X\<close>
	+ by (simp add: qs_def valid_decomp_def)
	+ with 0 show "valid_decomp X (ps @ qs)" by (rule valid_decomp_append)
	+ next
	+ show "cone_decomp (cone (h, insert x U)) (ps @ qs)"
	+ proof (rule cone_decomp_append)
	+ show "direct_decomp (cone (h, insert x U)) [cone (h, U), cone (?x * h, insert x U)]"
	+ using insert.hyps(2) by (rule direct_decomp_cone_insert)
	+ next
	+ show "cone_decomp (cone (?x * h, insert x U)) qs"
	+ by (simp add: qs_def cone_decomp_singleton)
	+ qed (fact 1)
	+ next
	+ from standard_decomp_singleton[of "?x * h" "insert x U"]
	+ have "standard_decomp (Suc (poly_deg h)) qs" by (simp add: deg qs_def)
	+ with 2 show "standard_decomp (Suc (poly_deg h)) (ps @ qs)" by (rule standard_decomp_append)
	+ next
	+ assume "is_monomial h" and "punit.lc h = 1"
	+ hence "monomial_decomp ps" by (rule 3)
	+ moreover have "monomial_decomp qs"
	+ proof -
	+ have "is_monomial (?x * h)"
	+ by (metis \<open>is_monomial h\<close> is_monomial_monomial monomial_is_monomial mult.commute
	+ mult.right_neutral mult_single)
	+ thus ?thesis by (simp add: monomial_decomp_def qs_def lc_times \<open>punit.lc h = 1\<close>)
	+ qed
	+ ultimately show "monomial_decomp (ps @ qs)" by (simp only: monomial_decomp_append_iff)
	+ next
	+ assume "homogeneous h"
	+ hence "hom_decomp ps" by (rule 4)
	+ moreover from \<open>homogeneous h\<close> have "hom_decomp qs"
	+ by (simp add: hom_decomp_def qs_def homogeneous_times)
	+ ultimately show "hom_decomp (ps @ qs)" by (simp only: hom_decomp_append_iff)
	+ qed
	+ qed
	+qed
	+
	+lemma standard_decomp_geE:
	+ assumes "finite X" and "valid_decomp X ps"
	+ and "cone_decomp (T::(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors}) set) ps"
	+ and "standard_decomp k ps" and "k \<le> d"
	+ obtains qs where "valid_decomp X qs" and "cone_decomp T qs" and "standard_decomp d qs"
	+ and "monomial_decomp ps \<Longrightarrow> monomial_decomp qs" and "hom_decomp ps \<Longrightarrow> hom_decomp qs"
	+proof -
	+ have "\<exists>qs. valid_decomp X qs \<and> cone_decomp T qs \<and> standard_decomp (k + i) qs \<and>
	+ (monomial_decomp ps \<longrightarrow> monomial_decomp qs) \<and> (hom_decomp ps \<longrightarrow> hom_decomp qs)" for i
	+ proof (induct i)
	+ case 0
	+ from assms(2, 3, 4) show ?case unfolding add_0_right by blast
	+ next
	+ case (Suc i)
	+ then obtain qs where 0: "valid_decomp X qs" and 1: "cone_decomp T qs"
	+ and 2: "standard_decomp (k + i) qs" and 3: "monomial_decomp ps \<Longrightarrow> monomial_decomp qs"
	+ and 4: "hom_decomp ps \<Longrightarrow> hom_decomp qs" by blast
	+ let ?P = "\<lambda>hU. poly_deg (fst hU) \<noteq> k + i"
	+ define rs where "rs = filter (- ?P) qs"
	+ define ss where "ss = filter ?P qs"
	+
	+ have "set rs \<subseteq> set qs" by (auto simp: rs_def)
	+ have "set ss \<subseteq> set qs" by (auto simp: ss_def)
	+
	+ define f where "f = (\<lambda>hU. SOME ps'. valid_decomp X ps' \<and> cone_decomp (cone hU) ps' \<and>
	+ standard_decomp (Suc (poly_deg ((fst hU)::('x \<Rightarrow>\<^sub>0 _) \<Rightarrow>\<^sub>0 'a))) ps' \<and>
	+ (monomial_decomp ps \<longrightarrow> monomial_decomp ps') \<and>
	+ (hom_decomp ps \<longrightarrow> hom_decomp ps'))"
	+ have "valid_decomp X (f hU) \<and> cone_decomp (cone hU) (f hU) \<and> standard_decomp (Suc (k + i)) (f hU) \<and>
	+ (monomial_decomp ps \<longrightarrow> monomial_decomp (f hU)) \<and> (hom_decomp ps \<longrightarrow> hom_decomp (f hU))"
	+ if "hU \<in> set rs" for hU
	+ proof -
	+ obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ with that have eq: "poly_deg (fst hU) = k + i" by (simp add: rs_def)
	+ from that \<open>set rs \<subseteq> set qs\<close> have "(h, U) \<in> set qs" unfolding hU ..
	+ with 0 have "U \<subseteq> X" and "h \<in> P[X]" and "h \<noteq> 0" by (rule valid_decompD)+
	+ with assms(1) obtain ps' where "valid_decomp X ps'" and "cone_decomp (cone (h, U)) ps'"
	+ and "standard_decomp (Suc (poly_deg h)) ps'"
	+ and md: "is_monomial h \<Longrightarrow> punit.lc h = 1 \<Longrightarrow> monomial_decomp ps'"
	+ and hd: "homogeneous h \<Longrightarrow> hom_decomp ps'" by (rule standard_decomp_SucE) blast
	+ note this(1-3)
	+ moreover have "monomial_decomp ps'" if "monomial_decomp ps"
	+ proof -
	+ from that have "monomial_decomp qs" by (rule 3)
	+ hence "is_monomial h" and "punit.lc h = 1" using \<open>(h, U) \<in> set qs\<close> by (rule monomial_decompD)+
	+ thus ?thesis by (rule md)
	+ qed
	+ moreover have "hom_decomp ps'" if "hom_decomp ps"
	+ proof -
	+ from that have "hom_decomp qs" by (rule 4)
	+ hence "homogeneous h" using \<open>(h, U) \<in> set qs\<close> by (rule hom_decompD)
	+ thus ?thesis by (rule hd)
	+ qed
	+ ultimately have "valid_decomp X ps' \<and> cone_decomp (cone hU) ps' \<and>
	+ standard_decomp (Suc (poly_deg (fst hU))) ps' \<and> (monomial_decomp ps \<longrightarrow> monomial_decomp ps') \<and>
	+ (hom_decomp ps \<longrightarrow> hom_decomp ps')" by (simp add: hU)
	+ thus ?thesis unfolding f_def eq by (rule someI)
	+ qed
	+ hence f1: "\<And>ps. ps \<in> set (map f rs) \<Longrightarrow> valid_decomp X ps"
	+ and f2: "\<And>hU. hU \<in> set rs \<Longrightarrow> cone_decomp (cone hU) (f hU)"
	+ and f3: "\<And>ps. ps \<in> set (map f rs) \<Longrightarrow> standard_decomp (Suc (k + i)) ps"
	+ and f4: "\<And>ps'. monomial_decomp ps \<Longrightarrow> ps' \<in> set (map f rs) \<Longrightarrow> monomial_decomp ps'"
	+ and f5: "\<And>ps'. hom_decomp ps \<Longrightarrow> ps' \<in> set (map f rs) \<Longrightarrow> hom_decomp ps'" by auto
	+
	+ define rs' where "rs' = concat (map f rs)"
	+ show ?case unfolding add_Suc_right
	+ proof (intro exI conjI impI)
	+ have "valid_decomp X ss"
	+ proof (rule valid_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set ss"
	+ hence "(h, U) \<in> set qs" using \<open>set ss \<subseteq> set qs\<close> ..
	+ with 0 show "h \<in> P[X]" and "h \<noteq> 0" and "U \<subseteq> X" by (rule valid_decompD)+
	+ qed
	+ moreover have "valid_decomp X rs'"
	+ unfolding rs'_def using f1 by (rule valid_decomp_concat)
	+ ultimately show "valid_decomp X (ss @ rs')" by (rule valid_decomp_append)
	+ next
	+ from 1 have "direct_decomp T (map cone qs)" by (rule cone_decompD)
	+ hence "direct_decomp T ((map cone ss) @ (map cone rs))" unfolding ss_def rs_def
	+ by (rule direct_decomp_split_map)
	+ hence ss: "cone_decomp (sum_list ` listset (map cone ss)) ss"
	+ and "cone_decomp (sum_list ` listset (map cone rs)) rs"
	+ and T: "direct_decomp T [sum_list ` listset (map cone ss), sum_list ` listset (map cone rs)]"
	+ by (auto simp: cone_decomp_def dest: direct_decomp_appendD intro!: empty_not_in_map_cone)
	+ from this(2) have "direct_decomp (sum_list ` listset (map cone rs)) (map cone rs)"
	+ by (rule cone_decompD)
	+ hence "cone_decomp (sum_list ` listset (map cone rs)) rs'" unfolding rs'_def
	+ proof (rule cone_decomp_concat)
	+ fix i
	+ assume *: "i < length (map cone rs)"
	+ hence "rs ! i \<in> set rs" by simp
	+ hence "cone_decomp (cone (rs ! i)) (f (rs ! i))" by (rule f2)
	+ with * show "cone_decomp (map cone rs ! i) (map f rs ! i)" by simp
	+ qed simp
	+ with T ss show "cone_decomp T (ss @ rs')" by (rule cone_decomp_append)
	+ next
	+ have "standard_decomp (Suc (k + i)) ss"
	+ proof (rule standard_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set (ss\<^sub>+)"
	+ hence "(h, U) \<in> set (qs\<^sub>+)" and "poly_deg h \<noteq> k + i" by (simp_all add: pos_decomp_def ss_def)
	+ from 2 this(1) have "k + i \<le> poly_deg h" by (rule standard_decompD)
	+ with \<open>poly_deg h \<noteq> k + i\<close> show "Suc (k + i) \<le> poly_deg h" by simp
	+
	+ fix d'
	+ assume "Suc (k + i) \<le> d'" and "d' \<le> poly_deg h"
	+ from this(1) have "k + i \<le> d'" and "d' \<noteq> k + i" by simp_all
	+ from 2 \<open>(h, U) \<in> set (qs\<^sub>+)\<close> this(1) obtain h' U'
	+ where "(h', U') \<in> set qs" and "poly_deg h' = d'" and "card U \<le> card U'"
	+ using \<open>d' \<le> poly_deg h\<close> by (rule standard_decompE)
	+ moreover from \<open>d' \<noteq> k + i\<close> this(1, 2) have "(h', U') \<in> set ss" by (simp add: ss_def)
	+ ultimately show "\<exists>h' U'. (h', U') \<in> set ss \<and> poly_deg h' = d' \<and> card U \<le> card U'" by blast
	+ qed
	+ moreover have "standard_decomp (Suc (k + i)) rs'"
	+ unfolding rs'_def using f3 by (rule standard_decomp_concat)
	+ ultimately show "standard_decomp (Suc (k + i)) (ss @ rs')" by (rule standard_decomp_append)
	+ next
	+ assume *: "monomial_decomp ps"
	+ hence "monomial_decomp qs" by (rule 3)
	+ hence "monomial_decomp ss" by (simp add: monomial_decomp_def ss_def)
	+ moreover have "monomial_decomp rs'"
	+ unfolding rs'_def using f4[OF *] by (rule monomial_decomp_concat)
	+ ultimately show "monomial_decomp (ss @ rs')" by (simp only: monomial_decomp_append_iff)
	+ next
	+ assume *: "hom_decomp ps"
	+ hence "hom_decomp qs" by (rule 4)
	+ hence "hom_decomp ss" by (simp add: hom_decomp_def ss_def)
	+ moreover have "hom_decomp rs'" unfolding rs'_def using f5[OF *] by (rule hom_decomp_concat)
	+ ultimately show "hom_decomp (ss @ rs')" by (simp only: hom_decomp_append_iff)
	+ qed
	+ qed
	+ then obtain qs where 1: "valid_decomp X qs" and 2: "cone_decomp T qs"
	+ and "standard_decomp (k + (d - k)) qs" and 4: "monomial_decomp ps \<Longrightarrow> monomial_decomp qs"
	+ and 5: "hom_decomp ps \<Longrightarrow> hom_decomp qs" by blast
	+ from this(3) assms(5) have "standard_decomp d qs" by simp
	+ with 1 2 show ?thesis using 4 5 ..
	+qed
	+
	+subsection \<open>Splitting w.r.t. Ideals\<close>
	+
	+context
	+ fixes X :: "'x set"
	+begin
	+
	+definition splits_wrt :: "(((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list \<times> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list) \<Rightarrow>
	+ (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::comm_ring_1) set \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) set \<Rightarrow> bool"
	+ where "splits_wrt pqs T F \<longleftrightarrow> cone_decomp T (fst pqs @ snd pqs) \<and>
	+ (\<forall>hU\<in>set (fst pqs). cone hU \<subseteq> ideal F \<inter> P[X]) \<and>
	+ (\<forall>(h, U)\<in>set (snd pqs). cone (h, U) \<subseteq> P[X] \<and> cone (h, U) \<inter> ideal F = {0})"
	+
	+lemma splits_wrtI:
	+ assumes "cone_decomp T (ps @ qs)"
	+ and "\<And>h U. (h, U) \<in> set ps \<Longrightarrow> cone (h, U) \<subseteq> P[X]" and "\<And>h U. (h, U) \<in> set ps \<Longrightarrow> h \<in> ideal F"
	+ and "\<And>h U. (h, U) \<in> set qs \<Longrightarrow> cone (h, U) \<subseteq> P[X]"
	+ and "\<And>h U a. (h, U) \<in> set qs \<Longrightarrow> a \<in> cone (h, U) \<Longrightarrow> a \<in> ideal F \<Longrightarrow> a = 0"
	+ shows "splits_wrt (ps, qs) T F"
	+ unfolding splits_wrt_def fst_conv snd_conv
	+proof (intro conjI ballI)
	+ fix hU
	+ assume "hU \<in> set ps"
	+ moreover obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ ultimately have "(h, U) \<in> set ps" by simp
	+ hence "cone (h, U) \<subseteq> P[X]" and "h \<in> ideal F" by (rule assms)+
	+ from _ this(1) show "cone hU \<subseteq> ideal F \<inter> P[X]" unfolding hU
	+ proof (rule Int_greatest)
	+ show "cone (h, U) \<subseteq> ideal F"
	+ proof
	+ fix a
	+ assume "a \<in> cone (h, U)"
	+ then obtain a' where "a' \<in> P[U]" and a: "a = a' * h" by (rule coneE)
	+ from \<open>h \<in> ideal F\<close> show "a \<in> ideal F" unfolding a by (rule ideal.span_scale)
	+ qed
	+ qed
	+next
	+ fix hU
	+ assume "hU \<in> set qs"
	+ moreover obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ ultimately have "(h, U) \<in> set qs" by simp
	+ hence "cone (h, U) \<subseteq> P[X]" and "\<And>a. a \<in> cone (h, U) \<Longrightarrow> a \<in> ideal F \<Longrightarrow> a = 0" by (rule assms)+
	+ moreover have "0 \<in> cone (h, U) \<inter> ideal F"
	+ by (simp add: zero_in_cone ideal.span_zero)
	+ ultimately show "case hU of (h, U) \<Rightarrow> cone (h, U) \<subseteq> P[X] \<and> cone (h, U) \<inter> ideal F = {0}"
	+ by (fastforce simp: hU)
	+qed (fact assms)+
	+
	+lemma splits_wrtI_valid_decomp:
	+ assumes "valid_decomp X ps" and "valid_decomp X qs" and "cone_decomp T (ps @ qs)"
	+ and "\<And>h U. (h, U) \<in> set ps \<Longrightarrow> h \<in> ideal F"
	+ and "\<And>h U a. (h, U) \<in> set qs \<Longrightarrow> a \<in> cone (h, U) \<Longrightarrow> a \<in> ideal F \<Longrightarrow> a = 0"
	+ shows "splits_wrt (ps, qs) T F"
	+ using assms(3) _ _ _ assms(5)
	+proof (rule splits_wrtI)
	+ fix h U
	+ assume "(h, U) \<in> set ps"
	+ thus "h \<in> ideal F" by (rule assms(4))
	+ from assms(1) \<open>(h, U) \<in> set ps\<close> have "h \<in> P[X]" and "U \<subseteq> X" by (rule valid_decompD)+
	+ thus "cone (h, U) \<subseteq> P[X]" by (rule cone_subset_PolysI)
	+next
	+ fix h U
	+ assume "(h, U) \<in> set qs"
	+ with assms(2) have "h \<in> P[X]" by (rule valid_decompD)
	+ moreover from assms(2) \<open>(h, U) \<in> set qs\<close> have "U \<subseteq> X" by (rule valid_decompD)
	+ ultimately show "cone (h, U) \<subseteq> P[X]" by (rule cone_subset_PolysI)
	+qed
	+
	+lemma splits_wrtD:
	+ assumes "splits_wrt (ps, qs) T F"
	+ shows "cone_decomp T (ps @ qs)" and "hU \<in> set ps \<Longrightarrow> cone hU \<subseteq> ideal F \<inter> P[X]"
	+ and "hU \<in> set qs \<Longrightarrow> cone hU \<subseteq> P[X]" and "hU \<in> set qs \<Longrightarrow> cone hU \<inter> ideal F = {0}"
	+ using assms by (fastforce simp: splits_wrt_def)+
	+
	+lemma splits_wrt_image_sum_list_fst_subset:
	+ assumes "splits_wrt (ps, qs) T F"
	+ shows "sum_list ` listset (map cone ps) \<subseteq> ideal F \<inter> P[X]"
	+proof
	+ fix x
	+ assume x_in: "x \<in> sum_list ` listset (map cone ps)"
	+ have "listset (map cone ps) \<subseteq> listset (map (\<lambda>_. ideal F \<inter> P[X]) ps)"
	+ proof (rule listset_mono)
	+ fix i
	+ assume i: "i < length (map (\<lambda>_. ideal F \<inter> P[X]) ps)"
	+ hence "ps ! i \<in> set ps" by simp
	+ with assms(1) have "cone (ps ! i) \<subseteq> ideal F \<inter> P[X]" by (rule splits_wrtD)
	+ with i show "map cone ps ! i \<subseteq> map (\<lambda>_. ideal F \<inter> P[X]) ps ! i" by simp
	+ qed simp
	+ hence "sum_list ` listset (map cone ps) \<subseteq> sum_list ` listset (map (\<lambda>_. ideal F \<inter> P[X]) ps)"
	+ by (rule image_mono)
	+ with x_in have "x \<in> sum_list ` listset (map (\<lambda>_. ideal F \<inter> P[X]) ps)" ..
	+ then obtain xs where xs: "xs \<in> listset (map (\<lambda>_. ideal F \<inter> P[X]) ps)" and x: "x = sum_list xs" ..
	+ have 1: "y \<in> ideal F \<inter> P[X]" if "y \<in> set xs" for y
	+ proof -
	+ from that obtain i where "i < length xs" and y: "y = xs ! i" by (metis in_set_conv_nth)
	+ moreover from xs have "length xs = length (map (\<lambda>_. ideal F \<inter> P[X]) ps)"
	+ by (rule listsetD)
	+ ultimately have "i < length (map (\<lambda>_. ideal F \<inter> P[X]) ps)" by simp
	+ moreover from xs this have "xs ! i \<in> (map (\<lambda>_. ideal F \<inter> P[X]) ps) ! i" by (rule listsetD)
	+ ultimately show "y \<in> ideal F \<inter> P[X]" by (simp add: y)
	+ qed
	+ show "x \<in> ideal F \<inter> P[X]" unfolding x
	+ proof
	+ show "sum_list xs \<in> ideal F"
	+ proof (rule ideal.span_closed_sum_list[simplified])
	+ fix y
	+ assume "y \<in> set xs"
	+ hence "y \<in> ideal F \<inter> P[X]" by (rule 1)
	+ thus "y \<in> ideal F" by simp
	+ qed
	+ next
	+ show "sum_list xs \<in> P[X]"
	+ proof (rule Polys_closed_sum_list)
	+ fix y
	+ assume "y \<in> set xs"
	+ hence "y \<in> ideal F \<inter> P[X]" by (rule 1)
	+ thus "y \<in> P[X]" by simp
	+ qed
	+ qed
	+qed
	+
	+lemma splits_wrt_image_sum_list_snd_subset:
	+ assumes "splits_wrt (ps, qs) T F"
	+ shows "sum_list ` listset (map cone qs) \<subseteq> P[X]"
	+proof
	+ fix x
	+ assume x_in: "x \<in> sum_list ` listset (map cone qs)"
	+ have "listset (map cone qs) \<subseteq> listset (map (\<lambda>_. P[X]) qs)"
	+ proof (rule listset_mono)
	+ fix i
	+ assume i: "i < length (map (\<lambda>_. P[X]) qs)"
	+ hence "qs ! i \<in> set qs" by simp
	+ with assms(1) have "cone (qs ! i) \<subseteq> P[X]" by (rule splits_wrtD)
	+ with i show "map cone qs ! i \<subseteq> map (\<lambda>_. P[X]) qs ! i" by simp
	+ qed simp
	+ hence "sum_list ` listset (map cone qs) \<subseteq> sum_list ` listset (map (\<lambda>_. P[X]) qs)"
	+ by (rule image_mono)
	+ with x_in have "x \<in> sum_list ` listset (map (\<lambda>_. P[X]) qs)" ..
	+ then obtain xs where xs: "xs \<in> listset (map (\<lambda>_. P[X]) qs)" and x: "x = sum_list xs" ..
	+ show "x \<in> P[X]" unfolding x
	+ proof (rule Polys_closed_sum_list)
	+ fix y
	+ assume "y \<in> set xs"
	+ then obtain i where "i < length xs" and y: "y = xs ! i" by (metis in_set_conv_nth)
	+ moreover from xs have "length xs = length (map (\<lambda>_. P[X]::(_ \<Rightarrow>\<^sub>0 'a) set) qs)"
	+ by (rule listsetD)
	+ ultimately have "i < length (map (\<lambda>_. P[X]) qs)" by simp
	+ moreover from xs this have "xs ! i \<in> (map (\<lambda>_. P[X]) qs) ! i" by (rule listsetD)
	+ ultimately show "y \<in> P[X]" by (simp add: y)
	+ qed
	+qed
	+
	+lemma splits_wrt_cone_decomp_1:
	+ assumes "splits_wrt (ps, qs) T F" and "monomial_decomp qs" and "is_monomial_set (F::(_ \<Rightarrow>\<^sub>0 'a::field) set)"
	+ \<comment>\<open>The last two assumptions are missing in the paper.\<close>
	+ shows "cone_decomp (T \<inter> ideal F) ps"
	+proof -
	+ from assms(1) have *: "cone_decomp T (ps @ qs)" by (rule splits_wrtD)
	+ hence "direct_decomp T (map cone ps @ map cone qs)" by (simp add: cone_decomp_def)
	+ hence 1: "direct_decomp (sum_list ` listset (map cone ps)) (map cone ps)"
	+ and 2: "direct_decomp T [sum_list ` listset (map cone ps), sum_list ` listset (map cone qs)]"
	+ by (auto dest: direct_decomp_appendD intro!: empty_not_in_map_cone)
	+ let ?ss = "[sum_list ` listset (map cone ps), sum_list ` listset (map cone qs)]"
	+ show ?thesis
	+ proof (intro cone_decompI direct_decompI)
	+ from 1 show "inj_on sum_list (listset (map cone ps))" by (simp only: direct_decomp_def bij_betw_def)
	+ next
	+ from assms(1) have "sum_list ` listset (map cone ps) \<subseteq> ideal F \<inter> P[X]"
	+ by (rule splits_wrt_image_sum_list_fst_subset)
	+ hence sub: "sum_list ` listset (map cone ps) \<subseteq> ideal F" by simp
	+ show "sum_list ` listset (map cone ps) = T \<inter> ideal F"
	+ proof (rule set_eqI)
	+ fix x
	+ show "x \<in> sum_list ` listset (map cone ps) \<longleftrightarrow> x \<in> T \<inter> ideal F"
	+ proof
	+ assume x_in: "x \<in> sum_list ` listset (map cone ps)"
	+ show "x \<in> T \<inter> ideal F"
	+ proof (intro IntI)
	+ have "map (\<lambda>_. 0) qs \<in> listset (map cone qs)" (is "?ys \<in> _")
	+ by (induct qs) (auto intro: listset_ConsI zero_in_cone simp del: listset.simps(2))
	+ hence "sum_list ?ys \<in> sum_list ` listset (map cone qs)" by (rule imageI)
	+ hence "0 \<in> sum_list ` listset (map cone qs)" by simp
	+ with x_in have "[x, 0] \<in> listset ?ss" using refl by (rule listset_doubletonI)
	+ with 2 have "sum_list [x, 0] \<in> T" by (rule direct_decompD)
	+ thus "x \<in> T" by simp
	+ next
	+ from x_in sub show "x \<in> ideal F" ..
	+ qed
	+ next
	+ assume "x \<in> T \<inter> ideal F"
	+ hence "x \<in> T" and "x \<in> ideal F" by simp_all
	+ from 2 this(1) obtain xs where "xs \<in> listset ?ss" and x: "x = sum_list xs"
	+ by (rule direct_decompE)
	+ from this(1) obtain p q where p: "p \<in> sum_list ` listset (map cone ps)"
	+ and q: "q \<in> sum_list ` listset (map cone qs)" and xs: "xs = [p, q]"
	+ by (rule listset_doubletonE)
	+ from \<open>x \<in> ideal F\<close> have "p + q \<in> ideal F" by (simp add: x xs)
	+ moreover from p sub have "p \<in> ideal F" ..
	+ ultimately have "p + q - p \<in> ideal F" by (rule ideal.span_diff)
	+ hence "q \<in> ideal F" by simp
	+ have "q = 0"
	+ proof (rule ccontr)
	+ assume "q \<noteq> 0"
	+ hence "keys q \<noteq> {}" by simp
	+ then obtain t where "t \<in> keys q" by blast
	+ with assms(2) q obtain c h U where "(h, U) \<in> set qs" and "c \<noteq> 0"
	+ and "monomial c t \<in> cone (h, U)" by (rule monomial_decomp_sum_list_monomial_in_cone)
	+ moreover from assms(3) \<open>q \<in> ideal F\<close> \<open>t \<in> keys q\<close> have "monomial c t \<in> ideal F"
	+ by (rule punit.monomial_pmdl_field[simplified])
	+ ultimately have "monomial c t \<in> cone (h, U) \<inter> ideal F" by simp
	+ also from assms(1) \<open>(h, U) \<in> set qs\<close> have "\<dots> = {0}" by (rule splits_wrtD)
	+ finally have "c = 0" by (simp add: monomial_0_iff)
	+ with \<open>c \<noteq> 0\<close> show False ..
	+ qed
	+ with p show "x \<in> sum_list ` listset (map cone ps)" by (simp add: x xs)
	+ qed
	+ qed
	+ qed
	+qed
	+
	+text \<open>Together, Theorems \<open>splits_wrt_image_sum_list_fst_subset\<close> and \<open>splits_wrt_cone_decomp_1\<close>
	+ imply that @{term ps} is also a cone decomposition of @{term "T \<inter> ideal F \<inter> P[X]"}.\<close>
	+
	+lemma splits_wrt_cone_decomp_2:
	+ assumes "finite X" and "splits_wrt (ps, qs) T F" and "monomial_decomp qs" and "is_monomial_set F"
	+ and "F \<subseteq> P[X]"
	+ shows "cone_decomp (T \<inter> normal_form F ` P[X]) qs"
	+proof -
	+ from assms(2) have *: "cone_decomp T (ps @ qs)" by (rule splits_wrtD)
	+ hence "direct_decomp T (map cone ps @ map cone qs)" by (simp add: cone_decomp_def)
	+ hence 1: "direct_decomp (sum_list ` listset (map cone qs)) (map cone qs)"
	+ and 2: "direct_decomp T [sum_list ` listset (map cone ps), sum_list ` listset (map cone qs)]"
	+ by (auto dest: direct_decomp_appendD intro!: empty_not_in_map_cone)
	+ let ?ss = "[sum_list ` listset (map cone ps), sum_list ` listset (map cone qs)]"
	+ let ?G = "punit.reduced_GB F"
	+ from assms(1, 5) have "?G \<subseteq> P[X]" and G_is_GB: "punit.is_Groebner_basis ?G"
	+ and ideal_G: "ideal ?G = ideal F"
	+ by (rule reduced_GB_Polys, rule reduced_GB_is_GB_Polys, rule reduced_GB_ideal_Polys)
	+ show ?thesis
	+ proof (intro cone_decompI direct_decompI)
	+ from 1 show "inj_on sum_list (listset (map cone qs))" by (simp only: direct_decomp_def bij_betw_def)
	+ next
	+ from assms(2) have "sum_list ` listset (map cone ps) \<subseteq> ideal F \<inter> P[X]"
	+ by (rule splits_wrt_image_sum_list_fst_subset)
	+ hence sub: "sum_list ` listset (map cone ps) \<subseteq> ideal F" by simp
	+ show "sum_list ` listset (map cone qs) = T \<inter> normal_form F ` P[X]"
	+ proof (rule set_eqI)
	+ fix x
	+ show "x \<in> sum_list ` listset (map cone qs) \<longleftrightarrow> x \<in> T \<inter> normal_form F ` P[X]"
	+ proof
	+ assume x_in: "x \<in> sum_list ` listset (map cone qs)"
	+ show "x \<in> T \<inter> normal_form F ` P[X]"
	+ proof (intro IntI)
	+ have "map (\<lambda>_. 0) ps \<in> listset (map cone ps)" (is "?ys \<in> _")
	+ by (induct ps) (auto intro: listset_ConsI zero_in_cone simp del: listset.simps(2))
	+ hence "sum_list ?ys \<in> sum_list ` listset (map cone ps)" by (rule imageI)
	+ hence "0 \<in> sum_list ` listset (map cone ps)" by simp
	+ from this x_in have "[0, x] \<in> listset ?ss" using refl by (rule listset_doubletonI)
	+ with 2 have "sum_list [0, x] \<in> T" by (rule direct_decompD)
	+ thus "x \<in> T" by simp
	+ next
	+ from assms(2) have "sum_list ` listset (map cone qs) \<subseteq> P[X]"
	+ by (rule splits_wrt_image_sum_list_snd_subset)
	+ with x_in have "x \<in> P[X]" ..
	+ moreover have "\<not> punit.is_red ?G x"
	+ proof
	+ assume "punit.is_red ?G x"
	+ then obtain g t where "g \<in> ?G" and "t \<in> keys x" and "g \<noteq> 0" and adds: "lpp g adds t"
	+ by (rule punit.is_red_addsE[simplified])
	+ from assms(3) x_in this(2) obtain c h U where "(h, U) \<in> set qs" and "c \<noteq> 0"
	+ and "monomial c t \<in> cone (h, U)" by (rule monomial_decomp_sum_list_monomial_in_cone)
	+ note this(3)
	+ moreover have "monomial c t \<in> ideal ?G"
	+ proof (rule punit.is_red_monomial_monomial_set_in_pmdl[simplified])
	+ from \<open>c \<noteq> 0\<close> show "is_monomial (monomial c t)" by (rule monomial_is_monomial)
	+ next
	+ from assms(1, 5, 4) show "is_monomial_set ?G" by (rule reduced_GB_is_monomial_set_Polys)
	+ next
	+ from \<open>c \<noteq> 0\<close> have "t \<in> keys (monomial c t)" by simp
	+ with \<open>g \<in> ?G\<close> \<open>g \<noteq> 0\<close> show "punit.is_red ?G (monomial c t)" using adds
	+ by (rule punit.is_red_addsI[simplified])
	+ qed
	+ ultimately have "monomial c t \<in> cone (h, U) \<inter> ideal F" by (simp add: ideal_G)
	+ also from assms(2) \<open>(h, U) \<in> set qs\<close> have "\<dots> = {0}" by (rule splits_wrtD)
	+ finally have "c = 0" by (simp add: monomial_0_iff)
	+ with \<open>c \<noteq> 0\<close> show False ..
	+ qed
	+ ultimately show "x \<in> normal_form F ` P[X]"
	+ using assms(1, 5) by (simp add: image_normal_form_iff)
	+ qed
	+ next
	+ assume "x \<in> T \<inter> normal_form F ` P[X]"
	+ hence "x \<in> T" and "x \<in> normal_form F ` P[X]" by simp_all
	+ from this(2) assms(1, 5) have "x \<in> P[X]" and irred: "\<not> punit.is_red ?G x"
	+ by (simp_all add: image_normal_form_iff)
	+ from 2 \<open>x \<in> T\<close> obtain xs where "xs \<in> listset ?ss" and x: "x = sum_list xs"
	+ by (rule direct_decompE)
	+ from this(1) obtain p q where p: "p \<in> sum_list ` listset (map cone ps)"
	+ and q: "q \<in> sum_list ` listset (map cone qs)" and xs: "xs = [p, q]"
	+ by (rule listset_doubletonE)
	+ have "x = p + q" by (simp add: x xs)
	+ from p sub have "p \<in> ideal F" ..
	+ have "p = 0"
	+ proof (rule ccontr)
	+ assume "p \<noteq> 0"
	+ hence "keys p \<noteq> {}" by simp
	+ then obtain t where "t \<in> keys p" by blast
	+ from assms(4) \<open>p \<in> ideal F\<close> \<open>t \<in> keys p\<close> have 3: "monomial c t \<in> ideal F" for c
	+ by (rule punit.monomial_pmdl_field[simplified])
	+ have "t \<notin> keys q"
	+ proof
	+ assume "t \<in> keys q"
	+ with assms(3) q obtain c h U where "(h, U) \<in> set qs" and "c \<noteq> 0"
	+ and "monomial c t \<in> cone (h, U)" by (rule monomial_decomp_sum_list_monomial_in_cone)
	+ from this(3) 3 have "monomial c t \<in> cone (h, U) \<inter> ideal F" by simp
	+ also from assms(2) \<open>(h, U) \<in> set qs\<close> have "\<dots> = {0}" by (rule splits_wrtD)
	+ finally have "c = 0" by (simp add: monomial_0_iff)
	+ with \<open>c \<noteq> 0\<close> show False ..
	+ qed
	+ with \<open>t \<in> keys p\<close> have "t \<in> keys x" unfolding \<open>x = p + q\<close> by (rule in_keys_plusI1)
	+ have "punit.is_red ?G x"
	+ proof -
	+ note G_is_GB
	+ moreover from 3 have "monomial 1 t \<in> ideal ?G" by (simp only: ideal_G)
	+ moreover have "monomial (1::'a) t \<noteq> 0" by (simp add: monomial_0_iff)
	+ ultimately obtain g where "g \<in> ?G" and "g \<noteq> 0"
	+ and "lpp g adds lpp (monomial (1::'a) t)" by (rule punit.GB_adds_lt[simplified])
	+ from this(3) have "lpp g adds t" by (simp add: punit.lt_monomial)
	+ with \<open>g \<in> ?G\<close> \<open>g \<noteq> 0\<close> \<open>t \<in> keys x\<close> show ?thesis by (rule punit.is_red_addsI[simplified])
	+ qed
	+ with irred show False ..
	+ qed
	+ with q show "x \<in> sum_list ` listset (map cone qs)" by (simp add: x xs)
	+ qed
	+ qed
	+ qed
	+qed
	+
	+lemma quot_monomial_ideal_monomial:
	+ "ideal (monomial 1 ` S) \<div> monomial 1 (Poly_Mapping.single (x::'x) (1::nat)) =
	+ ideal (monomial (1::'a::comm_ring_1) ` (\<lambda>s. s - Poly_Mapping.single x 1) ` S)"
	+proof (rule set_eqI)
	+ let ?x = "Poly_Mapping.single x (1::nat)"
	+ fix a
	+ have "a \<in> ideal (monomial 1 ` S) \<div> monomial 1 ?x \<longleftrightarrow> punit.monom_mult 1 ?x a \<in> ideal (monomial (1::'a) ` S)"
	+ by (simp only: quot_set_iff times_monomial_left)
	+ also have "\<dots> \<longleftrightarrow> a \<in> ideal (monomial 1 ` (\<lambda>s. s - ?x) ` S)"
	+ proof (induct a rule: poly_mapping_plus_induct)
	+ case 1
	+ show ?case by (simp add: ideal.span_zero)
	+ next
	+ case (2 a c t)
	+ let ?S = "monomial (1::'a) ` (\<lambda>s. s - ?x) ` S"
	+ show ?case
	+ proof
	+ assume 0: "punit.monom_mult 1 ?x (monomial c t + a) \<in> ideal (monomial 1 ` S)"
	+ have "is_monomial_set (monomial (1::'a) ` S)"
	+ by (auto intro!: is_monomial_setI monomial_is_monomial)
	+ moreover from 0 have 1: "monomial c (?x + t) + punit.monom_mult 1 ?x a \<in> ideal (monomial 1 ` S)"
	+ by (simp add: punit.monom_mult_monomial punit.monom_mult_dist_right)
	+ moreover have "?x + t \<in> keys (monomial c (?x + t) + punit.monom_mult 1 ?x a)"
	+ proof (intro in_keys_plusI1 notI)
	+ from 2(1) show "?x + t \<in> keys (monomial c (?x + t))" by simp
	+ next
	+ assume "?x + t \<in> keys (punit.monom_mult 1 ?x a)"
	+ also have "\<dots> \<subseteq> (+) ?x ` keys a" by (rule punit.keys_monom_mult_subset[simplified])
	+ finally obtain s where "s \<in> keys a" and "?x + t = ?x + s" ..
	+ from this(2) have "t = s" by simp
	+ with \<open>s \<in> keys a\<close> 2(2) show False by simp
	+ qed
	+ ultimately obtain f where "f \<in> monomial (1::'a) ` S" and adds: "lpp f adds ?x + t"
	+ by (rule punit.keys_monomial_pmdl[simplified])
	+ from this(1) obtain s where "s \<in> S" and f: "f = monomial 1 s" ..
	+ from adds have "s adds ?x + t" by (simp add: f punit.lt_monomial)
	+ hence "s - ?x adds t"
	+ by (metis (no_types, lifting) add_minus_2 adds_minus adds_triv_right plus_minus_assoc_pm_nat_1)
	+ then obtain s' where t: "t = (s - ?x) + s'" by (rule addsE)
	+ from \<open>s \<in> S\<close> have "monomial 1 (s - ?x) \<in> ?S" by (intro imageI)
	+ also have "\<dots> \<subseteq> ideal ?S" by (rule ideal.span_superset)
	+ finally have "monomial c s' * monomial 1 (s - ?x) \<in> ideal ?S"
	+ by (rule ideal.span_scale)
	+ hence "monomial c t \<in> ideal ?S" by (simp add: times_monomial_monomial t add.commute)
	+ moreover have "a \<in> ideal ?S"
	+ proof -
	+ from \<open>f \<in> monomial 1 ` S\<close> have "f \<in> ideal (monomial 1 ` S)" by (rule ideal.span_base)
	+ hence "punit.monom_mult c (?x + t - s) f \<in> ideal (monomial 1 ` S)"
	+ by (rule punit.pmdl_closed_monom_mult[simplified])
	+ with \<open>s adds ?x + t\<close> have "monomial c (?x + t) \<in> ideal (monomial 1 ` S)"
	+ by (simp add: f punit.monom_mult_monomial adds_minus)
	+ with 1 have "monomial c (?x + t) + punit.monom_mult 1 ?x a - monomial c (?x + t) \<in> ideal (monomial 1 ` S)"
	+ by (rule ideal.span_diff)
	+ thus ?thesis by (simp add: 2(3) del: One_nat_def)
	+ qed
	+ ultimately show "monomial c t + a \<in> ideal ?S"
	+ by (rule ideal.span_add)
	+ next
	+ have "is_monomial_set ?S" by (auto intro!: is_monomial_setI monomial_is_monomial)
	+ moreover assume 1: "monomial c t + a \<in> ideal ?S"
	+ moreover from _ 2(2) have "t \<in> keys (monomial c t + a)"
	+ proof (rule in_keys_plusI1)
	+ from 2(1) show "t \<in> keys (monomial c t)" by simp
	+ qed
	+ ultimately obtain f where "f \<in> ?S" and adds: "lpp f adds t"
	+ by (rule punit.keys_monomial_pmdl[simplified])
	+ from this(1) obtain s where "s \<in> S" and f: "f = monomial 1 (s - ?x)" by blast
	+ from adds have "s - ?x adds t" by (simp add: f punit.lt_monomial)
	+ hence "s adds ?x + t"
	+ by (auto simp: adds_poly_mapping le_fun_def lookup_add lookup_minus lookup_single when_def
	+ split: if_splits)
	+ then obtain s' where t: "?x + t = s + s'" by (rule addsE)
	+ from \<open>s \<in> S\<close> have "monomial 1 s \<in> monomial 1 ` S" by (rule imageI)
	+ also have "\<dots> \<subseteq> ideal (monomial 1 ` S)" by (rule ideal.span_superset)
	+ finally have "monomial c s' * monomial 1 s \<in> ideal (monomial 1 ` S)"
	+ by (rule ideal.span_scale)
	+ hence "monomial c (?x + t) \<in> ideal (monomial 1 ` S)"
	+ by (simp only: t) (simp add: times_monomial_monomial add.commute)
	+ moreover have "punit.monom_mult 1 ?x a \<in> ideal (monomial 1 ` S)"
	+ proof -
	+ from \<open>f \<in> ?S\<close> have "f \<in> ideal ?S" by (rule ideal.span_base)
	+ hence "punit.monom_mult c (t - (s - ?x)) f \<in> ideal ?S"
	+ by (rule punit.pmdl_closed_monom_mult[simplified])
	+ with \<open>s - ?x adds t\<close> have "monomial c t \<in> ideal ?S"
	+ by (simp add: f punit.monom_mult_monomial adds_minus)
	+ with 1 have "monomial c t + a - monomial c t \<in> ideal ?S"
	+ by (rule ideal.span_diff)
	+ thus ?thesis by (simp add: 2(3) del: One_nat_def)
	+ qed
	+ ultimately have "monomial c (?x + t) + punit.monom_mult 1 ?x a \<in> ideal (monomial 1 ` S)"
	+ by (rule ideal.span_add)
	+ thus "punit.monom_mult 1 ?x (monomial c t + a) \<in> ideal (monomial 1 ` S)"
	+ by (simp add: punit.monom_mult_monomial punit.monom_mult_dist_right)
	+ qed
	+ qed
	+ finally show "a \<in> ideal (monomial 1 ` S) \<div> monomial 1 ?x \<longleftrightarrow> a \<in> ideal (monomial 1 ` (\<lambda>s. s - ?x) ` S)" .
	+qed
	+
	+lemma lem_4_2_1:
	+ assumes "ideal F \<div> monomial 1 t = ideal (monomial (1::'a::comm_ring_1) ` S)"
	+ shows "cone (monomial 1 t, U) \<subseteq> ideal F \<longleftrightarrow> 0 \<in> S"
	+proof
	+ have "monomial 1 t \<in> cone (monomial (1::'a) t, U)" by (rule tip_in_cone)
	+ also assume "cone (monomial 1 t, U) \<subseteq> ideal F"
	+ finally have : "monomial 1 t 1 \<in> ideal F" by simp
	+ have "is_monomial_set (monomial (1::'a) ` S)"
	+ by (auto intro!: is_monomial_setI monomial_is_monomial)
	+ moreover from * have "1 \<in> ideal (monomial (1::'a) ` S)" by (simp only: quot_set_iff flip: assms)
	+ moreover have "0 \<in> keys (1::_ \<Rightarrow>\<^sub>0 'a)" by simp
	+ ultimately obtain g where "g \<in> monomial (1::'a) ` S" and adds: "lpp g adds 0"
	+ by (rule punit.keys_monomial_pmdl[simplified])
	+ from this(1) obtain s where "s \<in> S" and g: "g = monomial 1 s" ..
	+ from adds have "s adds 0" by (simp add: g punit.lt_monomial flip: single_one)
	+ with \<open>s \<in> S\<close> show "0 \<in> S" by (simp only: adds_zero)
	+next
	+ assume "0 \<in> S"
	+ hence "monomial 1 0 \<in> monomial (1::'a) ` S" by (rule imageI)
	+ hence "1 \<in> ideal (monomial (1::'a) ` S)" unfolding single_one by (rule ideal.span_base)
	+ hence eq: "ideal F \<div> monomial 1 t = UNIV" (is "_ \<div> ?t = _")
	+ by (simp only: assms ideal_eq_UNIV_iff_contains_one)
	+ show "cone (monomial 1 t, U) \<subseteq> ideal F"
	+ proof
	+ fix a
	+ assume "a \<in> cone (?t, U)"
	+ then obtain q where a: "a = q * ?t" by (rule coneE)
	+ have "q \<in> ideal F \<div> ?t" by (simp add: eq)
	+ thus "a \<in> ideal F" by (simp only: a quot_set_iff mult.commute)
	+ qed
	+qed
	+
	+lemma lem_4_2_2:
	+ assumes "ideal F \<div> monomial 1 t = ideal (monomial (1::'a::comm_ring_1) ` S)"
	+ shows "cone (monomial 1 t, U) \<inter> ideal F = {0} \<longleftrightarrow> S \<inter> .[U] = {}"
	+proof
	+ let ?t = "monomial (1::'a) t"
	+ assume eq: "cone (?t, U) \<inter> ideal F = {0}"
	+ {
	+ fix s
	+ assume "s \<in> S"
	+ hence "monomial 1 s \<in> monomial (1::'a) ` S" (is "?s \<in> _") by (rule imageI)
	+ hence "?s \<in> ideal (monomial 1 ` S)" by (rule ideal.span_base)
	+ also have "\<dots> = ideal F \<div> ?t" by (simp only: assms)
	+ finally have : "?s ?t \<in> ideal F" by (simp only: quot_set_iff mult.commute)
	+ assume "s \<in> .[U]"
	+ hence "?s \<in> P[U]" by (rule Polys_closed_monomial)
	+ with refl have "?s * ?t \<in> cone (?t, U)" by (rule coneI)
	+ with * have "?s * ?t \<in> cone (?t, U) \<inter> ideal F" by simp
	+ hence False by (simp add: eq times_monomial_monomial monomial_0_iff)
	+ }
	+ thus "S \<inter> .[U] = {}" by blast
	+next
	+ let ?t = "monomial (1::'a) t"
	+ assume eq: "S \<inter> .[U] = {}"
	+ {
	+ fix a
	+ assume "a \<in> cone (?t, U)"
	+ then obtain q where "q \<in> P[U]" and a: "a = q * ?t" by (rule coneE)
	+ assume "a \<in> ideal F"
	+ have "a = 0"
	+ proof (rule ccontr)
	+ assume "a \<noteq> 0"
	+ hence "q \<noteq> 0" by (auto simp: a)
	+ from \<open>a \<in> ideal F\<close> have *: "q \<in> ideal F \<div> ?t" by (simp only: quot_set_iff a mult.commute)
	+ have "is_monomial_set (monomial (1::'a) ` S)"
	+ by (auto intro!: is_monomial_setI monomial_is_monomial)
	+ moreover from * have q_in: "q \<in> ideal (monomial 1 ` S)" by (simp only: assms)
	+ moreover from \<open>q \<noteq> 0\<close> have "lpp q \<in> keys q" by (rule punit.lt_in_keys)
	+ ultimately obtain g where "g \<in> monomial (1::'a) ` S" and adds: "lpp g adds lpp q"
	+ by (rule punit.keys_monomial_pmdl[simplified])
	+ from this(1) obtain s where "s \<in> S" and g: "g = monomial 1 s" ..
	+ from \<open>q \<noteq> 0\<close> have "lpp q \<in> keys q" by (rule punit.lt_in_keys)
	+ also from \<open>q \<in> P[U]\<close> have "\<dots> \<subseteq> .[U]" by (rule PolysD)
	+ finally have "lpp q \<in> .[U]" .
	+ moreover from adds have "s adds lpp q" by (simp add: g punit.lt_monomial)
	+ ultimately have "s \<in> .[U]" by (rule PPs_closed_adds)
	+ with eq \<open>s \<in> S\<close> show False by blast
	+ qed
	+ }
	+ thus "cone (?t, U) \<inter> ideal F = {0}" using zero_in_cone ideal.span_zero by blast
	+qed
	+
	+subsection \<open>Function \<open>split\<close>\<close>
	+
	+definition max_subset :: "'a set \<Rightarrow> ('a set \<Rightarrow> bool) \<Rightarrow> 'a set"
	+ where "max_subset A P = (ARG_MAX card B. B \<subseteq> A \<and> P B)"
	+
	+lemma max_subset:
	+ assumes "finite A" and "B \<subseteq> A" and "P B"
	+ shows "max_subset A P \<subseteq> A" (is ?thesis1)
	+ and "P (max_subset A P)" (is ?thesis2)
	+ and "card B \<le> card (max_subset A P)" (is ?thesis3)
	+proof -
	+ from assms(2, 3) have "B \<subseteq> A \<and> P B" by simp
	+ moreover have "\<forall>C. C \<subseteq> A \<and> P C \<longrightarrow> card C < Suc (card A)"
	+ proof (intro allI impI, elim conjE)
	+ fix C
	+ assume "C \<subseteq> A"
	+ with assms(1) have "card C \<le> card A" by (rule card_mono)
	+ thus "card C < Suc (card A)" by simp
	+ qed
	+ ultimately have "?thesis1 \<and> ?thesis2" and ?thesis3 unfolding max_subset_def
	+ by (rule arg_max_natI, rule arg_max_nat_le)
	+ thus ?thesis1 and ?thesis2 and ?thesis3 by simp_all
	+qed
	+
	+function (domintros) split :: "('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow> 'x set \<Rightarrow> ('x \<Rightarrow>\<^sub>0 nat) set \<Rightarrow>
	+ ((((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> ('x set)) list) \<times>
	+ (((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{zero,one}) \<times> ('x set)) list))"
	+ where
	+ "split t U S =
	+ (if 0 \<in> S then
	+ ([(monomial 1 t, U)], [])
	+ else if S \<inter> .[U] = {} then
	+ ([], [(monomial 1 t, U)])
	+ else
	+ let x = SOME x'. x' \<in> U - (max_subset U (\<lambda>V. S \<inter> .[V] = {}));
	+ (ps0, qs0) = split t (U - {x}) S;
	+ (ps1, qs1) = split (Poly_Mapping.single x 1 + t) U ((\<lambda>f. f - Poly_Mapping.single x 1) ` S) in
	+ (ps0 @ ps1, qs0 @ qs1))"
	+ by auto
	+
	+text \<open>Function @{const split} is not executable, because this is not necessary.
	+ With some effort, it could be made executable, though.\<close>
	+
	+lemma split_domI':
	+ assumes "finite X" and "fst (snd args) \<subseteq> X" and "finite (snd (snd args))"
	+ shows "split_dom TYPE('a::{zero,one}) args"
	+proof -
	+ let ?m = "\<lambda>args'. card (fst (snd args')) + sum deg_pm (snd (snd args'))"
	+ from wf_measure[of ?m] assms(2, 3) show ?thesis
	+ proof (induct args)
	+ case (less args)
	+ obtain t U F where args: "args = (t, U, F)" using prod.exhaust by metis
	+ from less.prems have "U \<subseteq> X" and "finite F" by (simp_all only: args fst_conv snd_conv)
	+ from this(1) assms(1) have "finite U" by (rule finite_subset)
	+ have IH: "split_dom TYPE('a) (t', U', F')"
	+ if "U' \<subseteq> X" and "finite F'" and "card U' + sum deg_pm F' < card U + sum deg_pm F"
	+ for t' U' F'
	+ using less.hyps that by (simp add: args)
	+
	+ define S where "S = max_subset U (\<lambda>V. F \<inter> .[V] = {})"
	+ define x where "x = (SOME x'. x' \<in> U \<and> x' \<notin> S)"
	+ show ?case unfolding args
	+ proof (rule split.domintros, simp_all only: x_def[symmetric] S_def[symmetric])
	+ fix f
	+ assume "0 \<notin> F" and "f \<in> F" and "f \<in> .[U]"
	+ from this(1) have "F \<inter> .[{}] = {}" by simp
	+ with \<open>finite U\<close> empty_subsetI have "S \<subseteq> U" and "F \<inter> .[S] = {}"
	+ unfolding S_def by (rule max_subset)+
	+ have "x \<in> U \<and> x \<notin> S" unfolding x_def
	+ proof (rule someI_ex)
	+ from \<open>f \<in> F\<close> \<open>f \<in> .[U]\<close> \<open>F \<inter> .[S] = {}\<close> have "S \<noteq> U" by blast
	+ with \<open>S \<subseteq> U\<close> show "\<exists>y. y \<in> U \<and> y \<notin> S" by blast
	+ qed
	+ hence "x \<in> U" and "x \<notin> S" by simp_all
	+ {
	+ assume "\<not> split_dom TYPE('a) (t, U - {x}, F)"
	+ moreover from _ \<open>finite F\<close> have "split_dom TYPE('a) (t, U - {x}, F)"
	+ proof (rule IH)
	+ from \<open>U \<subseteq> X\<close> show "U - {x} \<subseteq> X" by blast
	+ next
	+ from \<open>finite U\<close> \<open>x \<in> U\<close> have "card (U - {x}) < card U" by (rule card_Diff1_less)
	+ thus "card (U - {x}) + sum deg_pm F < card U + sum deg_pm F" by simp
	+ qed
	+ ultimately show False ..
	+ }
	+ {
	+ let ?args = "(Poly_Mapping.single x (Suc 0) + t, U, (\<lambda>f. f - Poly_Mapping.single x (Suc 0)) ` F)"
	+ assume "\<not> split_dom TYPE('a) ?args"
	+ moreover from \<open>U \<subseteq> X\<close> have "split_dom TYPE('a) ?args"
	+ proof (rule IH)
	+ from \<open>finite F\<close> show "finite ((\<lambda>f. f - Poly_Mapping.single x (Suc 0)) ` F)"
	+ by (rule finite_imageI)
	+ next
	+ have "sum deg_pm ((\<lambda>f. f - Poly_Mapping.single x (Suc 0)) ` F) \<le>
	+ sum (deg_pm \<circ> (\<lambda>f. f - Poly_Mapping.single x (Suc 0))) F"
	+ using \<open>finite F\<close> by (rule sum_image_le) simp
	+ also from \<open>finite F\<close> have "\<dots> < sum deg_pm F"
	+ proof (rule sum_strict_mono_ex1)
	+ show "\<forall>f\<in>F. (deg_pm \<circ> (\<lambda>f. f - Poly_Mapping.single x (Suc 0))) f \<le> deg_pm f"
	+ by (simp add: deg_pm_minus_le)
	+ next
	+ show "\<exists>f\<in>F. (deg_pm \<circ> (\<lambda>f. f - Poly_Mapping.single x (Suc 0))) f < deg_pm f"
	+ proof (rule ccontr)
	+ assume *: "\<not> (\<exists>f\<in>F. (deg_pm \<circ> (\<lambda>f. f - Poly_Mapping.single x (Suc 0))) f < deg_pm f)"
	+ note \<open>finite U\<close>
	+ moreover from \<open>x \<in> U\<close> \<open>S \<subseteq> U\<close> have "insert x S \<subseteq> U" by (rule insert_subsetI)
	+ moreover have "F \<inter> .[insert x S] = {}"
	+ proof -
	+ {
	+ fix s
	+ assume "s \<in> F"
	+ with * have "\<not> deg_pm (s - Poly_Mapping.single x (Suc 0)) < deg_pm s" by simp
	+ with deg_pm_minus_le[of s "Poly_Mapping.single x (Suc 0)"]
	+ have "deg_pm (s - Poly_Mapping.single x (Suc 0)) = deg_pm s" by simp
	+ hence "keys s \<inter> keys (Poly_Mapping.single x (Suc 0)) = {}"
	+ by (simp only: deg_pm_minus_id_iff)
	+ hence "x \<notin> keys s" by simp
	+ moreover assume "s \<in> .[insert x S]"
	+ ultimately have "s \<in> .[S]" by (fastforce simp: PPs_def)
	+ with \<open>s \<in> F\<close> \<open>F \<inter> .[S] = {}\<close> have False by blast
	+ }
	+ thus ?thesis by blast
	+ qed
	+ ultimately have "card (insert x S) \<le> card S" unfolding S_def by (rule max_subset)
	+ moreover from \<open>S \<subseteq> U\<close> \<open>finite U\<close> have "finite S" by (rule finite_subset)
	+ ultimately show False using \<open>x \<notin> S\<close> by simp
	+ qed
	+ qed
	+ finally show "card U + sum deg_pm ((\<lambda>f. f - monomial (Suc 0) x) ` F) < card U + sum deg_pm F"
	+ by simp
	+ qed
	+ ultimately show False ..
	+ }
	+ qed
	+ qed
	+qed
	+
	+corollary split_domI: "finite X \<Longrightarrow> U \<subseteq> X \<Longrightarrow> finite S \<Longrightarrow> split_dom TYPE('a::{zero,one}) (t, U, S)"
	+ using split_domI'[of "(t, U, S)"] by simp
	+
	+lemma split_empty:
	+ assumes "finite X" and "U \<subseteq> X"
	+ shows "split t U {} = ([], [(monomial (1::'a::{zero,one}) t, U)])"
	+proof -
	+ have "finite {}" ..
	+ with assms have "split_dom TYPE('a) (t, U, {})" by (rule split_domI)
	+ thus ?thesis by (simp add: split.psimps)
	+qed
	+
	+lemma split_induct [consumes 3, case_names base1 base2 step]:
	+ fixes P :: "('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow> _"
	+ assumes "finite X" and "U \<subseteq> X" and "finite S"
	+ assumes "\<And>t U S. U \<subseteq> X \<Longrightarrow> finite S \<Longrightarrow> 0 \<in> S \<Longrightarrow> P t U S ([(monomial (1::'a::{zero,one}) t, U)], [])"
	+ assumes "\<And>t U S. U \<subseteq> X \<Longrightarrow> finite S \<Longrightarrow> 0 \<notin> S \<Longrightarrow> S \<inter> .[U] = {} \<Longrightarrow> P t U S ([], [(monomial 1 t, U)])"
	+ assumes "\<And>t U S V x ps0 ps1 qs0 qs1. U \<subseteq> X \<Longrightarrow> finite S \<Longrightarrow> 0 \<notin> S \<Longrightarrow> S \<inter> .[U] \<noteq> {} \<Longrightarrow> V \<subseteq> U \<Longrightarrow>
	+ S \<inter> .[V] = {} \<Longrightarrow> (\<And>V'. V' \<subseteq> U \<Longrightarrow> S \<inter> .[V'] = {} \<Longrightarrow> card V' \<le> card V) \<Longrightarrow>
	+ x \<in> U \<Longrightarrow> x \<notin> V \<Longrightarrow> V = max_subset U (\<lambda>V'. S \<inter> .[V'] = {}) \<Longrightarrow> x = (SOME x'. x' \<in> U - V) \<Longrightarrow>
	+ (ps0, qs0) = split t (U - {x}) S \<Longrightarrow>
	+ (ps1, qs1) = split (Poly_Mapping.single x 1 + t) U ((\<lambda>f. f - Poly_Mapping.single x 1) ` S) \<Longrightarrow>
	+ split t U S = (ps0 @ ps1, qs0 @ qs1) \<Longrightarrow>
	+ P t (U - {x}) S (ps0, qs0) \<Longrightarrow>
	+ P (Poly_Mapping.single x 1 + t) U ((\<lambda>f. f - Poly_Mapping.single x 1) ` S) (ps1, qs1) \<Longrightarrow>
	+ P t U S (ps0 @ ps1, qs0 @ qs1)"
	+ shows "P t U S (split t U S)"
	+proof -
	+ from assms(1-3) have "split_dom TYPE('a) (t, U, S)" by (rule split_domI)
	+ thus ?thesis using assms(2,3)
	+ proof (induct t U S rule: split.pinduct)
	+ case step: (1 t U F)
	+ from step(4) assms(1) have "finite U" by (rule finite_subset)
	+ define S where "S = max_subset U (\<lambda>V. F \<inter> .[V] = {})"
	+ define x where "x = (SOME x'. x' \<in> U \<and> x' \<notin> S)"
	+ show ?case
	+ proof (simp add: split.psimps[OF step(1)] S_def[symmetric] x_def[symmetric] split: prod.split, intro allI conjI impI)
	+ assume "0 \<in> F"
	+ with step(4, 5) show "P t U F ([(monomial 1 t, U)], [])" by (rule assms(4))
	+ thus "P t U F ([(monomial 1 t, U)], [])" .
	+ next
	+ assume "0 \<notin> F" and "F \<inter> .[U] = {}"
	+ with step(4, 5) show "P t U F ([], [(monomial 1 t, U)])" by (rule assms(5))
	+ next
	+ fix ps0 qs0 ps1 qs1 :: "((_ \<Rightarrow>\<^sub>0 'a) \<times> _) list"
	+ assume "split (Poly_Mapping.single x (Suc 0) + t) U ((\<lambda>f. f - Poly_Mapping.single x (Suc 0)) ` F) = (ps1, qs1)"
	+ hence PQ1[symmetric]: "split (Poly_Mapping.single x 1 + t) U ((\<lambda>f. f - Poly_Mapping.single x 1) ` F) = (ps1, qs1)"
	+ by simp
	+ assume PQ0[symmetric]: "split t (U - {x}) F = (ps0, qs0)"
	+ assume "F \<inter> .[U] \<noteq> {}" and "0 \<notin> F"
	+ from this(2) have "F \<inter> .[{}] = {}" by simp
	+ with \<open>finite U\<close> empty_subsetI have "S \<subseteq> U" and "F \<inter> .[S] = {}"
	+ unfolding S_def by (rule max_subset)+
	+ have S_max: "card S' \<le> card S" if "S' \<subseteq> U" and "F \<inter> .[S'] = {}" for S'
	+ using \<open>finite U\<close> that unfolding S_def by (rule max_subset)
	+ have "x \<in> U \<and> x \<notin> S" unfolding x_def
	+ proof (rule someI_ex)
	+ from \<open>F \<inter> .[U] \<noteq> {}\<close> \<open>F \<inter> .[S] = {}\<close> have "S \<noteq> U" by blast
	+ with \<open>S \<subseteq> U\<close> show "\<exists>y. y \<in> U \<and> y \<notin> S" by blast
	+ qed
	+ hence "x \<in> U" and "x \<notin> S" by simp_all
	+ from step(4, 5) \<open>0 \<notin> F\<close> \<open>F \<inter> .[U] \<noteq> {}\<close> \<open>S \<subseteq> U\<close> \<open>F \<inter> .[S] = {}\<close> S_max \<open>x \<in> U\<close> \<open>x \<notin> S\<close> S_def _ PQ0 PQ1
	+ show "P t U F (ps0 @ ps1, qs0 @ qs1)"
	+ proof (rule assms(6))
	+ show "P t (U - {x}) F (ps0, qs0)"
	+ unfolding PQ0 using \<open>0 \<notin> F\<close> \<open>F \<inter> .[U] \<noteq> {}\<close> _ _ step(5)
	+ proof (rule step(2))
	+ from \<open>U \<subseteq> X\<close> show "U - {x} \<subseteq> X" by fastforce
	+ qed (simp add: x_def S_def)
	+ next
	+ show "P (Poly_Mapping.single x 1 + t) U ((\<lambda>f. f - Poly_Mapping.single x 1) ` F) (ps1, qs1)"
	+ unfolding PQ1 using \<open>0 \<notin> F\<close> \<open>F \<inter> .[U] \<noteq> {}\<close> _ refl PQ0 \<open>U \<subseteq> X\<close>
	+ proof (rule step(3))
	+ from \<open>finite F\<close> show "finite ((\<lambda>f. f - Poly_Mapping.single x 1) ` F)" by (rule finite_imageI)
	+ qed (simp add: x_def S_def)
	+ next
	+ show "split t U F = (ps0 @ ps1, qs0 @ qs1)" using \<open>0 \<notin> F\<close> \<open>F \<inter> .[U] \<noteq> {}\<close>
	+ by (simp add: split.psimps[OF step(1)] Let_def flip: S_def x_def PQ0 PQ1 del: One_nat_def)
	+ qed (assumption+, simp add: x_def S_def)
	+ qed
	+ qed
	+qed
	+
	+lemma valid_decomp_split:
	+ assumes "finite X" and "U \<subseteq> X" and "finite S" and "t \<in> .[X]"
	+ shows "valid_decomp X (fst ((split t U S)::(_ \<times> (((_ \<Rightarrow>\<^sub>0 'a::zero_neq_one) \<times> _) list))))"
	+ and "valid_decomp X (snd ((split t U S)::(_ \<times> (((_ \<Rightarrow>\<^sub>0 'a::zero_neq_one) \<times> _) list))))"
	+ (is "valid_decomp _ (snd ?s)")
	+proof -
	+ from assms have "valid_decomp X (fst ?s) \<and> valid_decomp X (snd ?s)"
	+ proof (induct t U S rule: split_induct)
	+ case (base1 t U S)
	+ from base1(1, 4) show ?case by (simp add: valid_decomp_def monomial_0_iff Polys_closed_monomial)
	+ next
	+ case (base2 t U S)
	+ from base2(1, 5) show ?case by (simp add: valid_decomp_def monomial_0_iff Polys_closed_monomial)
	+ next
	+ case (step t U S V x ps0 ps1 qs0 qs1)
	+ from step.hyps(8, 1) have "x \<in> X" ..
	+ hence "Poly_Mapping.single x 1 \<in> .[X]" by (rule PPs_closed_single)
	+ hence "Poly_Mapping.single x 1 + t \<in> .[X]" using step.prems by (rule PPs_closed_plus)
	+ with step.hyps(15, 16) step.prems show ?case by (simp add: valid_decomp_append)
	+ qed
	+ thus "valid_decomp X (fst ?s)" and "valid_decomp X (snd ?s)" by simp_all
	+qed
	+
	+lemma monomial_decomp_split:
	+ assumes "finite X" and "U \<subseteq> X" and "finite S"
	+ shows "monomial_decomp (fst ((split t U S)::(_ \<times> (((_ \<Rightarrow>\<^sub>0 'a::zero_neq_one) \<times> _) list))))"
	+ and "monomial_decomp (snd ((split t U S)::(_ \<times> (((_ \<Rightarrow>\<^sub>0 'a::zero_neq_one) \<times> _) list))))"
	+ (is "monomial_decomp (snd ?s)")
	+proof -
	+ from assms have "monomial_decomp (fst ?s) \<and> monomial_decomp (snd ?s)"
	+ proof (induct t U S rule: split_induct)
	+ case (base1 t U S)
	+ from base1(1) show ?case by (simp add: monomial_decomp_def monomial_is_monomial)
	+ next
	+ case (base2 t U S)
	+ from base2(1) show ?case by (simp add: monomial_decomp_def monomial_is_monomial)
	+ next
	+ case (step t U S V x ps0 ps1 qs0 qs1)
	+ from step.hyps(15, 16) show ?case by (auto simp: monomial_decomp_def)
	+ qed
	+ thus "monomial_decomp (fst ?s)" and "monomial_decomp (snd ?s)" by simp_all
	+qed
	+
	+lemma split_splits_wrt:
	+ assumes "finite X" and "U \<subseteq> X" and "finite S" and "t \<in> .[X]"
	+ and "ideal F \<div> monomial 1 t = ideal (monomial 1 ` S)"
	+ shows "splits_wrt (split t U S) (cone (monomial (1::'a::{comm_ring_1,ring_no_zero_divisors}) t, U)) F"
	+ using assms
	+proof (induct t U S rule: split_induct)
	+ case (base1 t U S)
	+ from base1(3) have "cone (monomial 1 t, U) \<subseteq> ideal F" by (simp only: lem_4_2_1 base1(5))
	+ show ?case
	+ proof (rule splits_wrtI)
	+ fix h0 U0
	+ assume "(h0, U0) \<in> set [(monomial (1::'a) t, U)]"
	+ hence h0: "h0 = monomial 1 t" and "U0 = U" by simp_all
	+ note this(1)
	+ also have "monomial 1 t \<in> cone (monomial (1::'a) t, U)" by (fact tip_in_cone)
	+ also have "\<dots> \<subseteq> ideal F" by fact
	+ finally show "h0 \<in> ideal F" .
	+
	+ from base1(4) have "h0 \<in> P[X]" unfolding h0 by (rule Polys_closed_monomial)
	+ moreover from base1(1) have "U0 \<subseteq> X" by (simp only: \<open>U0 = U\<close>)
	+ ultimately show "cone (h0, U0) \<subseteq> P[X]" by (rule cone_subset_PolysI)
	+ qed (simp_all add: cone_decomp_singleton \<open>U \<subseteq> X\<close>)
	+next
	+ case (base2 t U S)
	+ from base2(4) have "cone (monomial 1 t, U) \<inter> ideal F = {0}" by (simp only: lem_4_2_2 base2(6))
	+ show ?case
	+ proof (rule splits_wrtI)
	+ fix h0 U0
	+ assume "(h0, U0) \<in> set [(monomial (1::'a) t, U)]"
	+ hence h0: "h0 = monomial 1 t" and "U0 = U" by simp_all
	+ note this(1)
	+ also from base2(5) have "monomial 1 t \<in> P[X]" by (rule Polys_closed_monomial)
	+ finally have "h0 \<in> P[X]" .
	+ moreover from base2(1) have "U0 \<subseteq> X" by (simp only: \<open>U0 = U\<close>)
	+ ultimately show "cone (h0, U0) \<subseteq> P[X]" by (rule cone_subset_PolysI)
	+ next
	+ fix h0 U0 a
	+ assume "(h0, U0) \<in> set [(monomial (1::'a) t, U)]" and "a \<in> cone (h0, U0)"
	+ hence "a \<in> cone (monomial 1 t, U)" by simp
	+ moreover assume "a \<in> ideal F"
	+ ultimately have "a \<in> cone (monomial 1 t, U) \<inter> ideal F" by (rule IntI)
	+ also have "\<dots> = {0}" by fact
	+ finally show "a = 0" by simp
	+ qed (simp_all add: cone_decomp_singleton \<open>U \<subseteq> X\<close>)
	+next
	+ case (step t U S V x ps0 ps1 qs0 qs1)
	+ let ?x = "Poly_Mapping.single x 1"
	+ from step.prems have 0: "splits_wrt (ps0, qs0) (cone (monomial 1 t, U - {x})) F" by (rule step.hyps)
	+ have 1: "splits_wrt (ps1, qs1) (cone (monomial 1 (?x + t), U)) F"
	+ proof (rule step.hyps)
	+ from step.hyps(8, 1) have "x \<in> X" ..
	+ hence "?x \<in> .[X]" by (rule PPs_closed_single)
	+ thus "?x + t \<in> .[X]" using step.prems(1) by (rule PPs_closed_plus)
	+ next
	+ have "ideal F \<div> monomial 1 (?x + t) = ideal F \<div> monomial 1 t \<div> monomial 1 ?x"
	+ by (simp add: times_monomial_monomial add.commute)
	+ also have "\<dots> = ideal (monomial 1 ` S) \<div> monomial 1 ?x" by (simp only: step.prems)
	+ finally show "ideal F \<div> monomial 1 (?x + t) = ideal (monomial 1 ` (\<lambda>s. s - ?x) ` S)"
	+ by (simp only: quot_monomial_ideal_monomial)
	+ qed
	+
	+ show ?case
	+ proof (rule splits_wrtI)
	+ from step.hyps(8) have U: "insert x U = U" by blast
	+ have "direct_decomp (cone (monomial (1::'a) t, insert x (U - {x})))
	+ [cone (monomial 1 t, U - {x}),
	+ cone (monomial 1 (monomial (Suc 0) x) * monomial 1 t, insert x (U - {x}))]"
	+ by (rule direct_decomp_cone_insert) simp
	+ hence "direct_decomp (cone (monomial (1::'a) t, U))
	+ [cone (monomial 1 t, U - {x}), cone (monomial 1 (?x + t), U)]"
	+ by (simp add: U times_monomial_monomial)
	+ moreover from 0 have "cone_decomp (cone (monomial 1 t, U - {x})) (ps0 @ qs0)"
	+ by (rule splits_wrtD)
	+ moreover from 1 have "cone_decomp (cone (monomial 1 (?x + t), U)) (ps1 @ qs1)"
	+ by (rule splits_wrtD)
	+ ultimately have "cone_decomp (cone (monomial 1 t, U)) ((ps0 @ qs0) @ (ps1 @ qs1))"
	+ by (rule cone_decomp_append)
	+ thus "cone_decomp (cone (monomial 1 t, U)) ((ps0 @ ps1) @ qs0 @ qs1)"
	+ by (rule cone_decomp_perm) (metis append.assoc perm_append1 perm_append2 perm_append_swap)
	+ next
	+ fix h0 U0
	+ assume "(h0, U0) \<in> set (ps0 @ ps1)"
	+ hence "(h0, U0) \<in> set ps0 \<union> set ps1" by simp
	+ hence "cone (h0, U0) \<subseteq> ideal F \<inter> P[X]"
	+ proof
	+ assume "(h0, U0) \<in> set ps0"
	+ with 0 show ?thesis by (rule splits_wrtD)
	+ next
	+ assume "(h0, U0) \<in> set ps1"
	+ with 1 show ?thesis by (rule splits_wrtD)
	+ qed
	+ hence *: "cone (h0, U0) \<subseteq> ideal F" and "cone (h0, U0) \<subseteq> P[X]" by simp_all
	+ from this(2) show "cone (h0, U0) \<subseteq> P[X]" .
	+
	+ from tip_in_cone * show "h0 \<in> ideal F" ..
	+ next
	+ fix h0 U0
	+ assume "(h0, U0) \<in> set (qs0 @ qs1)"
	+ hence "(h0, U0) \<in> set qs0 \<union> set qs1" by simp
	+ thus "cone (h0, U0) \<subseteq> P[X]"
	+ proof
	+ assume "(h0, U0) \<in> set qs0"
	+ with 0 show ?thesis by (rule splits_wrtD)
	+ next
	+ assume "(h0, U0) \<in> set qs1"
	+ with 1 show ?thesis by (rule splits_wrtD)
	+ qed
	+
	+ from \<open>(h0, U0) \<in> set qs0 \<union> set qs1\<close> have "cone (h0, U0) \<inter> ideal F = {0}"
	+ proof
	+ assume "(h0, U0) \<in> set qs0"
	+ with 0 show ?thesis by (rule splits_wrtD)
	+ next
	+ assume "(h0, U0) \<in> set qs1"
	+ with 1 show ?thesis by (rule splits_wrtD)
	+ qed
	+ thus "\<And>a. a \<in> cone (h0, U0) \<Longrightarrow> a \<in> ideal F \<Longrightarrow> a = 0" by blast
	+ qed
	+qed
	+
	+lemma lem_4_5:
	+ assumes "finite X" and "U \<subseteq> X" and "t \<in> .[X]" and "F \<subseteq> P[X]"
	+ and "ideal F \<div> monomial 1 t = ideal (monomial (1::'a) ` S)"
	+ and "cone (monomial (1::'a::field) t', V) \<subseteq> cone (monomial 1 t, U) \<inter> normal_form F ` P[X]"
	+ shows "V \<subseteq> U" and "S \<inter> .[V] = {}"
	+proof -
	+ let ?t = "monomial (1::'a) t"
	+ let ?t' = "monomial (1::'a) t'"
	+ from assms(6) have 1: "cone (?t', V) \<subseteq> cone (?t, U)" and 2: "cone (?t', V) \<subseteq> normal_form F ` P[X]"
	+ by blast+
	+ from this(1) show "V \<subseteq> U" by (rule cone_subsetD) (simp add: monomial_0_iff)
	+
	+ show "S \<inter> .[V] = {}"
	+ proof
	+ let ?t = "monomial (1::'a) t"
	+ let ?t' = "monomial (1::'a) t'"
	+ show "S \<inter> .[V] \<subseteq> {}"
	+ proof
	+ fix s
	+ assume "s \<in> S \<inter> .[V]"
	+ hence "s \<in> S" and "s \<in> .[V]" by simp_all
	+ from this(2) have "monomial (1::'a) s \<in> P[V]" (is "?s \<in> _") by (rule Polys_closed_monomial)
	+ with refl have "?s * ?t \<in> cone (?t, V)" by (rule coneI)
	+ from tip_in_cone 1 have "?t' \<in> cone (?t, U)" ..
	+ then obtain s' where "s' \<in> P[U]" and t': "?t' = s' * ?t" by (rule coneE)
	+ note this(1)
	+ also from assms(2) have "P[U] \<subseteq> P[X]" by (rule Polys_mono)
	+ finally have "s' \<in> P[X]" .
	+ have "s' * ?s * ?t = ?s * ?t'" by (simp add: t')
	+ also from refl \<open>?s \<in> P[V]\<close> have "\<dots> \<in> cone (?t', V)" by (rule coneI)
	+ finally have "s' * ?s * ?t \<in> cone (?t', V)" .
	+ hence 1: "s' * ?s * ?t \<in> normal_form F ` P[X]" using 2 ..
	+ from \<open>s \<in> S\<close> have "?s \<in> monomial 1 ` S" by (rule imageI)
	+ hence "?s \<in> ideal (monomial 1 ` S)" by (rule ideal.span_base)
	+ hence "s' * ?s \<in> ideal (monomial 1 ` S)" by (rule ideal.span_scale)
	+ hence "s' * ?s \<in> ideal F \<div> ?t" by (simp only: assms(5))
	+ hence "s' * ?s * ?t \<in> ideal F" by (simp only: quot_set_iff mult.commute)
	+ hence "s' * ?s * ?t \<in> ideal F \<inter> normal_form F ` P[X]" using 1 by (rule IntI)
	+ also from assms(1, 4) have "\<dots> \<subseteq> {0}"
	+ by (auto simp: normal_form_normal_form simp flip: normal_form_zero_iff)
	+ finally have "?s * ?t' = 0" by (simp add: t' ac_simps)
	+ thus "s \<in> {}" by (simp add: times_monomial_monomial monomial_0_iff)
	+ qed
	+ qed (fact empty_subsetI)
	+qed
	+
	+lemma lem_4_6:
	+ assumes "finite X" and "U \<subseteq> X" and "finite S" and "t \<in> .[X]" and "F \<subseteq> P[X]"
	+ and "ideal F \<div> monomial 1 t = ideal (monomial 1 ` S)"
	+ assumes "cone (monomial 1 t', V) \<subseteq> cone (monomial 1 t, U) \<inter> normal_form F ` P[X]"
	+ obtains V' where "(monomial 1 t, V') \<in> set (snd (split t U S))" and "card V \<le> card V'"
	+proof -
	+ let ?t = "monomial (1::'a) t"
	+ let ?t' = "monomial (1::'a) t'"
	+ from assms(7) have "cone (?t', V) \<subseteq> cone (?t, U)" and "cone (?t', V) \<subseteq> normal_form F ` P[X]"
	+ by blast+
	+ from assms(1, 2, 4, 5, 6, 7) have "V \<subseteq> U" and "S \<inter> .[V] = {}" by (rule lem_4_5)+
	+ with assms(1, 2, 3) show ?thesis using that
	+ proof (induct t U S arbitrary: V thesis rule: split_induct)
	+ case (base1 t U S)
	+ from base1.hyps(3) have "0 \<in> S \<inter> .[V]" using zero_in_PPs by (rule IntI)
	+ thus ?case by (simp add: base1.prems(2))
	+ next
	+ case (base2 t U S)
	+ show ?case
	+ proof (rule base2.prems)
	+ from base2.hyps(1) assms(1) have "finite U" by (rule finite_subset)
	+ thus "card V \<le> card U" using base2.prems(1) by (rule card_mono)
	+ qed simp
	+ next
	+ case (step t U S V0 x ps0 ps1 qs0 qs1)
	+ from step.prems(1, 2) have 0: "card V \<le> card V0" by (rule step.hyps)
	+ from step.hyps(5, 9) have "V0 \<subseteq> U - {x}" by blast
	+ then obtain V' where 1: "(monomial 1 t, V') \<in> set (snd (ps0, qs0))" and 2: "card V0 \<le> card V'"
	+ using step.hyps(6) by (rule step.hyps)
	+ show ?case
	+ proof (rule step.prems)
	+ from 1 show "(monomial 1 t, V') \<in> set (snd (ps0 @ ps1, qs0 @ qs1))" by simp
	+ next
	+ from 0 2 show "card V \<le> card V'" by (rule le_trans)
	+ qed
	+ qed
	+qed
	+
	+lemma lem_4_7:
	+ assumes "finite X" and "S \<subseteq> .[X]" and "g \<in> punit.reduced_GB (monomial (1::'a) ` S)"
	+ and "cone_decomp (P[X] \<inter> ideal (monomial (1::'a::field) ` S)) ps"
	+ and "monomial_decomp ps"
	+ obtains U where "(g, U) \<in> set ps"
	+proof -
	+ let ?S = "monomial (1::'a) ` S"
	+ let ?G = "punit.reduced_GB ?S"
	+ note assms(1)
	+ moreover from assms(2) have "?S \<subseteq> P[X]" by (auto intro: Polys_closed_monomial)
	+ moreover have "is_monomial_set ?S"
	+ by (auto intro!: is_monomial_setI monomial_is_monomial)
	+ ultimately have "is_monomial_set ?G" by (rule reduced_GB_is_monomial_set_Polys)
	+ hence "is_monomial g" using assms(3) by (rule is_monomial_setD)
	+ hence "g \<noteq> 0" by (rule monomial_not_0)
	+ moreover from assms(1) \<open>?S \<subseteq> P[X]\<close> have "punit.is_monic_set ?G"
	+ by (rule reduced_GB_is_monic_set_Polys)
	+ ultimately have "punit.lc g = 1" using assms(3) by (simp add: punit.is_monic_set_def)
	+ moreover define t where "t = lpp g"
	+ moreover from \<open>is_monomial g\<close> have "monomial (punit.lc g) (lpp g) = g"
	+ by (rule punit.monomial_eq_itself)
	+ ultimately have g: "g = monomial 1 t" by simp
	+ hence "t \<in> keys g" by simp
	+ from assms(3) have "g \<in> ideal ?G" by (rule ideal.span_base)
	+ also from assms(1) \<open>?S \<subseteq> P[X]\<close> have ideal_G: "\<dots> = ideal ?S" by (rule reduced_GB_ideal_Polys)
	+ finally have "g \<in> ideal ?S" .
	+ moreover from assms(3) have "g \<in> P[X]" by rule (intro reduced_GB_Polys assms(1) \<open>?S \<subseteq> P[X]\<close>)
	+ ultimately have "g \<in> P[X] \<inter> ideal ?S" by simp
	+ with assms(4) have "g \<in> sum_list ` listset (map cone ps)"
	+ by (simp only: cone_decomp_def direct_decompD)
	+ with assms(5) obtain d h U where *: "(h, U) \<in> set ps" and "d \<noteq> 0" and "monomial d t \<in> cone (h, U)"
	+ using \<open>t \<in> keys g\<close> by (rule monomial_decomp_sum_list_monomial_in_cone)
	+ from this(3) zero_in_PPs have "punit.monom_mult (1 / d) 0 (monomial d t) \<in> cone (h, U)"
	+ by (rule cone_closed_monom_mult)
	+ with \<open>d \<noteq> 0\<close> have "g \<in> cone (h, U)" by (simp add: g punit.monom_mult_monomial)
	+ then obtain q where "q \<in> P[U]" and g': "g = q * h" by (rule coneE)
	+ from \<open>g \<noteq> 0\<close> have "q \<noteq> 0" and "h \<noteq> 0" by (auto simp: g')
	+ hence lt_g': "lpp g = lpp q + lpp h" unfolding g' by (rule lp_times)
	+ hence adds1: "lpp h adds t" by (simp add: t_def)
	+ from assms(5) * have "is_monomial h" and "punit.lc h = 1" by (rule monomial_decompD)+
	+ moreover from this(1) have "monomial (punit.lc h) (lpp h) = h"
	+ by (rule punit.monomial_eq_itself)
	+ moreover define s where "s = lpp h"
	+ ultimately have h: "h = monomial 1 s" by simp
	+ have "punit.lc q = punit.lc g" by (simp add: g' lc_times \<open>punit.lc h = 1\<close>)
	+ hence "punit.lc q = 1" by (simp only: \<open>punit.lc g = 1\<close>)
	+ note tip_in_cone
	+ also from assms(4) * have "cone (h, U) \<subseteq> P[X] \<inter> ideal ?S" by (rule cone_decomp_cone_subset)
	+ also have "\<dots> \<subseteq> ideal ?G" by (simp add: ideal_G)
	+ finally have "h \<in> ideal ?G" .
	+ from assms(1) \<open>?S \<subseteq> P[X]\<close> have "punit.is_Groebner_basis ?G" by (rule reduced_GB_is_GB_Polys)
	+ then obtain g' where "g' \<in> ?G" and "g' \<noteq> 0" and adds2: "lpp g' adds lpp h"
	+ using \<open>h \<in> ideal ?G\<close> \<open>h \<noteq> 0\<close> by (rule punit.GB_adds_lt[simplified])
	+ from this(3) adds1 have "lpp g' adds t" by (rule adds_trans)
	+ with _ \<open>g' \<noteq> 0\<close> \<open>t \<in> keys g\<close> have "punit.is_red {g'} g"
	+ by (rule punit.is_red_addsI[simplified]) simp
	+ have "g' = g"
	+ proof (rule ccontr)
	+ assume "g' \<noteq> g"
	+ with \<open>g' \<in> ?G\<close> have "{g'} \<subseteq> ?G - {g}" by simp
	+ with \<open>punit.is_red {g'} g\<close> have red: "punit.is_red (?G - {g}) g" by (rule punit.is_red_subset)
	+ from assms(1) \<open>?S \<subseteq> P[X]\<close> have "punit.is_auto_reduced ?G" by (rule reduced_GB_is_auto_reduced_Polys)
	+ hence "\<not> punit.is_red (?G - {g}) g" using assms(3) by (rule punit.is_auto_reducedD)
	+ thus False using red ..
	+ qed
	+ with adds2 have "t adds lpp h" by (simp only: t_def)
	+ with adds1 have "lpp h = t" by (rule adds_antisym)
	+ hence "lpp q = 0" using lt_g' by (simp add: t_def)
	+ hence "monomial (punit.lc q) 0 = q" by (rule punit.lt_eq_min_term_monomial[simplified])
	+ hence "g = h" by (simp add: \<open>punit.lc q = 1\<close> g')
	+ with * have "(g, U) \<in> set ps" by simp
	+ thus ?thesis ..
	+qed
	+
	+lemma snd_splitI:
	+ assumes "finite X" and "U \<subseteq> X" and "finite S" and "0 \<notin> S"
	+ obtains V where "V \<subseteq> U" and "(monomial 1 t, V) \<in> set (snd (split t U S))"
	+ using assms
	+proof (induct t U S arbitrary: thesis rule: split_induct)
	+ case (base1 t U S)
	+ from base1.prems(2) base1.hyps(3) show ?case ..
	+next
	+ case (base2 t U S)
	+ from subset_refl show ?case by (rule base2.prems) simp
	+next
	+ case (step t U S V0 x ps0 ps1 qs0 qs1)
	+ from step.hyps(3) obtain V where 1: "V \<subseteq> U - {x}" and 2: "(monomial 1 t, V) \<in> set (snd (ps0, qs0))"
	+ using step.hyps(15) by blast
	+ show ?case
	+ proof (rule step.prems)
	+ from 1 show "V \<subseteq> U" by blast
	+ next
	+ from 2 show "(monomial 1 t, V) \<in> set (snd (ps0 @ ps1, qs0 @ qs1))" by fastforce
	+ qed
	+qed
	+
	+lemma fst_splitE:
	+ assumes "finite X" and "U \<subseteq> X" and "finite S" and "0 \<notin> S"
	+ and "(monomial (1::'a) s, V) \<in> set (fst (split t U S))"
	+ obtains t' x where "t' \<in> .[X]" and "x \<in> X" and "V \<subseteq> U" and "0 \<notin> (\<lambda>s. s - t') ` S"
	+ and "s = t' + t + Poly_Mapping.single x 1"
	+ and "(monomial (1::'a::zero_neq_one) s, V) \<in> set (fst (split (t' + t) V ((\<lambda>s. s - t') ` S)))"
	+ and "set (snd (split (t' + t) V ((\<lambda>s. s - t') ` S))) \<subseteq> (set (snd (split t U S)) :: ((_ \<Rightarrow>\<^sub>0 'a) \<times> _) set)"
	+ using assms
	+proof (induct t U S arbitrary: thesis rule: split_induct)
	+ case (base1 t U S)
	+ from base1.prems(2) base1.hyps(3) show ?case ..
	+next
	+ case (base2 t U S)
	+ from base2.prems(3) show ?case by simp
	+next
	+ case (step t U S V0 x ps0 ps1 qs0 qs1)
	+ from step.prems(3) have "(monomial 1 s, V) \<in> set ps0 \<union> set ps1" by simp
	+ thus ?case
	+ proof
	+ assume "(monomial 1 s, V) \<in> set ps0"
	+ hence "(monomial (1::'a) s, V) \<in> set (fst (ps0, qs0))" by (simp only: fst_conv)
	+ with step.hyps(3) obtain t' x' where "t' \<in> .[X]" and "x' \<in> X" and "V \<subseteq> U - {x}"
	+ and "0 \<notin> (\<lambda>s. s - t') ` S" and "s = t' + t + Poly_Mapping.single x' 1"
	+ and "(monomial (1::'a) s, V) \<in> set (fst (split (t' + t) V ((\<lambda>s. s - t') ` S)))"
	+ and "set (snd (split (t' + t) V ((\<lambda>s. s - t') ` S))) \<subseteq> set (snd (ps0, qs0))"
	+ using step.hyps(15) by blast
	+ note this(7)
	+ also have "set (snd (ps0, qs0)) \<subseteq> set (snd (ps0 @ ps1, qs0 @ qs1))" by simp
	+ finally have "set (snd (split (t' + t) V ((\<lambda>s. s - t') ` S))) \<subseteq> set (snd (ps0 @ ps1, qs0 @ qs1))" .
	+ from \<open>V \<subseteq> U - {x}\<close> have "V \<subseteq> U" by blast
	+ show ?thesis by (rule step.prems) fact+
	+ next
	+ assume "(monomial 1 s, V) \<in> set ps1"
	+ show ?thesis
	+ proof (cases "0 \<in> (\<lambda>f. f - Poly_Mapping.single x 1) ` S")
	+ case True
	+ from step.hyps(2) have fin: "finite ((\<lambda>f. f - Poly_Mapping.single x 1) ` S)"
	+ by (rule finite_imageI)
	+ have "split (Poly_Mapping.single x 1 + t) U ((\<lambda>f. f - Poly_Mapping.single x 1) ` S) =
	+ ([(monomial (1::'a) (Poly_Mapping.single x 1 + t), U)], [])"
	+ by (simp only: split.psimps[OF split_domI, OF assms(1) step.hyps(1) fin] True if_True)
	+ hence "ps1 = [(monomial 1 (Poly_Mapping.single x 1 + t), U)]"
	+ by (simp only: step.hyps(13)[symmetric] prod.inject)
	+ with \<open>(monomial 1 s, V) \<in> set ps1\<close> have s: "s = Poly_Mapping.single x 1 + t" and "V = U"
	+ by (auto dest!: monomial_inj)
	+ show ?thesis
	+ proof (rule step.prems)
	+ show "0 \<in> .[X]" by (fact zero_in_PPs)
	+ next
	+ from step.hyps(8, 1) show "x \<in> X" ..
	+ next
	+ show "V \<subseteq> U" by (simp add: \<open>V = U\<close>)
	+ next
	+ from step.hyps(3) show "0 \<notin> (\<lambda>s. s - 0) ` S" by simp
	+ next
	+ show "s = 0 + t + Poly_Mapping.single x 1" by (simp add: s add.commute)
	+ next
	+ show "(monomial (1::'a) s, V) \<in> set (fst (split (0 + t) V ((\<lambda>s. s - 0) ` S)))"
	+ using \<open>(monomial 1 s, V) \<in> set ps1\<close> by (simp add: step.hyps(14) \<open>V = U\<close>)
	+ next
	+ show "set (snd (split (0 + t) V ((\<lambda>s. s - 0) ` S))) \<subseteq> set (snd (ps0 @ ps1, qs0 @ qs1))"
	+ by (simp add: step.hyps(14) \<open>V = U\<close>)
	+ qed
	+ next
	+ case False
	+ moreover from \<open>(monomial 1 s, V) \<in> set ps1\<close> have "(monomial 1 s, V) \<in> set (fst (ps1, qs1))"
	+ by (simp only: fst_conv)
	+ ultimately obtain t' x' where "t' \<in> .[X]" and "x' \<in> X" and "V \<subseteq> U"
	+ and 1: "0 \<notin> (\<lambda>s. s - t') ` (\<lambda>f. f - Poly_Mapping.single x 1) ` S"
	+ and s: "s = t' + (Poly_Mapping.single x 1 + t) + Poly_Mapping.single x' 1"
	+ and 2: "(monomial (1::'a) s, V) \<in> set (fst (split (t' + (Poly_Mapping.single x 1 + t)) V
	+ ((\<lambda>s. s - t') ` (\<lambda>f. f - Poly_Mapping.single x 1) ` S)))"
	+ and 3: "set (snd (split (t' + (Poly_Mapping.single x 1 + t)) V ((\<lambda>s. s - t') ` (\<lambda>f. f - monomial 1 x) ` S))) \<subseteq>
	+ set (snd (ps1, qs1))"
	+ using step.hyps(16) by blast
	+ have eq: "(\<lambda>s. s - t') ` (\<lambda>f. f - Poly_Mapping.single x 1) ` S =
	+ (\<lambda>s. s - (t' + Poly_Mapping.single x 1)) ` S"
	+ by (simp add: image_image add.commute diff_diff_eq)
	+ show ?thesis
	+ proof (rule step.prems)
	+ from step.hyps(8, 1) have "x \<in> X" ..
	+ hence "Poly_Mapping.single x 1 \<in> .[X]" by (rule PPs_closed_single)
	+ with \<open>t' \<in> .[X]\<close> show "t' + Poly_Mapping.single x 1 \<in> .[X]" by (rule PPs_closed_plus)
	+ next
	+ from 1 show "0 \<notin> (\<lambda>s. s - (t' + Poly_Mapping.single x 1)) ` S"
	+ by (simp only: eq not_False_eq_True)
	+ next
	+ show "s = t' + Poly_Mapping.single x 1 + t + Poly_Mapping.single x' 1" by (simp only: s ac_simps)
	+ next
	+ show "(monomial (1::'a) s, V) \<in> set (fst (split (t' + Poly_Mapping.single x 1 + t) V
	+ ((\<lambda>s. s - (t' + Poly_Mapping.single x 1)) ` S)))"
	+ using 2 by (simp only: eq add.assoc)
	+ next
	+ have "set (snd (split (t' + Poly_Mapping.single x 1 + t) V ((\<lambda>s. s - (t' + Poly_Mapping.single x 1)) ` S))) \<subseteq>
	+ set (snd (ps1, qs1))" (is "?x \<subseteq> _") using 3 by (simp only: eq add.assoc)
	+ also have "\<dots> \<subseteq> set (snd (ps0 @ ps1, qs0 @ qs1))" by simp
	+ finally show "?x \<subseteq> set (snd (ps0 @ ps1, qs0 @ qs1))" .
	+ qed fact+
	+ qed
	+ qed
	+qed
	+
	+lemma lem_4_8:
	+ assumes "finite X" and "finite S" and "S \<subseteq> .[X]" and "0 \<notin> S"
	+ and "g \<in> punit.reduced_GB (monomial (1::'a) ` S)"
	+ obtains t U where "U \<subseteq> X" and "(monomial (1::'a::field) t, U) \<in> set (snd (split 0 X S))"
	+ and "poly_deg g = Suc (deg_pm t)"
	+proof -
	+ let ?S = "monomial (1::'a) ` S"
	+ let ?G = "punit.reduced_GB ?S"
	+ have md1: "monomial_decomp (fst ((split 0 X S)::(_ \<times> (((_ \<Rightarrow>\<^sub>0 'a) \<times> _) list))))"
	+ and md2: "monomial_decomp (snd ((split 0 X S)::(_ \<times> (((_ \<Rightarrow>\<^sub>0 'a) \<times> _) list))))"
	+ using assms(1) subset_refl assms(2) by (rule monomial_decomp_split)+
	+ from assms(3) have 0: "?S \<subseteq> P[X]" by (auto intro: Polys_closed_monomial)
	+ with assms(1) have "punit.is_auto_reduced ?G" and "punit.is_monic_set ?G"
	+ and ideal_G: "ideal ?G = ideal ?S" and "0 \<notin> ?G"
	+ by (rule reduced_GB_is_auto_reduced_Polys, rule reduced_GB_is_monic_set_Polys,
	+ rule reduced_GB_ideal_Polys, rule reduced_GB_nonzero_Polys)
	+ from this(2, 4) assms(5) have "punit.lc g = 1" by (auto simp: punit.is_monic_set_def)
	+ have "is_monomial_set ?S" by (auto intro!: is_monomial_setI monomial_is_monomial)
	+ with assms(1) 0 have "is_monomial_set ?G" by (rule reduced_GB_is_monomial_set_Polys)
	+ hence "is_monomial g" using assms(5) by (rule is_monomial_setD)
	+ moreover define s where "s = lpp g"
	+ ultimately have g: "g = monomial 1 s" using \<open>punit.lc g = 1\<close> by (metis punit.monomial_eq_itself)
	+ note assms(1) subset_refl assms(2) zero_in_PPs
	+ moreover have "ideal ?G \<div> monomial 1 0 = ideal ?S" by (simp add: ideal_G)
	+ ultimately have "splits_wrt (split 0 X S) (cone (monomial (1::'a) 0, X)) ?G" by (rule split_splits_wrt)
	+ hence "splits_wrt (fst (split 0 X S), snd (split 0 X S)) P[X] ?G" by simp
	+ hence "cone_decomp (P[X] \<inter> ideal ?G) (fst (split 0 X S))"
	+ using md2 \<open>is_monomial_set ?G\<close> by (rule splits_wrt_cone_decomp_1)
	+ hence "cone_decomp (P[X] \<inter> ideal ?S) (fst (split 0 X S))" by (simp only: ideal_G)
	+ with assms(1, 3, 5) obtain U where "(g, U) \<in> set (fst (split 0 X S))" using md1 by (rule lem_4_7)
	+ with assms(1) subset_refl assms(2, 4) obtain t' x where "t' \<in> .[X]" and "x \<in> X" and "U \<subseteq> X"
	+ and "0 \<notin> (\<lambda>s. s - t') ` S" and s: "s = t' + 0 + Poly_Mapping.single x 1"
	+ and "(g, U) \<in> set (fst (split (t' + 0) U ((\<lambda>s. s - t') ` S)))"
	+ and "set (snd (split (t' + 0) U ((\<lambda>s. s - t') ` S))) \<subseteq> (set (snd (split 0 X S)) :: ((_ \<Rightarrow>\<^sub>0 'a) \<times> _) set)"
	+ unfolding g by (rule fst_splitE)
	+ let ?S = "(\<lambda>s. s - t') ` S"
	+ from assms(2) have "finite ?S" by (rule finite_imageI)
	+ with assms(1) \<open>U \<subseteq> X\<close> obtain V where "V \<subseteq> U"
	+ and "(monomial (1::'a) (t' + 0), V) \<in> set (snd (split (t' + 0) U ?S))"
	+ using \<open>0 \<notin> ?S\<close> by (rule snd_splitI)
	+ note this(2)
	+ also have "\<dots> \<subseteq> set (snd (split 0 X S))" by fact
	+ finally have "(monomial (1::'a) t', V) \<in> set (snd (split 0 X S))" by simp
	+ have "poly_deg g = Suc (deg_pm t')" by (simp add: g s deg_pm_plus deg_pm_single poly_deg_monomial)
	+ from \<open>V \<subseteq> U\<close> \<open>U \<subseteq> X\<close> have "V \<subseteq> X" by (rule subset_trans)
	+ show ?thesis by rule fact+
	+qed
	+
	+corollary cor_4_9:
	+ assumes "finite X" and "finite S" and "S \<subseteq> .[X]"
	+ and "g \<in> punit.reduced_GB (monomial (1::'a::field) ` S)"
	+ shows "poly_deg g \<le> Suc (Max (poly_deg ` fst ` (set (snd (split 0 X S)) :: ((_ \<Rightarrow>\<^sub>0 'a) \<times> _) set)))"
	+ (is "_ \<le> Suc (Max (poly_deg ` fst ` ?S))")
	+proof (cases "0 \<in> S")
	+ case True
	+ hence "1 \<in> monomial (1::'a) ` S" by (rule rev_image_eqI) (simp only: single_one)
	+ hence "1 \<in> ideal (monomial (1::'a) ` S)" by (rule ideal.span_base)
	+ hence "ideal (monomial (1::'a) ` S) = UNIV" by (simp only: ideal_eq_UNIV_iff_contains_one)
	+ moreover from assms(3) have "monomial (1::'a) ` S \<subseteq> P[X]" by (auto intro: Polys_closed_monomial)
	+ ultimately have "punit.reduced_GB (monomial (1::'a) ` S) = {1}"
	+ using assms(1) by (simp only: ideal_eq_UNIV_iff_reduced_GB_eq_one_Polys)
	+ with assms(4) show ?thesis by simp
	+next
	+ case False
	+ from finite_set have fin: "finite (poly_deg ` fst ` ?S)" by (intro finite_imageI)
	+ obtain t U where "(monomial 1 t, U) \<in> ?S" and g: "poly_deg g = Suc (deg_pm t)"
	+ using assms(1-3) False assms(4) by (rule lem_4_8)
	+ from this(1) have "poly_deg (fst (monomial (1::'a) t, U)) \<in> poly_deg ` fst ` ?S"
	+ by (intro imageI)
	+ hence "deg_pm t \<in> poly_deg ` fst ` ?S" by (simp add: poly_deg_monomial)
	+ with fin have "deg_pm t \<le> Max (poly_deg ` fst ` ?S)" by (rule Max_ge)
	+ thus "poly_deg g \<le> Suc (Max (poly_deg ` fst ` ?S))" by (simp add: g)
	+qed
	+
	+lemma standard_decomp_snd_split:
	+ assumes "finite X" and "U \<subseteq> X" and "finite S" and "S \<subseteq> .[X]" and "t \<in> .[X]"
	+ shows "standard_decomp (deg_pm t) (snd (split t U S) :: ((_ \<Rightarrow>\<^sub>0 'a::field) \<times> _) list)"
	+ using assms
	+proof (induct t U S rule: split_induct)
	+ case (base1 t U S)
	+ show ?case by (simp add: standard_decomp_Nil)
	+next
	+ case (base2 t U S)
	+ have "deg_pm t = poly_deg (monomial (1::'a) t)" by (simp add: poly_deg_monomial)
	+ thus ?case by (simp add: standard_decomp_singleton)
	+next
	+ case (step t U S V x ps0 ps1 qs0 qs1)
	+ from step.hyps(15) step.prems have qs0: "standard_decomp (deg_pm t) qs0" by (simp only: snd_conv)
	+ have "(\<lambda>s. s - Poly_Mapping.single x 1) ` S \<subseteq> .[X]"
	+ proof
	+ fix u
	+ assume "u \<in> (\<lambda>s. s - Poly_Mapping.single x 1) ` S"
	+ then obtain s where "s \<in> S" and u: "u = s - Poly_Mapping.single x 1" ..
	+ from this(1) step.prems(1) have "s \<in> .[X]" ..
	+ thus "u \<in> .[X]" unfolding u by (rule PPs_closed_minus)
	+ qed
	+ moreover from _ step.prems(2) have "Poly_Mapping.single x 1 + t \<in> .[X]"
	+ proof (rule PPs_closed_plus)
	+ from step.hyps(8, 1) have "x \<in> X" ..
	+ thus "Poly_Mapping.single x 1 \<in> .[X]" by (rule PPs_closed_single)
	+ qed
	+ ultimately have qs1: "standard_decomp (Suc (deg_pm t)) qs1" using step.hyps(16)
	+ by (simp add: deg_pm_plus deg_pm_single)
	+ show ?case unfolding snd_conv
	+ proof (rule standard_decompI)
	+ fix h U0
	+ assume "(h, U0) \<in> set ((qs0 @ qs1)\<^sub>+)"
	+ hence *: "(h, U0) \<in> set (qs0\<^sub>+) \<union> set (qs1\<^sub>+)" by (simp add: pos_decomp_append)
	+ thus "deg_pm t \<le> poly_deg h"
	+ proof
	+ assume "(h, U0) \<in> set (qs0\<^sub>+)"
	+ with qs0 show ?thesis by (rule standard_decompD)
	+ next
	+ assume "(h, U0) \<in> set (qs1\<^sub>+)"
	+ with qs1 have "Suc (deg_pm t) \<le> poly_deg h" by (rule standard_decompD)
	+ thus ?thesis by simp
	+ qed
	+
	+ fix d
	+ assume d1: "deg_pm t \<le> d" and d2: "d \<le> poly_deg h"
	+ from * show "\<exists>t' U'. (t', U') \<in> set (qs0 @ qs1) \<and> poly_deg t' = d \<and> card U0 \<le> card U'"
	+ proof
	+ assume "(h, U0) \<in> set (qs0\<^sub>+)"
	+ with qs0 obtain h' U' where "(h', U') \<in> set qs0" and "poly_deg h' = d" and "card U0 \<le> card U'"
	+ using d1 d2 by (rule standard_decompE)
	+ moreover from this(1) have "(h', U') \<in> set (qs0 @ qs1)" by simp
	+ ultimately show ?thesis by blast
	+ next
	+ assume "(h, U0) \<in> set (qs1\<^sub>+)"
	+ hence "(h, U0) \<in> set qs1" by (simp add: pos_decomp_def)
	+ from assms(1) step.hyps(1, 2) have "monomial_decomp (snd (split t U S) :: ((_ \<Rightarrow>\<^sub>0 'a) \<times> _) list)"
	+ by (rule monomial_decomp_split)
	+ hence md: "monomial_decomp (qs0 @ qs1)" by (simp add: step.hyps(14))
	+ moreover from \<open>(h, U0) \<in> set qs1\<close> have "(h, U0) \<in> set (qs0 @ qs1)" by simp
	+ ultimately have "is_monomial h" and "punit.lc h = 1" by (rule monomial_decompD)+
	+ moreover from this(1) have "monomial (punit.lc h) (lpp h) = h" by (rule punit.monomial_eq_itself)
	+ moreover define s where "s = lpp h"
	+ ultimately have h: "h = monomial 1 s" by simp
	+ from d1 have "deg_pm t = d \<or> Suc (deg_pm t) \<le> d" by auto
	+ thus ?thesis
	+ proof
	+ assume "deg_pm t = d"
	+ define F where "F = (*) (monomial 1 t) ` monomial (1::'a) ` S"
	+ have "F \<subseteq> P[X]"
	+ proof
	+ fix f
	+ assume "f \<in> F"
	+ then obtain u where "u \<in> S" and f: "f = monomial 1 (t + u)"
	+ by (auto simp: F_def times_monomial_monomial)
	+ from this(1) step.prems(1) have "u \<in> .[X]" ..
	+ with step.prems(2) have "t + u \<in> .[X]" by (rule PPs_closed_plus)
	+ thus "f \<in> P[X]" unfolding f by (rule Polys_closed_monomial)
	+ qed
	+ have "ideal F = (*) (monomial 1 t) ` ideal (monomial 1 ` S)"
	+ by (simp only: ideal.span_image_scale_eq_image_scale F_def)
	+ moreover have "inj ((*) (monomial (1::'a) t))"
	+ by (auto intro!: injI simp: times_monomial_left monomial_0_iff dest!: punit.monom_mult_inj_3)
	+ ultimately have eq: "ideal F \<div> monomial 1 t = ideal (monomial 1 ` S)"
	+ by (simp only: quot_set_image_times)
	+ with assms(1) step.hyps(1, 2) step.prems(2)
	+ have "splits_wrt (split t U S) (cone (monomial (1::'a) t, U)) F" by (rule split_splits_wrt)
	+ hence "splits_wrt (ps0 @ ps1, qs0 @ qs1) (cone (monomial 1 t, U)) F" by (simp only: step.hyps(14))
	+ with assms(1) have "cone_decomp (cone (monomial (1::'a) t, U) \<inter> normal_form F ` P[X]) (qs0 @ qs1)"
	+ using md _ \<open>F \<subseteq> P[X]\<close>
	+ by (rule splits_wrt_cone_decomp_2)
	+ (auto intro!: is_monomial_setI monomial_is_monomial simp: F_def times_monomial_monomial)
	+ hence "cone (monomial 1 s, U0) \<subseteq> cone (monomial (1::'a) t, U) \<inter> normal_form F ` P[X]"
	+ using \<open>(h, U0) \<in> set (qs0 @ qs1)\<close> unfolding h by (rule cone_decomp_cone_subset)
	+ with assms(1) step.hyps(1, 2) step.prems(2) \<open>F \<subseteq> P[X]\<close> eq
	+ obtain U' where "(monomial (1::'a) t, U') \<in> set (snd (split t U S))" and "card U0 \<le> card U'"
	+ by (rule lem_4_6)
	+ from this(1) have "(monomial 1 t, U') \<in> set (qs0 @ qs1)" by (simp add: step.hyps(14))
	+ show ?thesis
	+ proof (intro exI conjI)
	+ show "poly_deg (monomial (1::'a) t) = d" by (simp add: poly_deg_monomial \<open>deg_pm t = d\<close>)
	+ qed fact+
	+ next
	+ assume "Suc (deg_pm t) \<le> d"
	+ with qs1 \<open>(h, U0) \<in> set (qs1\<^sub>+)\<close> obtain h' U' where "(h', U') \<in> set qs1" and "poly_deg h' = d"
	+ and "card U0 \<le> card U'" using d2 by (rule standard_decompE)
	+ moreover from this(1) have "(h', U') \<in> set (qs0 @ qs1)" by simp
	+ ultimately show ?thesis by blast
	+ qed
	+ qed
	+ qed
	+qed
	+
	+theorem standard_cone_decomp_snd_split:
	+ fixes F
	+ defines "G \<equiv> punit.reduced_GB F"
	+ defines "ss \<equiv> (split 0 X (lpp ` G)) :: ((_ \<Rightarrow>\<^sub>0 'a::field) \<times> _) list \<times> _"
	+ defines "d \<equiv> Suc (Max (poly_deg ` fst ` set (snd ss)))"
	+ assumes "finite X" and "F \<subseteq> P[X]"
	+ shows "standard_decomp 0 (snd ss)" (is ?thesis1)
	+ and "cone_decomp (normal_form F ` P[X]) (snd ss)" (is ?thesis2)
	+ and "(\<And>f. f \<in> F \<Longrightarrow> homogeneous f) \<Longrightarrow> g \<in> G \<Longrightarrow> poly_deg g \<le> d"
	+proof -
	+ have "ideal G = ideal F" and "punit.is_Groebner_basis G" and "finite G" and "0 \<notin> G"
	+ and "G \<subseteq> P[X]" and "punit.is_reduced_GB G" using assms(4, 5) unfolding G_def
	+ by (rule reduced_GB_ideal_Polys, rule reduced_GB_is_GB_Polys, rule finite_reduced_GB_Polys,
	+ rule reduced_GB_nonzero_Polys, rule reduced_GB_Polys, rule reduced_GB_is_reduced_GB_Polys)
	+ define S where "S = lpp ` G"
	+ note assms(4) subset_refl
	+ moreover from \<open>finite G\<close> have "finite S" unfolding S_def by (rule finite_imageI)
	+ moreover from \<open>G \<subseteq> P[X]\<close> have "S \<subseteq> .[X]" unfolding S_def by (rule PPs_closed_image_lpp)
	+ ultimately have "standard_decomp (deg_pm (0::'x \<Rightarrow>\<^sub>0 nat)) (snd ss)"
	+ using zero_in_PPs unfolding ss_def S_def by (rule standard_decomp_snd_split)
	+ thus ?thesis1 by simp
	+
	+ let ?S = "monomial (1::'a) ` S"
	+ from \<open>S \<subseteq> .[X]\<close> have "?S \<subseteq> P[X]" by (auto intro: Polys_closed_monomial)
	+ have "splits_wrt ss (cone (monomial 1 0, X)) ?S"
	+ using assms(4) subset_refl \<open>finite S\<close> zero_in_PPs unfolding ss_def S_def
	+ by (rule split_splits_wrt) simp
	+ hence "splits_wrt (fst ss, snd ss) P[X] ?S" by simp
	+ with assms(4) have "cone_decomp (P[X] \<inter> normal_form ?S ` P[X]) (snd ss)" using _ _ \<open>?S \<subseteq> P[X]\<close>
	+ proof (rule splits_wrt_cone_decomp_2)
	+ from assms(4) subset_refl \<open>finite S\<close> show "monomial_decomp (snd ss)"
	+ unfolding ss_def S_def by (rule monomial_decomp_split)
	+ qed (auto intro!: is_monomial_setI monomial_is_monomial)
	+ moreover have "normal_form ?S ` P[X] = normal_form F ` P[X]"
	+ by (rule set_eqI)
	+ (simp add: image_normal_form_iff[OF assms(4)] assms(5) \<open>?S \<subseteq> P[X]\<close>,
	+ simp add: S_def is_red_reduced_GB_monomial_lt_GB_Polys[OF assms(4)] \<open>G \<subseteq> P[X]\<close> \<open>0 \<notin> G\<close> flip: G_def)
	+ moreover from assms(4, 5) have "normal_form F ` P[X] \<subseteq> P[X]"
	+ by (auto intro: Polys_closed_normal_form)
	+ ultimately show ?thesis2 by (simp only: Int_absorb1)
	+
	+ assume "\<And>f. f \<in> F \<Longrightarrow> homogeneous f"
	+ moreover note \<open>punit.is_reduced_GB G\<close> \<open>ideal G = ideal F\<close>
	+ moreover assume "g \<in> G"
	+ ultimately have "homogeneous g" by (rule is_reduced_GB_homogeneous)
	+ moreover have "lpp g \<in> keys g"
	+ proof (rule punit.lt_in_keys)
	+ from \<open>g \<in> G\<close> \<open>0 \<notin> G\<close> show "g \<noteq> 0" by blast
	+ qed
	+ ultimately have deg_lt: "deg_pm (lpp g) = poly_deg g" by (rule homogeneousD_poly_deg)
	+ from \<open>g \<in> G\<close> have "monomial 1 (lpp g) \<in> ?S" unfolding S_def by (intro imageI)
	+ also have "\<dots> = punit.reduced_GB ?S" unfolding S_def G_def using assms(4, 5)
	+ by (rule reduced_GB_monomial_lt_reduced_GB_Polys[symmetric])
	+ finally have "monomial 1 (lpp g) \<in> punit.reduced_GB ?S" .
	+ with assms(4) \<open>finite S\<close> \<open>S \<subseteq> .[X]\<close> have "poly_deg (monomial (1::'a) (lpp g)) \<le> d"
	+ unfolding d_def ss_def S_def[symmetric] by (rule cor_4_9)
	+ thus "poly_deg g \<le> d" by (simp add: poly_deg_monomial deg_lt)
	+qed
	+
	+subsection \<open>Splitting Ideals\<close>
	+
	+qualified definition ideal_decomp_aux :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) set \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<Rightarrow>
	+ ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::field) set \<times> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list)"
	+ where "ideal_decomp_aux F f =
	+ (let J = ideal F; L = (J \<div> f) \<inter> P[X]; L' = lpp ` punit.reduced_GB L in
	+ (() f ` normal_form L ` P[X], map (apfst (() f)) (snd (split 0 X L'))))"
	+
	+context
	+ assumes fin_X: "finite X"
	+begin
	+
	+lemma ideal_decomp_aux:
	+ assumes "finite F" and "F \<subseteq> P[X]" and "f \<in> P[X]"
	+ shows "fst (ideal_decomp_aux F f) \<subseteq> ideal {f}" (is ?thesis1)
	+ and "ideal F \<inter> fst (ideal_decomp_aux F f) = {0}" (is ?thesis2)
	+ and "direct_decomp (ideal (insert f F) \<inter> P[X]) [fst (ideal_decomp_aux F f), ideal F \<inter> P[X]]" (is ?thesis3)
	+ and "cone_decomp (fst (ideal_decomp_aux F f)) (snd (ideal_decomp_aux F f))" (is ?thesis4)
	+ and "f \<noteq> 0 \<Longrightarrow> valid_decomp X (snd (ideal_decomp_aux F f))" (is "_ \<Longrightarrow> ?thesis5")
	+ and "f \<noteq> 0 \<Longrightarrow> standard_decomp (poly_deg f) (snd (ideal_decomp_aux F f))" (is "_ \<Longrightarrow> ?thesis6")
	+ and "homogeneous f \<Longrightarrow> hom_decomp (snd (ideal_decomp_aux F f))" (is "_ \<Longrightarrow> ?thesis7")
	+proof -
	+ define J where "J = ideal F"
	+ define L where "L = (J \<div> f) \<inter> P[X]"
	+ define S where "S = (*) f ` normal_form L ` P[X]"
	+ define L' where "L' = lpp ` punit.reduced_GB L"
	+
	+ have eq: "ideal_decomp_aux F f = (S, map (apfst ((*) f)) (snd (split 0 X L')))"
	+ by (simp add: J_def ideal_decomp_aux_def Let_def L_def L'_def S_def)
	+
	+ have L_sub: "L \<subseteq> P[X]" by (simp add: L_def)
	+
	+ show ?thesis1 unfolding eq fst_conv
	+ proof
	+ fix s
	+ assume "s \<in> S"
	+ then obtain q where "s = normal_form L q * f" unfolding S_def by (elim imageE) auto
	+ also have "\<dots> \<in> ideal {f}" by (intro ideal.span_scale ideal.span_base singletonI)
	+ finally show "s \<in> ideal {f}" .
	+ qed
	+
	+ show ?thesis2
	+ proof (rule set_eqI)
	+ fix h
	+ show "h \<in> ideal F \<inter> fst (ideal_decomp_aux F f) \<longleftrightarrow> h \<in> {0}"
	+ proof
	+ assume "h \<in> ideal F \<inter> fst (ideal_decomp_aux F f)"
	+ hence "h \<in> J" and "h \<in> S" by (simp_all add: J_def S_def eq)
	+ from this(2) obtain q where "q \<in> P[X]" and h: "h = f * normal_form L q" by (auto simp: S_def)
	+ from fin_X L_sub this(1) have "normal_form L q \<in> P[X]" by (rule Polys_closed_normal_form)
	+ moreover from \<open>h \<in> J\<close> have "f * normal_form L q \<in> J" by (simp add: h)
	+ ultimately have "normal_form L q \<in> L" by (simp add: L_def quot_set_iff)
	+ hence "normal_form L q \<in> ideal L" by (rule ideal.span_base)
	+ with normal_form_diff_in_ideal[OF fin_X L_sub] have "(q - normal_form L q) + normal_form L q \<in> ideal L"
	+ by (rule ideal.span_add)
	+ hence "normal_form L q = 0" using fin_X L_sub by (simp add: normal_form_zero_iff)
	+ thus "h \<in> {0}" by (simp add: h)
	+ next
	+ assume "h \<in> {0}"
	+ moreover have "0 \<in> (*) f ` normal_form L ` P[X]"
	+ proof (intro image_eqI)
	+ from fin_X L_sub show "0 = normal_form L 0" by (simp only: normal_form_zero)
	+ qed (simp_all add: zero_in_Polys)
	+ ultimately show "h \<in> ideal F \<inter> fst (ideal_decomp_aux F f)" by (simp add: ideal.span_zero eq S_def)
	+ qed
	+ qed
	+
	+ have "direct_decomp (ideal (insert f F) \<inter> P[X]) [ideal F \<inter> P[X], fst (ideal_decomp_aux F f)]"
	+ unfolding eq fst_conv S_def L_def J_def using fin_X assms(2, 3) by (rule direct_decomp_ideal_insert)
	+ thus ?thesis3 using perm.swap by (rule direct_decomp_perm)
	+
	+ have std: "standard_decomp 0 (snd (split 0 X L') :: ((_ \<Rightarrow>\<^sub>0 'a) \<times> _) list)"
	+ and "cone_decomp (normal_form L ` P[X]) (snd (split 0 X L'))"
	+ unfolding L'_def using fin_X \<open>L \<subseteq> P[X]\<close> by (rule standard_cone_decomp_snd_split)+
	+ from this(2) show ?thesis4 unfolding eq fst_conv snd_conv S_def by (rule cone_decomp_map_times)
	+
	+ from fin_X \<open>L \<subseteq> P[X]\<close> have "finite (punit.reduced_GB L)" by (rule finite_reduced_GB_Polys)
	+ hence "finite L'" unfolding L'_def by (rule finite_imageI)
	+ {
	+ have "monomial_decomp (snd (split 0 X L') :: ((_ \<Rightarrow>\<^sub>0 'a) \<times> _) list)"
	+ using fin_X subset_refl \<open>finite L'\<close> by (rule monomial_decomp_split)
	+ hence "hom_decomp (snd (split 0 X L') :: ((_ \<Rightarrow>\<^sub>0 'a) \<times> _) list)"
	+ by (rule monomial_decomp_imp_hom_decomp)
	+ moreover assume "homogeneous f"
	+ ultimately show ?thesis7 unfolding eq snd_conv by (rule hom_decomp_map_times)
	+ }
	+
	+ have vd: "valid_decomp X (snd (split 0 X L') :: ((_ \<Rightarrow>\<^sub>0 'a) \<times> _) list)"
	+ using fin_X subset_refl \<open>finite L'\<close> zero_in_PPs by (rule valid_decomp_split)
	+ moreover note assms(3)
	+ moreover assume "f \<noteq> 0"
	+ ultimately show ?thesis5 unfolding eq snd_conv by (rule valid_decomp_map_times)
	+
	+ from std vd \<open>f \<noteq> 0\<close> have "standard_decomp (0 + poly_deg f) (map (apfst ((*) f)) (snd (split 0 X L')))"
	+ by (rule standard_decomp_map_times)
	+ thus ?thesis6 by (simp add: eq)
	+qed
	+
	+lemma ideal_decompE:
	+ fixes f0 :: "_ \<Rightarrow>\<^sub>0 'a::field"
	+ assumes "finite F" and "F \<subseteq> P[X]" and "f0 \<in> P[X]" and "\<And>f. f \<in> F \<Longrightarrow> poly_deg f \<le> poly_deg f0"
	+ obtains T ps where "valid_decomp X ps" and "standard_decomp (poly_deg f0) ps" and "cone_decomp T ps"
	+ and "(\<And>f. f \<in> F \<Longrightarrow> homogeneous f) \<Longrightarrow> hom_decomp ps"
	+ and "direct_decomp (ideal (insert f0 F) \<inter> P[X]) [ideal {f0} \<inter> P[X], T]"
	+ using assms(1, 2, 4)
	+proof (induct F arbitrary: thesis)
	+ case empty
	+ show ?case
	+ proof (rule empty.prems)
	+ show "valid_decomp X []" by (rule valid_decompI) simp_all
	+ next
	+ show "standard_decomp (poly_deg f0) []" by (rule standard_decompI) simp_all
	+ next
	+ show "cone_decomp {0} []" by (rule cone_decompI) (simp add: direct_decomp_def bij_betw_def)
	+ next
	+ have "direct_decomp (ideal {f0} \<inter> P[X]) [ideal {f0} \<inter> P[X]]"
	+ by (fact direct_decomp_singleton)
	+ hence "direct_decomp (ideal {f0} \<inter> P[X]) [{0}, ideal {f0} \<inter> P[X]]" by (rule direct_decomp_Cons_zeroI)
	+ thus "direct_decomp (ideal {f0} \<inter> P[X]) [ideal {f0} \<inter> P[X], {0}]"
	+ using perm.swap by (rule direct_decomp_perm)
	+ qed (simp add: hom_decomp_def)
	+next
	+ case (insert f F)
	+ from insert.prems(2) have "F \<subseteq> P[X]" by simp
	+ moreover have "poly_deg f' \<le> poly_deg f0" if "f' \<in> F" for f'
	+ proof -
	+ from that have "f' \<in> insert f F" by simp
	+ thus ?thesis by (rule insert.prems)
	+ qed
	+ ultimately obtain T ps where valid_ps: "valid_decomp X ps" and std_ps: "standard_decomp (poly_deg f0) ps"
	+ and cn_ps: "cone_decomp T ps" and dd: "direct_decomp (ideal (insert f0 F) \<inter> P[X]) [ideal {f0} \<inter> P[X], T]"
	+ and hom_ps: "(\<And>f. f \<in> F \<Longrightarrow> homogeneous f) \<Longrightarrow> hom_decomp ps"
	+ using insert.hyps(3) by metis
	+ show ?case
	+ proof (cases "f = 0")
	+ case True
	+ show ?thesis
	+ proof (rule insert.prems)
	+ from dd show "direct_decomp (ideal (insert f0 (insert f F)) \<inter> P[X]) [ideal {f0} \<inter> P[X], T]"
	+ by (simp only: insert_commute[of f0] True ideal.span_insert_zero)
	+ next
	+ assume "\<And>f'. f' \<in> insert f F \<Longrightarrow> homogeneous f'"
	+ hence "\<And>f. f \<in> F \<Longrightarrow> homogeneous f" by blast
	+ thus "hom_decomp ps" by (rule hom_ps)
	+ qed fact+
	+ next
	+ case False
	+ let ?D = "ideal_decomp_aux (insert f0 F) f"
	+ from insert.hyps(1) have f0F_fin: "finite (insert f0 F)" by simp
	+ moreover from \<open>F \<subseteq> P[X]\<close> assms(3) have f0F_sub: "insert f0 F \<subseteq> P[X]" by simp
	+ moreover from insert.prems(2) have "f \<in> P[X]" by simp
	+ ultimately have eq: "ideal (insert f0 F) \<inter> fst ?D = {0}" and "valid_decomp X (snd ?D)"
	+ and cn_D: "cone_decomp (fst ?D) (snd ?D)"
	+ and "standard_decomp (poly_deg f) (snd ?D)"
	+ and dd': "direct_decomp (ideal (insert f (insert f0 F)) \<inter> P[X])
	+ [fst ?D, ideal (insert f0 F) \<inter> P[X]]"
	+ and hom_D: "homogeneous f \<Longrightarrow> hom_decomp (snd ?D)"
	+ by (rule ideal_decomp_aux, auto intro: ideal_decomp_aux simp: False)
	+ note fin_X this(2-4)
	+ moreover have "poly_deg f \<le> poly_deg f0" by (rule insert.prems) simp
	+ ultimately obtain qs where valid_qs: "valid_decomp X qs" and cn_qs: "cone_decomp (fst ?D) qs"
	+ and std_qs: "standard_decomp (poly_deg f0) qs"
	+ and hom_qs: "hom_decomp (snd ?D) \<Longrightarrow> hom_decomp qs" by (rule standard_decomp_geE) blast
	+ let ?T = "sum_list ` listset [T, fst ?D]"
	+ let ?ps = "ps @ qs"
	+ show ?thesis
	+ proof (rule insert.prems)
	+ from valid_ps valid_qs show "valid_decomp X ?ps" by (rule valid_decomp_append)
	+ next
	+ from std_ps std_qs show "standard_decomp (poly_deg f0) ?ps" by (rule standard_decomp_append)
	+ next
	+ from dd perm.swap have "direct_decomp (ideal (insert f0 F) \<inter> P[X]) [T, ideal {f0} \<inter> P[X]]"
	+ by (rule direct_decomp_perm)
	+ hence "T \<subseteq> ideal (insert f0 F) \<inter> P[X]"
	+ by (rule direct_decomp_Cons_subsetI) (simp add: ideal.span_zero zero_in_Polys)
	+ hence "T \<inter> fst ?D \<subseteq> ideal (insert f0 F) \<inter> fst ?D" by blast
	+ hence "T \<inter> fst ?D \<subseteq> {0}" by (simp only: eq)
	+ from refl have "direct_decomp ?T [T, fst ?D]"
	+ proof (intro direct_decompI inj_onI)
	+ fix xs ys
	+ assume "xs \<in> listset [T, fst ?D]"
	+ then obtain x1 x2 where "x1 \<in> T" and "x2 \<in> fst ?D" and xs: "xs = [x1, x2]"
	+ by (rule listset_doubletonE)
	+ assume "ys \<in> listset [T, fst ?D]"
	+ then obtain y1 y2 where "y1 \<in> T" and "y2 \<in> fst ?D" and ys: "ys = [y1, y2]"
	+ by (rule listset_doubletonE)
	+ assume "sum_list xs = sum_list ys"
	+ hence "x1 - y1 = y2 - x2" by (simp add: xs ys) (metis add_diff_cancel_left add_diff_cancel_right)
	+ moreover from cn_ps \<open>x1 \<in> T\<close> \<open>y1 \<in> T\<close> have "x1 - y1 \<in> T" by (rule cone_decomp_closed_minus)
	+ moreover from cn_D \<open>y2 \<in> fst ?D\<close> \<open>x2 \<in> fst ?D\<close> have "y2 - x2 \<in> fst ?D"
	+ by (rule cone_decomp_closed_minus)
	+ ultimately have "y2 - x2 \<in> T \<inter> fst ?D" by simp
	+ also have "\<dots> \<subseteq> {0}" by fact
	+ finally have "x2 = y2" by simp
	+ with \<open>x1 - y1 = y2 - x2\<close> show "xs = ys" by (simp add: xs ys)
	+ qed
	+ thus "cone_decomp ?T ?ps" using cn_ps cn_qs by (rule cone_decomp_append)
	+ next
	+ assume "\<And>f'. f' \<in> insert f F \<Longrightarrow> homogeneous f'"
	+ hence "homogeneous f" and "\<And>f'. f' \<in> F \<Longrightarrow> homogeneous f'" by blast+
	+ from this(2) have "hom_decomp ps" by (rule hom_ps)
	+ moreover from \<open>homogeneous f\<close> have "hom_decomp qs" by (intro hom_qs hom_D)
	+ ultimately show "hom_decomp (ps @ qs)" by (simp only: hom_decomp_append_iff)
	+ next
	+ from dd' have "direct_decomp (ideal (insert f0 (insert f F)) \<inter> P[X])
	+ [ideal (insert f0 F) \<inter> P[X], fst ?D]"
	+ by (simp add: insert_commute direct_decomp_perm perm.swap)
	+ hence "direct_decomp (ideal (insert f0 (insert f F)) \<inter> P[X])
	+ ([fst ?D] @ [ideal {f0} \<inter> P[X], T])" using dd by (rule direct_decomp_direct_decomp)
	+ hence "direct_decomp (ideal (insert f0 (insert f F)) \<inter> P[X]) ([ideal {f0} \<inter> P[X]] @ [T, fst ?D])"
	+ by (rule direct_decomp_perm) auto
	+ hence "direct_decomp (ideal (insert f0 (insert f F)) \<inter> P[X]) [sum_list ` listset [ideal {f0} \<inter> P[X]], ?T]"
	+ by (rule direct_decomp_appendD)
	+ thus "direct_decomp (ideal (insert f0 (insert f F)) \<inter> P[X]) [ideal {f0} \<inter> P[X], ?T]"
	+ by (simp add: image_image)
	+ qed
	+ qed
	+qed
	+
	+subsection \<open>Exact Cone Decompositions\<close>
	+
	+definition exact_decomp :: "nat \<Rightarrow> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::zero) \<times> 'x set) list \<Rightarrow> bool"
	+ where "exact_decomp m ps \<longleftrightarrow> (\<forall>(h, U)\<in>set ps. h \<in> P[X] \<and> U \<subseteq> X) \<and>
	+ (\<forall>(h, U)\<in>set ps. \<forall>(h', U')\<in>set ps. poly_deg h = poly_deg h' \<longrightarrow>
	+ m < card U \<longrightarrow> m < card U' \<longrightarrow> (h, U) = (h', U'))"
	+
	+lemma exact_decompI:
	+ "(\<And>h U. (h, U) \<in> set ps \<Longrightarrow> h \<in> P[X]) \<Longrightarrow> (\<And>h U. (h, U) \<in> set ps \<Longrightarrow> U \<subseteq> X) \<Longrightarrow>
	+ (\<And>h h' U U'. (h, U) \<in> set ps \<Longrightarrow> (h', U') \<in> set ps \<Longrightarrow> poly_deg h = poly_deg h' \<Longrightarrow>
	+ m < card U \<Longrightarrow> m < card U' \<Longrightarrow> (h, U) = (h', U')) \<Longrightarrow>
	+ exact_decomp m ps"
	+ unfolding exact_decomp_def by fastforce
	+
	+lemma exact_decompD:
	+ assumes "exact_decomp m ps" and "(h, U) \<in> set ps"
	+ shows "h \<in> P[X]" and "U \<subseteq> X"
	+ and "(h', U') \<in> set ps \<Longrightarrow> poly_deg h = poly_deg h' \<Longrightarrow> m < card U \<Longrightarrow> m < card U' \<Longrightarrow>
	+ (h, U) = (h', U')"
	+ using assms unfolding exact_decomp_def by fastforce+
	+
	+lemma exact_decompI_zero:
	+ assumes "\<And>h U. (h, U) \<in> set ps \<Longrightarrow> h \<in> P[X]" and "\<And>h U. (h, U) \<in> set ps \<Longrightarrow> U \<subseteq> X"
	+ and "\<And>h h' U U'. (h, U) \<in> set (ps\<^sub>+) \<Longrightarrow> (h', U') \<in> set (ps\<^sub>+) \<Longrightarrow> poly_deg h = poly_deg h' \<Longrightarrow>
	+ (h, U) = (h', U')"
	+ shows "exact_decomp 0 ps"
	+ using assms(1, 2)
	+proof (rule exact_decompI)
	+ fix h h' and U U' :: "'x set"
	+ assume "0 < card U"
	+ hence "U \<noteq> {}" by auto
	+ moreover assume "(h, U) \<in> set ps"
	+ ultimately have "(h, U) \<in> set (ps\<^sub>+)" by (simp add: pos_decomp_def)
	+ assume "0 < card U'"
	+ hence "U' \<noteq> {}" by auto
	+ moreover assume "(h', U') \<in> set ps"
	+ ultimately have "(h', U') \<in> set (ps\<^sub>+)" by (simp add: pos_decomp_def)
	+ assume "poly_deg h = poly_deg h'"
	+ with \<open>(h, U) \<in> set (ps\<^sub>+)\<close> \<open>(h', U') \<in> set (ps\<^sub>+)\<close> show "(h, U) = (h', U')" by (rule assms(3))
	+qed
	+
	+lemma exact_decompD_zero:
	+ assumes "exact_decomp 0 ps" and "(h, U) \<in> set (ps\<^sub>+)" and "(h', U') \<in> set (ps\<^sub>+)"
	+ and "poly_deg h = poly_deg h'"
	+ shows "(h, U) = (h', U')"
	+proof -
	+ from assms(2) have "(h, U) \<in> set ps" and "U \<noteq> {}" by (simp_all add: pos_decomp_def)
	+ from assms(1) this(1) have "U \<subseteq> X" by (rule exact_decompD)
	+ hence "finite U" using fin_X by (rule finite_subset)
	+ with \<open>U \<noteq> {}\<close> have "0 < card U" by (simp add: card_gt_0_iff)
	+ from assms(3) have "(h', U') \<in> set ps" and "U' \<noteq> {}" by (simp_all add: pos_decomp_def)
	+ from assms(1) this(1) have "U' \<subseteq> X" by (rule exact_decompD)
	+ hence "finite U'" using fin_X by (rule finite_subset)
	+ with \<open>U' \<noteq> {}\<close> have "0 < card U'" by (simp add: card_gt_0_iff)
	+ show ?thesis by (rule exact_decompD) fact+
	+qed
	+
	+lemma exact_decomp_imp_valid_decomp:
	+ assumes "exact_decomp m ps" and "\<And>h U. (h, U) \<in> set ps \<Longrightarrow> h \<noteq> 0"
	+ shows "valid_decomp X ps"
	+proof (rule valid_decompI)
	+ fix h U
	+ assume *: "(h, U) \<in> set ps"
	+ with assms(1) show "h \<in> P[X]" and "U \<subseteq> X" by (rule exact_decompD)+
	+ from * show "h \<noteq> 0" by (rule assms(2))
	+qed
	+
	+lemma exact_decomp_card_X:
	+ assumes "valid_decomp X ps" and "card X \<le> m"
	+ shows "exact_decomp m ps"
	+proof (rule exact_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set ps"
	+ with assms(1) show "h \<in> P[X]" and "U \<subseteq> X" by (rule valid_decompD)+
	+next
	+ fix h1 h2 U1 U2
	+ assume "(h1, U1) \<in> set ps"
	+ with assms(1) have "U1 \<subseteq> X" by (rule valid_decompD)
	+ with fin_X have "card U1 \<le> card X" by (rule card_mono)
	+ also have "\<dots> \<le> m" by (fact assms(2))
	+ also assume "m < card U1"
	+ finally show "(h1, U1) = (h2, U2)" by simp
	+qed
	+
	+definition \<a> :: "((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::zero) \<times> 'x set) list \<Rightarrow> nat"
	+ where "\<a> ps = (LEAST k. standard_decomp k ps)"
	+
	+definition \<b> :: "((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::zero) \<times> 'x set) list \<Rightarrow> nat \<Rightarrow> nat"
	+ where "\<b> ps i = (LEAST d. \<a> ps \<le> d \<and> (\<forall>(h, U)\<in>set ps. i \<le> card U \<longrightarrow> poly_deg h < d))"
	+
	+lemma \<a>: "standard_decomp k ps \<Longrightarrow> standard_decomp (\<a> ps) ps"
	+ unfolding \<a>_def by (rule LeastI)
	+
	+lemma \<a>_Nil:
	+ assumes "ps\<^sub>+ = []"
	+ shows "\<a> ps = 0"
	+proof -
	+ from assms have "standard_decomp 0 ps" by (rule standard_decomp_Nil)
	+ thus ?thesis unfolding \<a>_def by (rule Least_eq_0)
	+qed
	+
	+lemma \<a>_nonempty:
	+ assumes "valid_decomp X ps" and "standard_decomp k ps" and "ps\<^sub>+ \<noteq> []"
	+ shows "\<a> ps = Min (poly_deg ` fst ` set (ps\<^sub>+))"
	+ using fin_X assms(1) _ assms(3)
	+proof (rule standard_decomp_nonempty_unique)
	+ from assms(2) show "standard_decomp (\<a> ps) ps" by (rule \<a>)
	+qed
	+
	+lemma \<a>_nonempty_unique:
	+ assumes "valid_decomp X ps" and "standard_decomp k ps" and "ps\<^sub>+ \<noteq> []"
	+ shows "\<a> ps = k"
	+proof -
	+ from assms have "\<a> ps = Min (poly_deg ` fst ` set (ps\<^sub>+))" by (rule \<a>_nonempty)
	+ moreover from fin_X assms have "k = Min (poly_deg ` fst ` set (ps\<^sub>+))"
	+ by (rule standard_decomp_nonempty_unique)
	+ ultimately show ?thesis by simp
	+qed
	+
	+lemma \<b>:
	+ shows "\<a> ps \<le> \<b> ps i" and "(h, U) \<in> set ps \<Longrightarrow> i \<le> card U \<Longrightarrow> poly_deg h < \<b> ps i"
	+proof -
	+ let ?A = "poly_deg ` fst ` set ps"
	+ define A where "A = insert (\<a> ps) ?A"
	+ define m where "m = Suc (Max A)"
	+ from finite_set have "finite ?A" by (intro finite_imageI)
	+ hence "finite A" by (simp add: A_def)
	+ have "\<a> ps \<le> \<b> ps i \<and> (\<forall>(h', U')\<in>set ps. i \<le> card U' \<longrightarrow> poly_deg h' < \<b> ps i)" unfolding \<b>_def
	+ proof (rule LeastI)
	+ have "\<a> ps \<in> A" by (simp add: A_def)
	+ with \<open>finite A\<close> have "\<a> ps \<le> Max A" by (rule Max_ge)
	+ hence "\<a> ps \<le> m" by (simp add: m_def)
	+ moreover {
	+ fix h U
	+ assume "(h, U) \<in> set ps"
	+ hence "poly_deg (fst (h, U)) \<in> ?A" by (intro imageI)
	+ hence "poly_deg h \<in> A" by (simp add: A_def)
	+ with \<open>finite A\<close> have "poly_deg h \<le> Max A" by (rule Max_ge)
	+ hence "poly_deg h < m" by (simp add: m_def)
	+ }
	+ ultimately show "\<a> ps \<le> m \<and> (\<forall>(h, U)\<in>set ps. i \<le> card U \<longrightarrow> poly_deg h < m)" by blast
	+ qed
	+ thus "\<a> ps \<le> \<b> ps i" and "(h, U) \<in> set ps \<Longrightarrow> i \<le> card U \<Longrightarrow> poly_deg h < \<b> ps i" by blast+
	+qed
	+
	+lemma \<b>_le:
	+ "\<a> ps \<le> d \<Longrightarrow> (\<And>h' U'. (h', U') \<in> set ps \<Longrightarrow> i \<le> card U' \<Longrightarrow> poly_deg h' < d) \<Longrightarrow> \<b> ps i \<le> d"
	+ unfolding \<b>_def by (intro Least_le) blast
	+
	+lemma \<b>_decreasing:
	+ assumes "i \<le> j"
	+ shows "\<b> ps j \<le> \<b> ps i"
	+proof (rule \<b>_le)
	+ fix h U
	+ assume "(h, U) \<in> set ps"
	+ assume "j \<le> card U"
	+ with assms(1) have "i \<le> card U" by (rule le_trans)
	+ with \<open>(h, U) \<in> set ps\<close> show "poly_deg h < \<b> ps i" by (rule \<b>)
	+qed (fact \<b>)
	+
	+lemma \<b>_Nil:
	+ assumes "ps\<^sub>+ = []" and "Suc 0 \<le> i"
	+ shows "\<b> ps i = 0"
	+ unfolding \<b>_def
	+proof (rule Least_eq_0)
	+ from assms(1) have "\<a> ps = 0" by (rule \<a>_Nil)
	+ moreover {
	+ fix h and U::"'x set"
	+ note assms(2)
	+ also assume "i \<le> card U"
	+ finally have "U \<noteq> {}" by auto
	+ moreover assume "(h, U) \<in> set ps"
	+ ultimately have "(h, U) \<in> set (ps\<^sub>+)" by (simp add: pos_decomp_def)
	+ hence False by (simp add: assms)
	+ }
	+ ultimately show "\<a> ps \<le> 0 \<and> (\<forall>(h, U)\<in>set ps. i \<le> card U \<longrightarrow> poly_deg h < 0)" by blast
	+qed
	+
	+lemma \<b>_zero:
	+ assumes "ps \<noteq> []"
	+ shows "Suc (Max (poly_deg ` fst ` set ps)) \<le> \<b> ps 0"
	+proof -
	+ from finite_set have "finite (poly_deg ` fst ` set ps)" by (intro finite_imageI)
	+ moreover from assms have "poly_deg ` fst ` set ps \<noteq> {}" by simp
	+ moreover have "\<forall>a\<in>poly_deg ` fst ` set ps. a < \<b> ps 0"
	+ proof
	+ fix d
	+ assume "d \<in> poly_deg ` fst ` set ps"
	+ then obtain p where "p \<in> set ps" and "d = poly_deg (fst p)" by blast
	+ moreover obtain h U where "p = (h, U)" using prod.exhaust by blast
	+ ultimately have "(h, U) \<in> set ps" and d: "d = poly_deg h" by simp_all
	+ from this(1) le0 show "d < \<b> ps 0" unfolding d by (rule \<b>)
	+ qed
	+ ultimately have "Max (poly_deg ` fst ` set ps) < \<b> ps 0" by simp
	+ thus ?thesis by simp
	+qed
	+
	+corollary \<b>_zero_gr:
	+ assumes "(h, U) \<in> set ps"
	+ shows "poly_deg h < \<b> ps 0"
	+proof -
	+ have "poly_deg h \<le> Max (poly_deg ` fst ` set ps)"
	+ proof (rule Max_ge)
	+ from finite_set show "finite (poly_deg ` fst ` set ps)" by (intro finite_imageI)
	+ next
	+ from assms have "poly_deg (fst (h, U)) \<in> poly_deg ` fst ` set ps" by (intro imageI)
	+ thus "poly_deg h \<in> poly_deg ` fst ` set ps" by simp
	+ qed
	+ also have "\<dots> < Suc \<dots>" by simp
	+ also have "\<dots> \<le> \<b> ps 0"
	+ proof (rule \<b>_zero)
	+ from assms show "ps \<noteq> []" by auto
	+ qed
	+ finally show ?thesis .
	+qed
	+
	+lemma \<b>_one:
	+ assumes "valid_decomp X ps" and "standard_decomp k ps"
	+ shows "\<b> ps (Suc 0) = (if ps\<^sub>+ = [] then 0 else Suc (Max (poly_deg ` fst ` set (ps\<^sub>+))))"
	+proof (cases "ps\<^sub>+ = []")
	+ case True
	+ hence "\<b> ps (Suc 0) = 0" using le_refl by (rule \<b>_Nil)
	+ with True show ?thesis by simp
	+next
	+ case False
	+ with assms have aP: "\<a> ps = Min (poly_deg ` fst ` set (ps\<^sub>+))" (is "_ = Min ?A") by (rule \<a>_nonempty)
	+ from pos_decomp_subset finite_set have "finite (set (ps\<^sub>+))" by (rule finite_subset)
	+ hence "finite ?A" by (intro finite_imageI)
	+ from False have "?A \<noteq> {}" by simp
	+ have "\<b> ps (Suc 0) = Suc (Max ?A)" unfolding \<b>_def
	+ proof (rule Least_equality)
	+ from \<open>finite ?A\<close> \<open>?A \<noteq> {}\<close> have "\<a> ps \<in> ?A" unfolding aP by (rule Min_in)
	+ with \<open>finite ?A\<close> have "\<a> ps \<le> Max ?A" by (rule Max_ge)
	+ hence "\<a> ps \<le> Suc (Max ?A)" by simp
	+ moreover {
	+ fix h U
	+ assume "(h, U) \<in> set ps"
	+ with fin_X assms(1) have "finite U" by (rule valid_decompD_finite)
	+ moreover assume "Suc 0 \<le> card U"
	+ ultimately have "U \<noteq> {}" by auto
	+ with \<open>(h, U) \<in> set ps\<close> have "(h, U) \<in> set (ps\<^sub>+)" by (simp add: pos_decomp_def)
	+ hence "poly_deg (fst (h, U)) \<in> ?A" by (intro imageI)
	+ hence "poly_deg h \<in> ?A" by (simp only: fst_conv)
	+ with \<open>finite ?A\<close> have "poly_deg h \<le> Max ?A" by (rule Max_ge)
	+ hence "poly_deg h < Suc (Max ?A)" by simp
	+ }
	+ ultimately show "\<a> ps \<le> Suc (Max ?A) \<and> (\<forall>(h, U)\<in>set ps. Suc 0 \<le> card U \<longrightarrow> poly_deg h < Suc (Max ?A))"
	+ by blast
	+ next
	+ fix d
	+ assume "\<a> ps \<le> d \<and> (\<forall>(h, U)\<in>set ps. Suc 0 \<le> card U \<longrightarrow> poly_deg h < d)"
	+ hence rl: "poly_deg h < d" if "(h, U) \<in> set ps" and "0 < card U" for h U using that by auto
	+ have "Max ?A < d" unfolding Max_less_iff[OF \<open>finite ?A\<close> \<open>?A \<noteq> {}\<close>]
	+ proof
	+ fix d0
	+ assume "d0 \<in> poly_deg ` fst ` set (ps\<^sub>+)"
	+ then obtain h U where "(h, U) \<in> set (ps\<^sub>+)" and d0: "d0 = poly_deg h" by auto
	+ from this(1) have "(h, U) \<in> set ps" and "U \<noteq> {}" by (simp_all add: pos_decomp_def)
	+ from fin_X assms(1) this(1) have "finite U" by (rule valid_decompD_finite)
	+ with \<open>U \<noteq> {}\<close> have "0 < card U" by (simp add: card_gt_0_iff)
	+ with \<open>(h, U) \<in> set ps\<close> show "d0 < d" unfolding d0 by (rule rl)
	+ qed
	+ thus "Suc (Max ?A) \<le> d" by simp
	+ qed
	+ with False show ?thesis by simp
	+qed
	+
	+corollary \<b>_one_gr:
	+ assumes "valid_decomp X ps" and "standard_decomp k ps" and "(h, U) \<in> set (ps\<^sub>+)"
	+ shows "poly_deg h < \<b> ps (Suc 0)"
	+proof -
	+ from assms(3) have "ps\<^sub>+ \<noteq> []" by auto
	+ with assms(1, 2) have eq: "\<b> ps (Suc 0) = Suc (Max (poly_deg ` fst ` set (ps\<^sub>+)))"
	+ by (simp add: \<b>_one)
	+ have "poly_deg h \<le> Max (poly_deg ` fst ` set (ps\<^sub>+))"
	+ proof (rule Max_ge)
	+ from finite_set show "finite (poly_deg ` fst ` set (ps\<^sub>+))" by (intro finite_imageI)
	+ next
	+ from assms(3) have "poly_deg (fst (h, U)) \<in> poly_deg ` fst ` set (ps\<^sub>+)" by (intro imageI)
	+ thus "poly_deg h \<in> poly_deg ` fst ` set (ps\<^sub>+)" by simp
	+ qed
	+ also have "\<dots> < \<b> ps (Suc 0)" by (simp add: eq)
	+ finally show ?thesis .
	+qed
	+
	+lemma \<b>_card_X:
	+ assumes "exact_decomp m ps" and "Suc (card X) \<le> i"
	+ shows "\<b> ps i = \<a> ps"
	+ unfolding \<b>_def
	+proof (rule Least_equality)
	+ {
	+ fix h U
	+ assume "(h, U) \<in> set ps"
	+ with assms(1) have "U \<subseteq> X" by (rule exact_decompD)
	+ note assms(2)
	+ also assume "i \<le> card U"
	+ finally have "card X < card U" by simp
	+ with fin_X have "\<not> U \<subseteq> X" by (auto dest: card_mono leD)
	+ hence False using \<open>U \<subseteq> X\<close> ..
	+ }
	+ thus "\<a> ps \<le> \<a> ps \<and> (\<forall>(h, U)\<in>set ps. i \<le> card U \<longrightarrow> poly_deg h < \<a> ps)" by blast
	+qed simp
	+
	+lemma lem_6_1_1:
	+ assumes "standard_decomp k ps" and "exact_decomp m ps" and "Suc 0 \<le> i"
	+ and "i \<le> card X" and "\<b> ps (Suc i) \<le> d" and "d < \<b> ps i"
	+ obtains h U where "(h, U) \<in> set (ps\<^sub>+)" and "poly_deg h = d" and "card U = i"
	+proof -
	+ have "ps\<^sub>+ \<noteq> []"
	+ proof
	+ assume "ps\<^sub>+ = []"
	+ hence "\<b> ps i = 0" using assms(3) by (rule \<b>_Nil)
	+ with assms(6) show False by simp
	+ qed
	+ have eq1: "\<b> ps (Suc (card X)) = \<a> ps" using assms(2) le_refl by (rule \<b>_card_X)
	+ from assms(1) have std: "standard_decomp (\<b> ps (Suc (card X))) ps" unfolding eq1 by (rule \<a>)
	+ from assms(4) have "Suc i \<le> Suc (card X)" ..
	+ hence "\<b> ps (Suc (card X)) \<le> \<b> ps (Suc i)" by (rule \<b>_decreasing)
	+ hence "\<a> ps \<le> \<b> ps (Suc i)" by (simp only: eq1)
	+ have "\<exists>h U. (h, U) \<in> set ps \<and> i \<le> card U \<and> \<b> ps i \<le> Suc (poly_deg h)"
	+ proof (rule ccontr)
	+ assume *: "\<nexists>h U. (h, U) \<in> set ps \<and> i \<le> card U \<and> \<b> ps i \<le> Suc (poly_deg h)"
	+ note \<open>\<a> ps \<le> \<b> ps (Suc i)\<close>
	+ also from assms(5, 6) have "\<b> ps (Suc i) < \<b> ps i" by (rule le_less_trans)
	+ finally have "\<a> ps < \<b> ps i" .
	+ hence "\<a> ps \<le> \<b> ps i - 1" by simp
	+ hence "\<b> ps i \<le> \<b> ps i - 1"
	+ proof (rule \<b>_le)
	+ fix h U
	+ assume "(h, U) \<in> set ps" and "i \<le> card U"
	+ show "poly_deg h < \<b> ps i - 1"
	+ proof (rule ccontr)
	+ assume "\<not> poly_deg h < \<b> ps i - 1"
	+ hence "\<b> ps i \<le> Suc (poly_deg h)" by simp
	+ with * \<open>(h, U) \<in> set ps\<close> \<open>i \<le> card U\<close> show False by auto
	+ qed
	+ qed
	+ thus False using \<open>\<a> ps < \<b> ps i\<close> by linarith
	+ qed
	+ then obtain h U where "(h, U) \<in> set ps" and "i \<le> card U" and "\<b> ps i \<le> Suc (poly_deg h)" by blast
	+ from assms(3) this(2) have "U \<noteq> {}" by auto
	+ with \<open>(h, U) \<in> set ps\<close> have "(h, U) \<in> set (ps\<^sub>+)" by (simp add: pos_decomp_def)
	+ note std this
	+ moreover have "\<b> ps (Suc (card X)) \<le> d" unfolding eq1 using \<open>\<a> ps \<le> \<b> ps (Suc i)\<close> assms(5)
	+ by (rule le_trans)
	+ moreover have "d \<le> poly_deg h"
	+ proof -
	+ from assms(6) \<open>\<b> ps i \<le> Suc (poly_deg h)\<close> have "d < Suc (poly_deg h)" by (rule less_le_trans)
	+ thus ?thesis by simp
	+ qed
	+ ultimately obtain h' U' where "(h', U') \<in> set ps" and d: "poly_deg h' = d" and "card U \<le> card U'"
	+ by (rule standard_decompE)
	+ from \<open>i \<le> card U\<close> this(3) have "i \<le> card U'" by (rule le_trans)
	+ with assms(3) have "U' \<noteq> {}" by auto
	+ with \<open>(h', U') \<in> set ps\<close> have "(h', U') \<in> set (ps\<^sub>+)" by (simp add: pos_decomp_def)
	+ moreover note \<open>poly_deg h' = d\<close>
	+ moreover have "card U' = i"
	+ proof (rule ccontr)
	+ assume "card U' \<noteq> i"
	+ with \<open>i \<le> card U'\<close> have "Suc i \<le> card U'" by simp
	+ with \<open>(h', U') \<in> set ps\<close> have "poly_deg h' < \<b> ps (Suc i)" by (rule \<b>)
	+ with assms(5) show False by (simp add: d)
	+ qed
	+ ultimately show ?thesis ..
	+qed
	+
	+corollary lem_6_1_2:
	+ assumes "standard_decomp k ps" and "exact_decomp 0 ps" and "Suc 0 \<le> i"
	+ and "i \<le> card X" and "\<b> ps (Suc i) \<le> d" and "d < \<b> ps i"
	+ obtains h U where "{(h', U') \<in> set (ps\<^sub>+). poly_deg h' = d} = {(h, U)}" and "card U = i"
	+proof -
	+ from assms obtain h U where "(h, U) \<in> set (ps\<^sub>+)" and "poly_deg h = d" and "card U = i"
	+ by (rule lem_6_1_1)
	+ hence "{(h, U)} \<subseteq> {(h', U') \<in> set (ps\<^sub>+). poly_deg h' = d}" (is "_ \<subseteq> ?A") by simp
	+ moreover have "?A \<subseteq> {(h, U)}"
	+ proof
	+ fix x
	+ assume "x \<in> ?A"
	+ then obtain h' U' where "(h', U') \<in> set (ps\<^sub>+)" and "poly_deg h' = d" and x: "x = (h', U')"
	+ by blast
	+ note assms(2) \<open>(h, U) \<in> set (ps\<^sub>+)\<close> this(1)
	+ moreover have "poly_deg h = poly_deg h'" by (simp only: \<open>poly_deg h = d\<close> \<open>poly_deg h' = d\<close>)
	+ ultimately have "(h, U) = (h', U')" by (rule exact_decompD_zero)
	+ thus "x \<in> {(h, U)}" by (simp add: x)
	+ qed
	+ ultimately have "{(h, U)} = ?A" ..
	+ hence "?A = {(h, U)}" by (rule sym)
	+ thus ?thesis using \<open>card U = i\<close> ..
	+qed
	+
	+corollary lem_6_1_2':
	+ assumes "standard_decomp k ps" and "exact_decomp 0 ps" and "Suc 0 \<le> i"
	+ and "i \<le> card X" and "\<b> ps (Suc i) \<le> d" and "d < \<b> ps i"
	+ shows "card {(h', U') \<in> set (ps\<^sub>+). poly_deg h' = d} = 1" (is "card ?A = _")
	+ and "{(h', U') \<in> set (ps\<^sub>+). poly_deg h' = d \<and> card U' = i} = {(h', U') \<in> set (ps\<^sub>+). poly_deg h' = d}"
	+ (is "?B = _")
	+ and "card {(h', U') \<in> set (ps\<^sub>+). poly_deg h' = d \<and> card U' = i} = 1"
	+proof -
	+ from assms obtain h U where "?A = {(h, U)}" and "card U = i" by (rule lem_6_1_2)
	+ from this(1) show "card ?A = 1" by simp
	+ moreover show "?B = ?A"
	+ proof
	+ have "(h, U) \<in> ?A" by (simp add: \<open>?A = {(h, U)}\<close>)
	+ have "?A = {(h, U)}" by fact
	+ also from \<open>(h, U) \<in> ?A\<close> \<open>card U = i\<close> have "\<dots> \<subseteq> ?B" by simp
	+ finally show "?A \<subseteq> ?B" .
	+ qed blast
	+ ultimately show "card ?B = 1" by simp
	+qed
	+
	+corollary lem_6_1_3:
	+ assumes "standard_decomp k ps" and "exact_decomp 0 ps" and "Suc 0 \<le> i"
	+ and "i \<le> card X" and "(h, U) \<in> set (ps\<^sub>+)" and "card U = i"
	+ shows "\<b> ps (Suc i) \<le> poly_deg h"
	+proof (rule ccontr)
	+ define j where "j = (LEAST j'. \<b> ps j' \<le> poly_deg h)"
	+ assume "\<not> \<b> ps (Suc i) \<le> poly_deg h"
	+ hence "poly_deg h < \<b> ps (Suc i)" by simp
	+ from assms(2) le_refl have "\<b> ps (Suc (card X)) = \<a> ps" by (rule \<b>_card_X)
	+ also from _ assms(5) have "\<dots> \<le> poly_deg h"
	+ proof (rule standard_decompD)
	+ from assms(1) show "standard_decomp (\<a> ps) ps" by (rule \<a>)
	+ qed
	+ finally have "\<b> ps (Suc (card X)) \<le> poly_deg h" .
	+ hence 1: "\<b> ps j \<le> poly_deg h" unfolding j_def by (rule LeastI)
	+ have "Suc i < j"
	+ proof (rule ccontr)
	+ assume "\<not> Suc i < j"
	+ hence "j \<le> Suc i" by simp
	+ hence "\<b> ps (Suc i) \<le> \<b> ps j" by (rule \<b>_decreasing)
	+ also have "\<dots> \<le> poly_deg h" by fact
	+ finally show False using \<open>poly_deg h < \<b> ps (Suc i)\<close> by simp
	+ qed
	+ hence eq: "Suc (j - 1) = j" by simp
	+ note assms(1, 2)
	+ moreover from assms(3) have "Suc 0 \<le> j - 1"
	+ proof (rule le_trans)
	+ from \<open>Suc i < j\<close> show "i \<le> j - 1" by simp
	+ qed
	+ moreover have "j - 1 \<le> card X"
	+ proof -
	+ have "j \<le> Suc (card X)" unfolding j_def by (rule Least_le) fact
	+ thus ?thesis by simp
	+ qed
	+ moreover from 1 have "\<b> ps (Suc (j - 1)) \<le> poly_deg h" by (simp only: eq)
	+ moreover have "poly_deg h < \<b> ps (j - 1)"
	+ proof (rule ccontr)
	+ assume "\<not> poly_deg h < \<b> ps (j - 1)"
	+ hence "\<b> ps (j - 1) \<le> poly_deg h" by simp
	+ hence "j \<le> j - 1" unfolding j_def by (rule Least_le)
	+ also have "\<dots> < Suc (j - 1)" by simp
	+ finally show False by (simp only: eq)
	+ qed
	+ ultimately obtain h0 U0
	+ where eq1: "{(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = poly_deg h} = {(h0, U0)}"
	+ and "card U0 = j - 1" by (rule lem_6_1_2)
	+ from assms(5) have "(h, U) \<in> {(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = poly_deg h}" by simp
	+ hence "(h, U) \<in> {(h0, U0)}" by (simp only: eq1)
	+ hence "U = U0" by simp
	+ hence "card U = j - 1" by (simp only: \<open>card U0 = j - 1\<close>)
	+ hence "i = j - 1" by (simp only: assms(6))
	+ hence "Suc i = j" by (simp only: eq)
	+ with \<open>Suc i < j\<close> show False by simp
	+qed
	+
	+qualified fun shift_list :: "((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors}) \<times> 'x set) \<Rightarrow>
	+ 'x \<Rightarrow> _ list \<Rightarrow> _ list" where
	+ "shift_list (h, U) x ps =
	+ ((punit.monom_mult 1 (Poly_Mapping.single x 1) h, U) # (h, U - {x}) # removeAll (h, U) ps)"
	+
	+declare shift_list.simps[simp del]
	+
	+lemma monomial_decomp_shift_list:
	+ assumes "monomial_decomp ps" and "hU \<in> set ps"
	+ shows "monomial_decomp (shift_list hU x ps)"
	+proof -
	+ let ?x = "Poly_Mapping.single x (1::nat)"
	+ obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ with assms(2) have "(h, U) \<in> set ps" by simp
	+ with assms(1) have 1: "is_monomial h" and 2: "lcf h = 1" by (rule monomial_decompD)+
	+ from this(1) have "monomial (lcf h) (lpp h) = h" by (rule punit.monomial_eq_itself)
	+ moreover define t where "t = lpp h"
	+ ultimately have "h = monomial 1 t" by (simp only: 2)
	+ hence "is_monomial (punit.monom_mult 1 ?x h)" and "lcf (punit.monom_mult 1 ?x h) = 1"
	+ by (simp_all add: punit.monom_mult_monomial monomial_is_monomial)
	+ with assms(1) 1 2 show ?thesis by (simp add: shift_list.simps monomial_decomp_def hU)
	+qed
	+
	+lemma hom_decomp_shift_list:
	+ assumes "hom_decomp ps" and "hU \<in> set ps"
	+ shows "hom_decomp (shift_list hU x ps)"
	+proof -
	+ let ?x = "Poly_Mapping.single x (1::nat)"
	+ obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ with assms(2) have "(h, U) \<in> set ps" by simp
	+ with assms(1) have 1: "homogeneous h" by (rule hom_decompD)
	+ hence "homogeneous (punit.monom_mult 1 ?x h)" by (simp only: homogeneous_monom_mult)
	+ with assms(1) 1 show ?thesis by (simp add: shift_list.simps hom_decomp_def hU)
	+qed
	+
	+lemma valid_decomp_shift_list:
	+ assumes "valid_decomp X ps" and "(h, U) \<in> set ps" and "x \<in> U"
	+ shows "valid_decomp X (shift_list (h, U) x ps)"
	+proof -
	+ let ?x = "Poly_Mapping.single x (1::nat)"
	+ from assms(1, 2) have "h \<in> P[X]" and "h \<noteq> 0" and "U \<subseteq> X" by (rule valid_decompD)+
	+ moreover from this(1) have "punit.monom_mult 1 ?x h \<in> P[X]"
	+ proof (intro Polys_closed_monom_mult PPs_closed_single)
	+ from \<open>x \<in> U\<close> \<open>U \<subseteq> X\<close> show "x \<in> X" ..
	+ qed
	+ moreover from \<open>U \<subseteq> X\<close> have "U - {x} \<subseteq> X" by blast
	+ ultimately show ?thesis
	+ using assms(1) \<open>h \<noteq> 0\<close> by (simp add: valid_decomp_def punit.monom_mult_eq_zero_iff shift_list.simps)
	+qed
	+
	+lemma standard_decomp_shift_list:
	+ assumes "standard_decomp k ps" and "(h1, U1) \<in> set ps" and "(h2, U2) \<in> set ps"
	+ and "poly_deg h1 = poly_deg h2" and "card U2 \<le> card U1" and "(h1, U1) \<noteq> (h2, U2)" and "x \<in> U2"
	+ shows "standard_decomp k (shift_list (h2, U2) x ps)"
	+proof (rule standard_decompI)
	+ let ?p1 = "(punit.monom_mult 1 (Poly_Mapping.single x 1) h2, U2)"
	+ let ?p2 = "(h2, U2 - {x})"
	+ let ?qs = "removeAll (h2, U2) ps"
	+ fix h U
	+ assume "(h, U) \<in> set ((shift_list (h2, U2) x ps)\<^sub>+)"
	+ hence disj: "(h, U) = ?p1 \<or> ((h, U) = ?p2 \<and> U2 - {x} \<noteq> {}) \<or> (h, U) \<in> set (ps\<^sub>+)"
	+ by (auto simp: pos_decomp_def shift_list.simps split: if_split_asm)
	+ from assms(7) have "U2 \<noteq> {}" by blast
	+ with assms(3) have "(h2, U2) \<in> set (ps\<^sub>+)" by (simp add: pos_decomp_def)
	+ with assms(1) have k_le: "k \<le> poly_deg h2" by (rule standard_decompD)
	+
	+ let ?x = "Poly_Mapping.single x 1"
	+ from disj show "k \<le> poly_deg h"
	+ proof (elim disjE)
	+ assume "(h, U) = ?p1"
	+ hence h: "h = punit.monom_mult (1::'a) ?x h2" by simp
	+ note k_le
	+ also have "poly_deg h2 \<le> poly_deg h" by (cases "h2 = 0") (simp_all add: h poly_deg_monom_mult)
	+ finally show ?thesis .
	+ next
	+ assume "(h, U) = ?p2 \<and> U2 - {x} \<noteq> {}"
	+ with k_le show ?thesis by simp
	+ next
	+ assume "(h, U) \<in> set (ps\<^sub>+)"
	+ with assms(1) show ?thesis by (rule standard_decompD)
	+ qed
	+
	+ fix d
	+ assume "k \<le> d" and "d \<le> poly_deg h"
	+ from disj obtain h' U' where 1: "(h', U') \<in> set (?p1 # ps)" and "poly_deg h' = d"
	+ and "card U \<le> card U'"
	+ proof (elim disjE)
	+ assume "(h, U) = ?p1"
	+ hence h: "h = punit.monom_mult 1 ?x h2" and "U = U2" by simp_all
	+ from \<open>d \<le> poly_deg h\<close> have "d \<le> poly_deg h2 \<or> poly_deg h = d"
	+ by (cases "h2 = 0") (auto simp: h poly_deg_monom_mult deg_pm_single)
	+ thus ?thesis
	+ proof
	+ assume "d \<le> poly_deg h2"
	+ with assms(1) \<open>(h2, U2) \<in> set (ps\<^sub>+)\<close> \<open>k \<le> d\<close> obtain h' U'
	+ where "(h', U') \<in> set ps" and "poly_deg h' = d" and "card U2 \<le> card U'"
	+ by (rule standard_decompE)
	+ from this(1) have "(h', U') \<in> set (?p1 # ps)" by simp
	+ moreover note \<open>poly_deg h' = d\<close>
	+ moreover from \<open>card U2 \<le> card U'\<close> have "card U \<le> card U'" by (simp only: \<open>U = U2\<close>)
	+ ultimately show ?thesis ..
	+ next
	+ have "(h, U) \<in> set (?p1 # ps)" by (simp add: \<open>(h, U) = ?p1\<close>)
	+ moreover assume "poly_deg h = d"
	+ ultimately show ?thesis using le_refl ..
	+ qed
	+ next
	+ assume "(h, U) = ?p2 \<and> U2 - {x} \<noteq> {}"
	+ hence "h = h2" and U: "U = U2 - {x}" by simp_all
	+ from \<open>d \<le> poly_deg h\<close> this(1) have "d \<le> poly_deg h2" by simp
	+ with assms(1) \<open>(h2, U2) \<in> set (ps\<^sub>+)\<close> \<open>k \<le> d\<close> obtain h' U'
	+ where "(h', U') \<in> set ps" and "poly_deg h' = d" and "card U2 \<le> card U'"
	+ by (rule standard_decompE)
	+ from this(1) have "(h', U') \<in> set (?p1 # ps)" by simp
	+ moreover note \<open>poly_deg h' = d\<close>
	+ moreover from _ \<open>card U2 \<le> card U'\<close> have "card U \<le> card U'" unfolding U
	+ by (rule le_trans) (metis Diff_empty card_Diff1_le card_infinite finite_Diff_insert order_refl)
	+ ultimately show ?thesis ..
	+ next
	+ assume "(h, U) \<in> set (ps\<^sub>+)"
	+ from assms(1) this \<open>k \<le> d\<close> \<open>d \<le> poly_deg h\<close> obtain h' U'
	+ where "(h', U') \<in> set ps" and "poly_deg h' = d" and "card U \<le> card U'"
	+ by (rule standard_decompE)
	+ from this(1) have "(h', U') \<in> set (?p1 # ps)" by simp
	+ thus ?thesis using \<open>poly_deg h' = d\<close> \<open>card U \<le> card U'\<close> ..
	+ qed
	+ show "\<exists>h' U'. (h', U') \<in> set (shift_list (h2, U2) x ps) \<and> poly_deg h' = d \<and> card U \<le> card U'"
	+ proof (cases "(h', U') = (h2, U2)")
	+ case True
	+ hence "h' = h2" and "U' = U2" by simp_all
	+ from assms(2, 6) have "(h1, U1) \<in> set (shift_list (h2, U2) x ps)" by (simp add: shift_list.simps)
	+ moreover from \<open>poly_deg h' = d\<close> have "poly_deg h1 = d" by (simp only: \<open>h' = h2\<close> assms(4))
	+ moreover from \<open>card U \<le> card U'\<close> assms(5) have "card U \<le> card U1" by (simp add: \<open>U' = U2\<close>)
	+ ultimately show ?thesis by blast
	+ next
	+ case False
	+ with 1 have "(h', U') \<in> set (shift_list (h2, U2) x ps)" by (auto simp: shift_list.simps)
	+ thus ?thesis using \<open>poly_deg h' = d\<close> \<open>card U \<le> card U'\<close> by blast
	+ qed
	+qed
	+
	+lemma cone_decomp_shift_list:
	+ assumes "valid_decomp X ps" and "cone_decomp T ps" and "(h, U) \<in> set ps" and "x \<in> U"
	+ shows "cone_decomp T (shift_list (h, U) x ps)"
	+proof -
	+ let ?p1 = "(punit.monom_mult 1 (Poly_Mapping.single x 1) h, U)"
	+ let ?p2 = "(h, U - {x})"
	+ let ?qs = "removeAll (h, U) ps"
	+ from assms(3) obtain ps1 ps2 where ps: "ps = ps1 @ (h, U) # ps2" and *: "(h, U) \<notin> set ps1"
	+ by (meson split_list_first)
	+ have "count_list ps2 (h, U) = 0"
	+ proof (rule ccontr)
	+ from assms(1, 3) have "h \<noteq> 0" by (rule valid_decompD)
	+ assume "count_list ps2 (h, U) \<noteq> 0"
	+ hence "1 < count_list ps (h, U)" by (simp add: ps count_list_append)
	+ also have "\<dots> \<le> count_list (map cone ps) (cone (h, U))" by (fact count_list_map_ge)
	+ finally have "1 < count_list (map cone ps) (cone (h, U))" .
	+ with cone_decompD have "cone (h, U) = {0}"
	+ proof (rule direct_decomp_repeated_eq_zero)
	+ fix s
	+ assume "s \<in> set (map cone ps)"
	+ thus "0 \<in> s" by (auto intro: zero_in_cone)
	+ qed (fact assms(2))
	+ with tip_in_cone[of h U] have "h = 0" by simp
	+ with \<open>h \<noteq> 0\<close> show False ..
	+ qed
	+ hence **: "(h, U) \<notin> set ps2" by (simp add: count_list_eq_0_iff)
	+ have "perm ps ((h, U) # ps1 @ ps2)" (is "perm _ ?ps")
	+ by (rule perm_sym) (simp only: perm_append_Cons ps)
	+ with assms(2) have "cone_decomp T ?ps" by (rule cone_decomp_perm)
	+ hence "direct_decomp T (map cone ?ps)" by (rule cone_decompD)
	+ hence "direct_decomp T (cone (h, U) # map cone (ps1 @ ps2))" by simp
	+ hence "direct_decomp T ((map cone (ps1 @ ps2)) @ [cone ?p1, cone ?p2])"
	+ proof (rule direct_decomp_direct_decomp)
	+ let ?x = "Poly_Mapping.single x (Suc 0)"
	+ have "direct_decomp (cone (h, insert x (U - {x})))
	+ [cone (h, U - {x}), cone (monomial (1::'a) ?x * h, insert x (U - {x}))]"
	+ by (rule direct_decomp_cone_insert) simp
	+ with assms(4) show "direct_decomp (cone (h, U)) [cone ?p1, cone ?p2]"
	+ by (simp add: insert_absorb times_monomial_left direct_decomp_perm perm.swap)
	+ qed
	+ hence "direct_decomp T (map cone (ps1 @ ps2 @ [?p1, ?p2]))" by simp
	+ hence "cone_decomp T (ps1 @ ps2 @ [?p1, ?p2])" by (rule cone_decompI)
	+ moreover have "perm (ps1 @ ps2 @ [?p1, ?p2]) (?p1 # ?p2 # (ps1 @ ps2))"
	+ proof -
	+ have "ps1 @ ps2 @ [?p1, ?p2] = (ps1 @ ps2) @ [?p1, ?p2]" by simp
	+ also have "perm \<dots> ([?p1, ?p2] @ (ps1 @ ps2))" by (rule perm_append_swap)
	+ also have "\<dots> = ?p1 # ?p2 # (ps1 @ ps2)" by simp
	+ finally show ?thesis .
	+ qed
	+ ultimately have "cone_decomp T (?p1 # ?p2 # (ps1 @ ps2))" by (rule cone_decomp_perm)
	+ also from * ** have "ps1 @ ps2 = removeAll (h, U) ps" by (simp add: remove1_append ps)
	+ finally show ?thesis by (simp only: shift_list.simps)
	+qed
	+
	+subsection \<open>Functions \<open>shift\<close> and \<open>exact\<close>\<close>
	+
	+context
	+ fixes k m :: nat
	+begin
	+
	+context
	+ fixes d :: nat
	+begin
	+
	+definition shift2_inv :: "((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::zero) \<times> 'x set) list \<Rightarrow> bool" where
	+ "shift2_inv qs \<longleftrightarrow> valid_decomp X qs \<and> standard_decomp k qs \<and> exact_decomp (Suc m) qs \<and>
	+ (\<forall>d0<d. card {q \<in> set qs. poly_deg (fst q) = d0 \<and> m < card (snd q)} \<le> 1)"
	+
	+fun shift1_inv :: "(((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list \<times> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::zero) \<times> 'x set) set) \<Rightarrow> bool"
	+ where "shift1_inv (qs, B) \<longleftrightarrow> B = {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)} \<and> shift2_inv qs"
	+
	+lemma shift2_invI:
	+ "valid_decomp X qs \<Longrightarrow> standard_decomp k qs \<Longrightarrow> exact_decomp (Suc m) qs \<Longrightarrow>
	+ (\<And>d0. d0 < d \<Longrightarrow> card {q \<in> set qs. poly_deg (fst q) = d0 \<and> m < card (snd q)} \<le> 1) \<Longrightarrow>
	+ shift2_inv qs"
	+ by (simp add: shift2_inv_def)
	+
	+lemma shift2_invD:
	+ assumes "shift2_inv qs"
	+ shows "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp (Suc m) qs"
	+ and "d0 < d \<Longrightarrow> card {q \<in> set qs. poly_deg (fst q) = d0 \<and> m < card (snd q)} \<le> 1"
	+ using assms by (simp_all add: shift2_inv_def)
	+
	+lemma shift1_invI:
	+ "B = {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)} \<Longrightarrow> shift2_inv qs \<Longrightarrow> shift1_inv (qs, B)"
	+ by simp
	+
	+lemma shift1_invD:
	+ assumes "shift1_inv (qs, B)"
	+ shows "B = {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}" and "shift2_inv qs"
	+ using assms by simp_all
	+
	+declare shift1_inv.simps[simp del]
	+
	+lemma shift1_inv_finite_snd:
	+ assumes "shift1_inv (qs, B)"
	+ shows "finite B"
	+proof (rule finite_subset)
	+ from assms have "B = {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}" by (rule shift1_invD)
	+ also have "\<dots> \<subseteq> set qs" by blast
	+ finally show "B \<subseteq> set qs" .
	+qed (fact finite_set)
	+
	+lemma shift1_inv_some_snd:
	+ assumes "shift1_inv (qs, B)" and "1 < card B" and "(h, U) = (SOME b. b \<in> B \<and> card (snd b) = Suc m)"
	+ shows "(h, U) \<in> B" and "(h, U) \<in> set qs" and "poly_deg h = d" and "card U = Suc m"
	+proof -
	+ define A where "A = {q \<in> B. card (snd q) = Suc m}"
	+ define Y where "Y = {q \<in> set qs. poly_deg (fst q) = d \<and> Suc m < card (snd q)}"
	+ from assms(1) have B: "B = {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}"
	+ and inv2: "shift2_inv qs" by (rule shift1_invD)+
	+ have B': "B = A \<union> Y" by (auto simp: B A_def Y_def)
	+ have "finite A"
	+ proof (rule finite_subset)
	+ show "A \<subseteq> B" unfolding A_def by blast
	+ next
	+ from assms(1) show "finite B" by (rule shift1_inv_finite_snd)
	+ qed
	+ moreover have "finite Y"
	+ proof (rule finite_subset)
	+ show "Y \<subseteq> set qs" unfolding Y_def by blast
	+ qed (fact finite_set)
	+ moreover have "A \<inter> Y = {}" by (auto simp: A_def Y_def)
	+ ultimately have "card (A \<union> Y) = card A + card Y" by (rule card_Un_disjoint)
	+ with assms(2) have "1 < card A + card Y" by (simp only: B')
	+ thm card_le_Suc0_iff_eq[OF \<open>finite Y\<close>]
	+ moreover have "card Y \<le> 1" unfolding One_nat_def card_le_Suc0_iff_eq[OF \<open>finite Y\<close>]
	+ proof (intro ballI)
	+ fix q1 q2 :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set"
	+ obtain h1 U1 where q1: "q1 = (h1, U1)" using prod.exhaust by blast
	+ obtain h2 U2 where q2: "q2 = (h2, U2)" using prod.exhaust by blast
	+ assume "q1 \<in> Y"
	+ hence "(h1, U1) \<in> set qs" and "poly_deg h1 = d" and "Suc m < card U1" by (simp_all add: q1 Y_def)
	+ assume "q2 \<in> Y"
	+ hence "(h2, U2) \<in> set qs" and "poly_deg h2 = d" and "Suc m < card U2" by (simp_all add: q2 Y_def)
	+ from this(2) have "poly_deg h1 = poly_deg h2" by (simp only: \<open>poly_deg h1 = d\<close>)
	+ from inv2 have "exact_decomp (Suc m) qs" by (rule shift2_invD)
	+ thus "q1 = q2" unfolding q1 q2 by (rule exact_decompD) fact+
	+ qed
	+ ultimately have "0 < card A" by simp
	+ hence "A \<noteq> {}" by auto
	+ then obtain a where "a \<in> A" by blast
	+ have "(h, U) \<in> B \<and> card (snd (h, U)) = Suc m" unfolding assms(3)
	+ proof (rule someI)
	+ from \<open>a \<in> A\<close> show "a \<in> B \<and> card (snd a) = Suc m" by (simp add: A_def)
	+ qed
	+ thus "(h, U) \<in> B" and "card U = Suc m" by simp_all
	+ from this(1) show "(h, U) \<in> set qs" and "poly_deg h = d" by (simp_all add: B)
	+qed
	+
	+lemma shift1_inv_preserved:
	+ assumes "shift1_inv (qs, B)" and "1 < card B" and "(h, U) = (SOME b. b \<in> B \<and> card (snd b) = Suc m)"
	+ and "x = (SOME y. y \<in> U)"
	+ shows "shift1_inv (shift_list (h, U) x qs, B - {(h, U)})"
	+proof -
	+ let ?p1 = "(punit.monom_mult 1 (Poly_Mapping.single x 1) h, U)"
	+ let ?p2 = "(h, U - {x})"
	+ let ?qs = "removeAll (h, U) qs"
	+ let ?B = "B - {(h, U)}"
	+ from assms(1, 2, 3) have "(h, U) \<in> B" and "(h, U) \<in> set qs" and deg_h: "poly_deg h = d"
	+ and card_U: "card U = Suc m" by (rule shift1_inv_some_snd)+
	+ from card_U have "U \<noteq> {}" by auto
	+ then obtain y where "y \<in> U" by blast
	+ hence "x \<in> U" unfolding assms(4) by (rule someI)
	+ with card_U have card_Ux: "card (U - {x}) = m"
	+ by (metis card_Diff_singleton card_infinite diff_Suc_1 nat.simps(3))
	+ from assms(1) have B: "B = {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}"
	+ and inv2: "shift2_inv qs" by (rule shift1_invD)+
	+ from inv2 have valid_qs: "valid_decomp X qs" by (rule shift2_invD)
	+ hence "h \<noteq> 0" using \<open>(h, U) \<in> set qs\<close> by (rule valid_decompD)
	+ show ?thesis
	+ proof (intro shift1_invI shift2_invI)
	+ show "?B = {q \<in> set (shift_list (h, U) x qs). poly_deg (fst q) = d \<and> m < card (snd q)}" (is "_ = ?C")
	+ proof (rule Set.set_eqI)
	+ fix b
	+ show "b \<in> ?B \<longleftrightarrow> b \<in> ?C"
	+ proof
	+ assume "b \<in> ?C"
	+ hence "b \<in> insert ?p1 (insert ?p2 (set ?qs))" and b1: "poly_deg (fst b) = d"
	+ and b2: "m < card (snd b)" by (simp_all add: shift_list.simps)
	+ from this(1) show "b \<in> ?B"
	+ proof (elim insertE)
	+ assume "b = ?p1"
	+ with \<open>h \<noteq> 0\<close> have "poly_deg (fst b) = Suc d"
	+ by (simp add: poly_deg_monom_mult deg_pm_single deg_h)
	+ thus ?thesis by (simp add: b1)
	+ next
	+ assume "b = ?p2"
	+ hence "card (snd b) = m" by (simp add: card_Ux)
	+ with b2 show ?thesis by simp
	+ next
	+ assume "b \<in> set ?qs"
	+ with b1 b2 show ?thesis by (auto simp: B)
	+ qed
	+ qed (auto simp: B shift_list.simps)
	+ qed
	+ next
	+ from valid_qs \<open>(h, U) \<in> set qs\<close> \<open>x \<in> U\<close> show "valid_decomp X (shift_list (h, U) x qs)"
	+ by (rule valid_decomp_shift_list)
	+ next
	+ from inv2 have std: "standard_decomp k qs" by (rule shift2_invD)
	+ have "?B \<noteq> {}"
	+ proof
	+ assume "?B = {}"
	+ hence "B \<subseteq> {(h, U)}" by simp
	+ with _ have "card B \<le> card {(h, U)}" by (rule card_mono) simp
	+ with assms(2) show False by simp
	+ qed
	+ then obtain h' U' where "(h', U') \<in> B" and "(h', U') \<noteq> (h, U)" by auto
	+ from this(1) have "(h', U') \<in> set qs" and "poly_deg h' = d" and "Suc m \<le> card U'"
	+ by (simp_all add: B)
	+ note std this(1) \<open>(h, U) \<in> set qs\<close>
	+ moreover from \<open>poly_deg h' = d\<close> have "poly_deg h' = poly_deg h" by (simp only: deg_h)
	+ moreover from \<open>Suc m \<le> card U'\<close> have "card U \<le> card U'" by (simp only: card_U)
	+ ultimately show "standard_decomp k (shift_list (h, U) x qs)"
	+ by (rule standard_decomp_shift_list) fact+
	+ next
	+ from inv2 have exct: "exact_decomp (Suc m) qs" by (rule shift2_invD)
	+ show "exact_decomp (Suc m) (shift_list (h, U) x qs)"
	+ proof (rule exact_decompI)
	+ fix h' U'
	+ assume "(h', U') \<in> set (shift_list (h, U) x qs)"
	+ hence *: "(h', U') \<in> insert ?p1 (insert ?p2 (set ?qs))" by (simp add: shift_list.simps)
	+ thus "h' \<in> P[X]"
	+ proof (elim insertE)
	+ assume "(h', U') = ?p1"
	+ hence h': "h' = punit.monom_mult 1 (Poly_Mapping.single x 1) h" by simp
	+ from exct \<open>(h, U) \<in> set qs\<close> have "U \<subseteq> X" by (rule exact_decompD)
	+ with \<open>x \<in> U\<close> have "x \<in> X" ..
	+ hence "Poly_Mapping.single x 1 \<in> .[X]" by (rule PPs_closed_single)
	+ moreover from exct \<open>(h, U) \<in> set qs\<close> have "h \<in> P[X]" by (rule exact_decompD)
	+ ultimately show ?thesis unfolding h' by (rule Polys_closed_monom_mult)
	+ next
	+ assume "(h', U') = ?p2"
	+ hence "h' = h" by simp
	+ also from exct \<open>(h, U) \<in> set qs\<close> have "\<dots> \<in> P[X]" by (rule exact_decompD)
	+ finally show ?thesis .
	+ next
	+ assume "(h', U') \<in> set ?qs"
	+ hence "(h', U') \<in> set qs" by simp
	+ with exct show ?thesis by (rule exact_decompD)
	+ qed
	+
	+ from * show "U' \<subseteq> X"
	+ proof (elim insertE)
	+ assume "(h', U') = ?p1"
	+ hence "U' = U" by simp
	+ also from exct \<open>(h, U) \<in> set qs\<close> have "\<dots> \<subseteq> X" by (rule exact_decompD)
	+ finally show ?thesis .
	+ next
	+ assume "(h', U') = ?p2"
	+ hence "U' = U - {x}" by simp
	+ also have "\<dots> \<subseteq> U" by blast
	+ also from exct \<open>(h, U) \<in> set qs\<close> have "\<dots> \<subseteq> X" by (rule exact_decompD)
	+ finally show ?thesis .
	+ next
	+ assume "(h', U') \<in> set ?qs"
	+ hence "(h', U') \<in> set qs" by simp
	+ with exct show ?thesis by (rule exact_decompD)
	+ qed
	+ next
	+ fix h1 h2 U1 U2
	+ assume "(h1, U1) \<in> set (shift_list (h, U) x qs)" and "Suc m < card U1"
	+ hence "(h1, U1) \<in> set qs" using card_U card_Ux by (auto simp: shift_list.simps)
	+ assume "(h2, U2) \<in> set (shift_list (h, U) x qs)" and "Suc m < card U2"
	+ hence "(h2, U2) \<in> set qs" using card_U card_Ux by (auto simp: shift_list.simps)
	+ assume "poly_deg h1 = poly_deg h2"
	+ from exct show "(h1, U1) = (h2, U2)" by (rule exact_decompD) fact+
	+ qed
	+ next
	+ fix d0
	+ assume "d0 < d"
	+ have "finite {q \<in> set qs. poly_deg (fst q) = d0 \<and> m < card (snd q)}" (is "finite ?A")
	+ by auto
	+ moreover have "{q \<in> set (shift_list (h, U) x qs). poly_deg (fst q) = d0 \<and> m < card (snd q)} \<subseteq> ?A"
	+ (is "?C \<subseteq> _")
	+ proof
	+ fix q
	+ assume "q \<in> ?C"
	+ hence "q = ?p1 \<or> q = ?p2 \<or> q \<in> set ?qs" and 1: "poly_deg (fst q) = d0" and 2: "m < card (snd q)"
	+ by (simp_all add: shift_list.simps)
	+ from this(1) show "q \<in> ?A"
	+ proof (elim disjE)
	+ assume "q = ?p1"
	+ with \<open>h \<noteq> 0\<close> have "d \<le> poly_deg (fst q)" by (simp add: poly_deg_monom_mult deg_h)
	+ with \<open>d0 < d\<close> show ?thesis by (simp only: 1)
	+ next
	+ assume "q = ?p2"
	+ hence "d \<le> poly_deg (fst q)" by (simp add: deg_h)
	+ with \<open>d0 < d\<close> show ?thesis by (simp only: 1)
	+ next
	+ assume "q \<in> set ?qs"
	+ with 1 2 show ?thesis by simp
	+ qed
	+ qed
	+ ultimately have "card ?C \<le> card ?A" by (rule card_mono)
	+ also from inv2 \<open>d0 < d\<close> have "\<dots> \<le> 1" by (rule shift2_invD)
	+ finally show "card ?C \<le> 1" .
	+ qed
	+qed
	+
	+function (domintros) shift1 :: "(((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list \<times> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) set) \<Rightarrow>
	+ (((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list \<times>
	+ ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors}) \<times> 'x set) set)"
	+ where
	+ "shift1 (qs, B) =
	+ (if 1 < card B then
	+ let (h, U) = SOME b. b \<in> B \<and> card (snd b) = Suc m; x = SOME y. y \<in> U in
	+ shift1 (shift_list (h, U) x qs, B - {(h, U)})
	+ else (qs, B))"
	+ by auto
	+
	+lemma shift1_domI:
	+ assumes "shift1_inv args"
	+ shows "shift1_dom args"
	+proof -
	+ from wf_measure[of "card \<circ> snd"] show ?thesis using assms
	+ proof (induct)
	+ case (less args)
	+ obtain qs B where args: "args = (qs, B)" using prod.exhaust by blast
	+ have IH: "shift1_dom (qs0, B0)" if "card B0 < card B" and "shift1_inv (qs0, B0)"
	+ for qs0 and B0::"((_ \<Rightarrow>\<^sub>0 'a) \<times> _) set"
	+ using _ that(2)
	+ proof (rule less)
	+ from that(1) show "((qs0, B0), args) \<in> measure (card \<circ> snd)" by (simp add: args)
	+ qed
	+ from less(2) have inv: "shift1_inv (qs, B)" by (simp only: args)
	+ show ?case unfolding args
	+ proof (rule shift1.domintros)
	+ fix h U
	+ assume hU: "(h, U) = (SOME b. b \<in> B \<and> card (snd b) = Suc m)"
	+ define x where "x = (SOME y. y \<in> U)"
	+ assume "Suc 0 < card B"
	+ hence "1 < card B" by simp
	+ have "shift1_dom (shift_list (h, U) x qs, B - {(h, U)})"
	+ proof (rule IH)
	+ from inv have "finite B" by (rule shift1_inv_finite_snd)
	+ moreover from inv \<open>1 < card B\<close> hU have "(h, U) \<in> B" by (rule shift1_inv_some_snd)
	+ ultimately show "card (B - {(h, U)}) < card B" by (rule card_Diff1_less)
	+ next
	+ from inv \<open>1 < card B\<close> hU x_def show "shift1_inv (shift_list (h, U) x qs, (B - {(h, U)}))"
	+ by (rule shift1_inv_preserved)
	+ qed
	+ thus "shift1_dom (shift_list (SOME b. b \<in> B \<and> card (snd b) = Suc m) (SOME y. y \<in> U) qs,
	+ B - {SOME b. b \<in> B \<and> card (snd b) = Suc m})" by (simp add: hU x_def)
	+ qed
	+ qed
	+qed
	+
	+lemma shift1_induct [consumes 1, case_names base step]:
	+ assumes "shift1_inv args"
	+ assumes "\<And>qs B. shift1_inv (qs, B) \<Longrightarrow> card B \<le> 1 \<Longrightarrow> P (qs, B) (qs, B)"
	+ assumes "\<And>qs B h U x. shift1_inv (qs, B) \<Longrightarrow> 1 < card B \<Longrightarrow>
	+ (h, U) = (SOME b. b \<in> B \<and> card (snd b) = Suc m) \<Longrightarrow> x = (SOME y. y \<in> U) \<Longrightarrow>
	+ finite U \<Longrightarrow> x \<in> U \<Longrightarrow> card (U - {x}) = m \<Longrightarrow>
	+ P (shift_list (h, U) x qs, B - {(h, U)}) (shift1 (shift_list (h, U) x qs, B - {(h, U)})) \<Longrightarrow>
	+ P (qs, B) (shift1 (shift_list (h, U) x qs, B - {(h, U)}))"
	+ shows "P args (shift1 args)"
	+proof -
	+ from assms(1) have "shift1_dom args" by (rule shift1_domI)
	+ thus ?thesis using assms(1)
	+ proof (induct args rule: shift1.pinduct)
	+ case step: (1 qs B)
	+ obtain h U where hU: "(h, U) = (SOME b. b \<in> B \<and> card (snd b) = Suc m)" by (smt prod.exhaust)
	+ define x where "x = (SOME y. y \<in> U)"
	+ show ?case
	+ proof (simp add: shift1.psimps[OF step.hyps(1)] flip: hU x_def del: One_nat_def,
	+ intro conjI impI)
	+ let ?args = "(shift_list (h, U) x qs, B - {(h, U)})"
	+ assume "1 < card B"
	+ with step.prems have card_U: "card U = Suc m" using hU by (rule shift1_inv_some_snd)
	+ from card_U have "finite U" using card_infinite by fastforce
	+ from card_U have "U \<noteq> {}" by auto
	+ then obtain y where "y \<in> U" by blast
	+ hence "x \<in> U" unfolding x_def by (rule someI)
	+ with step.prems \<open>1 < card B\<close> hU x_def \<open>finite U\<close> show "P (qs, B) (shift1 ?args)"
	+ proof (rule assms(3))
	+ from \<open>finite U\<close> \<open>x \<in> U\<close> show "card (U - {x}) = m" by (simp add: card_U)
	+ next
	+ from \<open>1 < card B\<close> refl hU x_def show "P ?args (shift1 ?args)"
	+ proof (rule step.hyps)
	+ from step.prems \<open>1 < card B\<close> hU x_def show "shift1_inv ?args" by (rule shift1_inv_preserved)
	+ qed
	+ qed
	+ next
	+ assume "\<not> 1 < card B"
	+ hence "card B \<le> 1" by simp
	+ with step.prems show "P (qs, B) (qs, B)" by (rule assms(2))
	+ qed
	+ qed
	+qed
	+
	+lemma shift1_1:
	+ assumes "shift1_inv args" and "d0 \<le> d"
	+ shows "card {q \<in> set (fst (shift1 args)). poly_deg (fst q) = d0 \<and> m < card (snd q)} \<le> 1"
	+ using assms(1)
	+proof (induct args rule: shift1_induct)
	+ case (base qs B)
	+ from assms(2) have "d0 < d \<or> d0 = d" by auto
	+ thus ?case
	+ proof
	+ from base(1) have "shift2_inv qs" by (rule shift1_invD)
	+ moreover assume "d0 < d"
	+ ultimately show ?thesis unfolding fst_conv by (rule shift2_invD)
	+ next
	+ assume "d0 = d"
	+ from base(1) have "B = {q \<in> set (fst (qs, B)). poly_deg (fst q) = d0 \<and> m < card (snd q)}"
	+ unfolding fst_conv \<open>d0 = d\<close> by (rule shift1_invD)
	+ with base(2) show ?thesis by simp
	+ qed
	+qed
	+
	+lemma shift1_2:
	+ "shift1_inv args \<Longrightarrow>
	+ card {q \<in> set (fst (shift1 args)). m < card (snd q)} \<le> card {q \<in> set (fst args). m < card (snd q)}"
	+proof (induct args rule: shift1_induct)
	+ case (base qs B)
	+ show ?case ..
	+next
	+ case (step qs B h U x)
	+ let ?x = "Poly_Mapping.single x (1::nat)"
	+ let ?p1 = "(punit.monom_mult 1 ?x h, U)"
	+ let ?A = "{q \<in> set qs. m < card (snd q)}"
	+ from step(1-3) have card_U: "card U = Suc m" and "(h, U) \<in> set qs" by (rule shift1_inv_some_snd)+
	+ from step(1) have "shift2_inv qs" by (rule shift1_invD)
	+ hence "valid_decomp X qs" by (rule shift2_invD)
	+ hence "h \<noteq> 0" using \<open>(h, U) \<in> set qs\<close> by (rule valid_decompD)
	+ have fin1: "finite ?A" by auto
	+ hence fin2: "finite (insert ?p1 ?A)" by simp
	+ from \<open>(h, U) \<in> set qs\<close> have hU_in: "(h, U) \<in> insert ?p1 ?A" by (simp add: card_U)
	+ have "?p1 \<noteq> (h, U)"
	+ proof
	+ assume "?p1 = (h, U)"
	+ hence "lpp (punit.monom_mult 1 ?x h) = lpp h" by simp
	+ with \<open>h \<noteq> 0\<close> show False by (simp add: punit.lt_monom_mult monomial_0_iff)
	+ qed
	+ let ?qs = "shift_list (h, U) x qs"
	+ have "{q \<in> set (fst (?qs, B - {(h, U)})). m < card (snd q)} = (insert ?p1 ?A) - {(h, U)}"
	+ using step(7) card_U \<open>?p1 \<noteq> (h, U)\<close> by (fastforce simp: shift_list.simps)
	+ also from fin2 hU_in have "card \<dots> = card (insert ?p1 ?A) - 1" by (simp add: card_Diff_singleton_if)
	+ also from fin1 have "\<dots> \<le> Suc (card ?A) - 1" by (simp add: card_insert_if)
	+ also have "\<dots> = card {q \<in> set (fst (qs, B)). m < card (snd q)}" by simp
	+ finally have "card {q \<in> set (fst (?qs, B - {(h, U)})). m < card (snd q)} \<le>
	+ card {q \<in> set (fst (qs, B)). m < card (snd q)}" .
	+ with step(8) show ?case by (rule le_trans)
	+qed
	+
	+lemma shift1_3: "shift1_inv args \<Longrightarrow> cone_decomp T (fst args) \<Longrightarrow> cone_decomp T (fst (shift1 args))"
	+proof (induct args rule: shift1_induct)
	+ case (base qs B)
	+ from base(3) show ?case .
	+next
	+ case (step qs B h U x)
	+ from step.hyps(1) have "shift2_inv qs" by (rule shift1_invD)
	+ hence "valid_decomp X qs" by (rule shift2_invD)
	+ moreover from step.prems have "cone_decomp T qs" by (simp only: fst_conv)
	+ moreover from step.hyps(1-3) have "(h, U) \<in> set qs" by (rule shift1_inv_some_snd)
	+ ultimately have "cone_decomp T (fst (shift_list (h, U) x qs, B - {(h, U)}))"
	+ unfolding fst_conv using step.hyps(6) by (rule cone_decomp_shift_list)
	+ thus ?case by (rule step.hyps(8))
	+qed
	+
	+lemma shift1_4:
	+ "shift1_inv args \<Longrightarrow>
	+ Max (poly_deg ` fst ` set (fst args)) \<le> Max (poly_deg ` fst ` set (fst (shift1 args)))"
	+proof (induct args rule: shift1_induct)
	+ case (base qs B)
	+ show ?case ..
	+next
	+ case (step qs B h U x)
	+ let ?x = "Poly_Mapping.single x 1"
	+ let ?p1 = "(punit.monom_mult 1 ?x h, U)"
	+ let ?qs = "shift_list (h, U) x qs"
	+ from step(1) have "B = {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}"
	+ and inv2: "shift2_inv qs" by (rule shift1_invD)+
	+ from this(1) have "B \<subseteq> set qs" by auto
	+ with step(2) have "set qs \<noteq> {}" by auto
	+ from finite_set have fin: "finite (poly_deg ` fst ` set ?qs)" by (intro finite_imageI)
	+ have "Max (poly_deg ` fst ` set (fst (qs, B))) \<le> Max (poly_deg ` fst ` set (fst (?qs, B - {(h, U)})))"
	+ unfolding fst_conv
	+ proof (rule Max.boundedI)
	+ from finite_set show "finite (poly_deg ` fst ` set qs)" by (intro finite_imageI)
	+ next
	+ from \<open>set qs \<noteq> {}\<close> show "poly_deg ` fst ` set qs \<noteq> {}" by simp
	+ next
	+ fix a
	+ assume "a \<in> poly_deg ` fst ` set qs"
	+ then obtain q where "q \<in> set qs" and a: "a = poly_deg (fst q)" by blast
	+ show "a \<le> Max (poly_deg ` fst ` set ?qs)"
	+ proof (cases "q = (h, U)")
	+ case True
	+ hence "a \<le> poly_deg (fst ?p1)" by (cases "h = 0") (simp_all add: a poly_deg_monom_mult)
	+ also from fin have "\<dots> \<le> Max (poly_deg ` fst ` set ?qs)"
	+ proof (rule Max_ge)
	+ have "?p1 \<in> set ?qs" by (simp add: shift_list.simps)
	+ thus "poly_deg (fst ?p1) \<in> poly_deg ` fst ` set ?qs" by (intro imageI)
	+ qed
	+ finally show ?thesis .
	+ next
	+ case False
	+ with \<open>q \<in> set qs\<close> have "q \<in> set ?qs" by (simp add: shift_list.simps)
	+ hence "a \<in> poly_deg ` fst ` set ?qs" unfolding a by (intro imageI)
	+ with fin show ?thesis by (rule Max_ge)
	+ qed
	+ qed
	+ thus ?case using step(8) by (rule le_trans)
	+qed
	+
	+lemma shift1_5: "shift1_inv args \<Longrightarrow> fst (shift1 args) = [] \<longleftrightarrow> fst args = []"
	+proof (induct args rule: shift1_induct)
	+ case (base qs B)
	+ show ?case ..
	+next
	+ case (step qs B h U x)
	+ let ?p1 = "(punit.monom_mult 1 (Poly_Mapping.single x 1) h, U)"
	+ let ?qs = "shift_list (h, U) x qs"
	+ from step(1) have "B = {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}"
	+ and inv2: "shift2_inv qs" by (rule shift1_invD)+
	+ from this(1) have "B \<subseteq> set qs" by auto
	+ with step(2) have "qs \<noteq> []" by auto
	+ moreover have "fst (shift1 (?qs, B - {(h, U)})) \<noteq> []"
	+ by (simp add: step.hyps(8) del: One_nat_def) (simp add: shift_list.simps)
	+ ultimately show ?case by simp
	+qed
	+
	+lemma shift1_6: "shift1_inv args \<Longrightarrow> monomial_decomp (fst args) \<Longrightarrow> monomial_decomp (fst (shift1 args))"
	+proof (induct args rule: shift1_induct)
	+ case (base qs B)
	+ from base(3) show ?case .
	+next
	+ case (step qs B h U x)
	+ from step(1-3) have "(h, U) \<in> set qs" by (rule shift1_inv_some_snd)
	+ with step.prems have "monomial_decomp (fst (shift_list (h, U) x qs, B - {(h, U)}))"
	+ unfolding fst_conv by (rule monomial_decomp_shift_list)
	+ thus ?case by (rule step.hyps)
	+qed
	+
	+lemma shift1_7: "shift1_inv args \<Longrightarrow> hom_decomp (fst args) \<Longrightarrow> hom_decomp (fst (shift1 args))"
	+proof (induct args rule: shift1_induct)
	+ case (base qs B)
	+ from base(3) show ?case .
	+next
	+ case (step qs B h U x)
	+ from step(1-3) have "(h, U) \<in> set qs" by (rule shift1_inv_some_snd)
	+ with step.prems have "hom_decomp (fst (shift_list (h, U) x qs, B - {(h, U)}))"
	+ unfolding fst_conv by (rule hom_decomp_shift_list)
	+ thus ?case by (rule step.hyps)
	+qed
	+
	+end
	+
	+lemma shift2_inv_preserved:
	+ assumes "shift2_inv d qs"
	+ shows "shift2_inv (Suc d) (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})))"
	+proof -
	+ define args where "args = (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})"
	+ from refl assms have inv1: "shift1_inv d args" unfolding args_def
	+ by (rule shift1_invI)
	+ hence "shift1_inv d (shift1 args)" by (induct args rule: shift1_induct)
	+ hence "shift1_inv d (fst (shift1 args), snd (shift1 args))" by simp
	+ hence "shift2_inv d (fst (shift1 args))" by (rule shift1_invD)
	+ hence "valid_decomp X (fst (shift1 args))" and "standard_decomp k (fst (shift1 args))"
	+ and "exact_decomp (Suc m) (fst (shift1 args))" by (rule shift2_invD)+
	+ thus "shift2_inv (Suc d) (fst (shift1 args))"
	+ proof (rule shift2_invI)
	+ fix d0
	+ assume "d0 < Suc d"
	+ hence "d0 \<le> d" by simp
	+ with inv1 show "card {q \<in> set (fst (shift1 args)). poly_deg (fst q) = d0 \<and> m < card (snd q)} \<le> 1"
	+ by (rule shift1_1)
	+ qed
	+qed
	+
	+function shift2 :: "nat \<Rightarrow> nat \<Rightarrow> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list \<Rightarrow>
	+ ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors}) \<times> 'x set) list" where
	+ "shift2 c d qs =
	+ (if c \<le> d then qs
	+ else shift2 c (Suc d) (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}))))"
	+ by auto
	+termination proof
	+ show "wf (measure (\<lambda>(c, d, _). c - d))" by (fact wf_measure)
	+qed simp
	+
	+lemma shift2_1: "shift2_inv d qs \<Longrightarrow> shift2_inv c (shift2 c d qs)"
	+proof (induct c d qs rule: shift2.induct)
	+ case IH: (1 c d qs)
	+ show ?case
	+ proof (subst shift2.simps, simp del: shift2.simps, intro conjI impI)
	+ assume "c \<le> d"
	+ show "shift2_inv c qs"
	+ proof (rule shift2_invI)
	+ from IH(2) show "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp (Suc m) qs"
	+ by (rule shift2_invD)+
	+ next
	+ fix d0
	+ assume "d0 < c"
	+ hence "d0 < d" using \<open>c \<le> d\<close> by (rule less_le_trans)
	+ with IH(2) show "card {q \<in> set qs. poly_deg (fst q) = d0 \<and> m < card (snd q)} \<le> 1"
	+ by (rule shift2_invD)
	+ qed
	+ next
	+ assume "\<not> c \<le> d"
	+ thus "shift2_inv c (shift2 c (Suc d) (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}))))"
	+ proof (rule IH)
	+ from IH(2) show "shift2_inv (Suc d) (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})))"
	+ by (rule shift2_inv_preserved)
	+ qed
	+ qed
	+qed
	+
	+lemma shift2_2:
	+ "shift2_inv d qs \<Longrightarrow>
	+ card {q \<in> set (shift2 c d qs). m < card (snd q)} \<le> card {q \<in> set qs. m < card (snd q)}"
	+proof (induct c d qs rule: shift2.induct)
	+ case IH: (1 c d qs)
	+ let ?A = "{q \<in> set (shift2 c (Suc d) (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})))). m < card (snd q)}"
	+ show ?case
	+ proof (subst shift2.simps, simp del: shift2.simps, intro impI)
	+ assume "\<not> c \<le> d"
	+ hence "card ?A \<le> card {q \<in> set (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}))). m < card (snd q)}"
	+ proof (rule IH)
	+ show "shift2_inv (Suc d) (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})))"
	+ using IH(2) by (rule shift2_inv_preserved)
	+ qed
	+ also have "\<dots> \<le> card {q \<in> set (fst (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})). m < card (snd q)}"
	+ using refl IH(2) by (intro shift1_2 shift1_invI)
	+ finally show "card ?A \<le> card {q \<in> set qs. m < card (snd q)}" by (simp only: fst_conv)
	+ qed
	+qed
	+
	+lemma shift2_3: "shift2_inv d qs \<Longrightarrow> cone_decomp T qs \<Longrightarrow> cone_decomp T (shift2 c d qs)"
	+proof (induct c d qs rule: shift2.induct)
	+ case IH: (1 c d qs)
	+ have inv2: "shift2_inv (Suc d) (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})))"
	+ using IH(2) by (rule shift2_inv_preserved)
	+ show ?case
	+ proof (subst shift2.simps, simp add: IH.prems del: shift2.simps, intro impI)
	+ assume "\<not> c \<le> d"
	+ moreover note inv2
	+ moreover have "cone_decomp T (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})))"
	+ proof (rule shift1_3)
	+ from refl IH(2) show "shift1_inv d (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})"
	+ by (rule shift1_invI)
	+ qed (simp add: IH.prems)
	+ ultimately show "cone_decomp T (shift2 c (Suc d) (fst (shift1 (qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)}))))"
	+ by (rule IH)
	+ qed
	+qed
	+
	+lemma shift2_4:
	+ "shift2_inv d qs \<Longrightarrow> Max (poly_deg ` fst ` set qs) \<le> Max (poly_deg ` fst ` set (shift2 c d qs))"
	+proof (induct c d qs rule: shift2.induct)
	+ case IH: (1 c d qs)
	+ let ?args = "(qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})"
	+ show ?case
	+ proof (subst shift2.simps, simp del: shift2.simps, intro impI)
	+ assume "\<not> c \<le> d"
	+ have "Max (poly_deg ` fst ` set (fst ?args)) \<le> Max (poly_deg ` fst ` set (fst (shift1 ?args)))"
	+ using refl IH(2) by (intro shift1_4 shift1_invI)
	+ also from \<open>\<not> c \<le> d\<close> have "\<dots> \<le> Max (poly_deg ` fst ` set (shift2 c (Suc d) (fst (shift1 ?args))))"
	+ proof (rule IH)
	+ from IH(2) show "shift2_inv (Suc d) (fst (shift1 ?args))"
	+ by (rule shift2_inv_preserved)
	+ qed
	+ finally show "Max (poly_deg ` fst ` set qs) \<le> Max (poly_deg ` fst ` set (shift2 c (Suc d) (fst (shift1 ?args))))"
	+ by (simp only: fst_conv)
	+ qed
	+qed
	+
	+lemma shift2_5:
	+ "shift2_inv d qs \<Longrightarrow> shift2 c d qs = [] \<longleftrightarrow> qs = []"
	+proof (induct c d qs rule: shift2.induct)
	+ case IH: (1 c d qs)
	+ let ?args = "(qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})"
	+ show ?case
	+ proof (subst shift2.simps, simp del: shift2.simps, intro impI)
	+ assume "\<not> c \<le> d"
	+ hence "shift2 c (Suc d) (fst (shift1 ?args)) = [] \<longleftrightarrow> fst (shift1 ?args) = []"
	+ proof (rule IH)
	+ from IH(2) show "shift2_inv (Suc d) (fst (shift1 ?args))"
	+ by (rule shift2_inv_preserved)
	+ qed
	+ also from refl IH(2) have "\<dots> \<longleftrightarrow> fst ?args = []" by (intro shift1_5 shift1_invI)
	+ finally show "shift2 c (Suc d) (fst (shift1 ?args)) = [] \<longleftrightarrow> qs = []" by (simp only: fst_conv)
	+ qed
	+qed
	+
	+lemma shift2_6:
	+ "shift2_inv d qs \<Longrightarrow> monomial_decomp qs \<Longrightarrow> monomial_decomp (shift2 c d qs)"
	+proof (induct c d qs rule: shift2.induct)
	+ case IH: (1 c d qs)
	+ let ?args = "(qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})"
	+ show ?case
	+ proof (subst shift2.simps, simp del: shift2.simps, intro conjI impI IH)
	+ from IH(2) show "shift2_inv (Suc d) (fst (shift1 ?args))" by (rule shift2_inv_preserved)
	+ next
	+ from refl IH(2) have "shift1_inv d ?args" by (rule shift1_invI)
	+ moreover from IH(3) have "monomial_decomp (fst ?args)" by simp
	+ ultimately show "monomial_decomp (fst (shift1 ?args))" by (rule shift1_6)
	+ qed
	+qed
	+
	+lemma shift2_7:
	+ "shift2_inv d qs \<Longrightarrow> hom_decomp qs \<Longrightarrow> hom_decomp (shift2 c d qs)"
	+proof (induct c d qs rule: shift2.induct)
	+ case IH: (1 c d qs)
	+ let ?args = "(qs, {q \<in> set qs. poly_deg (fst q) = d \<and> m < card (snd q)})"
	+ show ?case
	+ proof (subst shift2.simps, simp del: shift2.simps, intro conjI impI IH)
	+ from IH(2) show "shift2_inv (Suc d) (fst (shift1 ?args))" by (rule shift2_inv_preserved)
	+ next
	+ from refl IH(2) have "shift1_inv d ?args" by (rule shift1_invI)
	+ moreover from IH(3) have "hom_decomp (fst ?args)" by simp
	+ ultimately show "hom_decomp (fst (shift1 ?args))" by (rule shift1_7)
	+ qed
	+qed
	+
	+definition shift :: "((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list \<Rightarrow>
	+ ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors}) \<times> 'x set) list"
	+ where "shift qs = shift2 (k + card {q \<in> set qs. m < card (snd q)}) k qs"
	+
	+lemma shift2_inv_init:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp (Suc m) qs"
	+ shows "shift2_inv k qs"
	+ using assms
	+proof (rule shift2_invI)
	+ fix d0
	+ assume "d0 < k"
	+ have "{q \<in> set qs. poly_deg (fst q) = d0 \<and> m < card (snd q)} = {}"
	+ proof -
	+ {
	+ fix q
	+ assume "q \<in> set qs"
	+ obtain h U where q: "q = (h, U)" using prod.exhaust by blast
	+ assume "poly_deg (fst q) = d0" and "m < card (snd q)"
	+ hence "poly_deg h < k" and "m < card U" using \<open>d0 < k\<close> by (simp_all add: q)
	+ from this(2) have "U \<noteq> {}" by auto
	+ with \<open>q \<in> set qs\<close> have "(h, U) \<in> set (qs\<^sub>+)" by (simp add: q pos_decomp_def)
	+ with assms(2) have "k \<le> poly_deg h" by (rule standard_decompD)
	+ with \<open>poly_deg h < k\<close> have False by simp
	+ }
	+ thus ?thesis by blast
	+ qed
	+ thus "card {q \<in> set qs. poly_deg (fst q) = d0 \<and> m < card (snd q)} \<le> 1" by (simp only: card_empty)
	+qed
	+
	+lemma shift:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp (Suc m) qs"
	+ shows "valid_decomp X (shift qs)" and "standard_decomp k (shift qs)" and "exact_decomp m (shift qs)"
	+proof -
	+ define c where "c = card {q \<in> set qs. m < card (snd q)}"
	+ define A where "A = {q \<in> set (shift qs). m < card (snd q)}"
	+ from assms have "shift2_inv k qs" by (rule shift2_inv_init)
	+ hence inv2: "shift2_inv (k + c) (shift qs)" and "card A \<le> c"
	+ unfolding shift_def c_def A_def by (rule shift2_1, rule shift2_2)
	+ from inv2 have fin: "valid_decomp X (shift qs)" and std: "standard_decomp k (shift qs)"
	+ and exct: "exact_decomp (Suc m) (shift qs)"
	+ by (rule shift2_invD)+
	+ show "valid_decomp X (shift qs)" and "standard_decomp k (shift qs)" by fact+
	+ have "finite A" by (auto simp: A_def)
	+
	+ show "exact_decomp m (shift qs)"
	+ proof (rule exact_decompI)
	+ fix h U
	+ assume "(h, U) \<in> set (shift qs)"
	+ with exct show "h \<in> P[X]" and "U \<subseteq> X" by (rule exact_decompD)+
	+ next
	+ fix h1 h2 U1 U2
	+ assume 1: "(h1, U1) \<in> set (shift qs)" and 2: "(h2, U2) \<in> set (shift qs)"
	+ assume 3: "poly_deg h1 = poly_deg h2" and 4: "m < card U1" and 5: "m < card U2"
	+ from 5 have "U2 \<noteq> {}" by auto
	+ with 2 have "(h2, U2) \<in> set ((shift qs)\<^sub>+)" by (simp add: pos_decomp_def)
	+ let ?C = "{q \<in> set (shift qs). poly_deg (fst q) = poly_deg h2 \<and> m < card (snd q)}"
	+ define B where "B = {q \<in> A. k \<le> poly_deg (fst q) \<and> poly_deg (fst q) \<le> poly_deg h2}"
	+ have "Suc (poly_deg h2) - k \<le> card B"
	+ proof -
	+ have "B = (\<Union>d0\<in>{k..poly_deg h2}. {q \<in> A. poly_deg (fst q) = d0})" by (auto simp: B_def)
	+ also have "card \<dots> = (\<Sum>d0=k..poly_deg h2. card {q \<in> A. poly_deg (fst q) = d0})"
	+ proof (intro card_UN_disjoint ballI impI)
	+ fix d0
	+ from _ \<open>finite A\<close> show "finite {q \<in> A. poly_deg (fst q) = d0}" by (rule finite_subset) blast
	+ next
	+ fix d0 d1 :: nat
	+ assume "d0 \<noteq> d1"
	+ thus "{q \<in> A. poly_deg (fst q) = d0} \<inter> {q \<in> A. poly_deg (fst q) = d1} = {}" by blast
	+ qed (fact finite_atLeastAtMost)
	+ also have "\<dots> \<ge> (\<Sum>d0=k..poly_deg h2. 1)"
	+ proof (rule sum_mono)
	+ fix d0
	+ assume "d0 \<in> {k..poly_deg h2}"
	+ hence "k \<le> d0" and "d0 \<le> poly_deg h2" by simp_all
	+ with std \<open>(h2, U2) \<in> set ((shift qs)\<^sub>+)\<close> obtain h' U' where "(h', U') \<in> set (shift qs)"
	+ and "poly_deg h' = d0" and "card U2 \<le> card U'" by (rule standard_decompE)
	+ from 5 this(3) have "m < card U'" by (rule less_le_trans)
	+ with \<open>(h', U') \<in> set (shift qs)\<close> have "(h', U') \<in> {q \<in> A. poly_deg (fst q) = d0}"
	+ by (simp add: A_def \<open>poly_deg h' = d0\<close>)
	+ hence "{q \<in> A. poly_deg (fst q) = d0} \<noteq> {}" by blast
	+ moreover from _ \<open>finite A\<close> have "finite {q \<in> A. poly_deg (fst q) = d0}"
	+ by (rule finite_subset) blast
	+ ultimately show "1 \<le> card {q \<in> A. poly_deg (fst q) = d0}"
	+ by (simp add: card_gt_0_iff Suc_le_eq)
	+ qed
	+ also have "(\<Sum>d0=k..poly_deg h2. 1) = Suc (poly_deg h2) - k" by auto
	+ finally show ?thesis .
	+ qed
	+ also from \<open>finite A\<close> _ have "\<dots> \<le> card A" by (rule card_mono) (auto simp: B_def)
	+ also have "\<dots> \<le> c" by fact
	+ finally have "poly_deg h2 < k + c" by simp
	+ with inv2 have "card ?C \<le> 1" by (rule shift2_invD)
	+ have "finite ?C" by auto
	+ moreover note \<open>card ?C \<le> 1\<close>
	+ moreover from 1 3 4 have "(h1, U1) \<in> ?C" by simp
	+ moreover from 2 5 have "(h2, U2) \<in> ?C" by simp
	+ ultimately show "(h1, U1) = (h2, U2)" by (auto simp: card_le_Suc0_iff_eq)
	+ qed
	+qed
	+
	+lemma monomial_decomp_shift:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp (Suc m) qs"
	+ and "monomial_decomp qs"
	+ shows "monomial_decomp (shift qs)"
	+proof -
	+ from assms(1, 2, 3) have "shift2_inv k qs" by (rule shift2_inv_init)
	+ thus ?thesis unfolding shift_def using assms(4) by (rule shift2_6)
	+qed
	+
	+lemma hom_decomp_shift:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp (Suc m) qs"
	+ and "hom_decomp qs"
	+ shows "hom_decomp (shift qs)"
	+proof -
	+ from assms(1, 2, 3) have "shift2_inv k qs" by (rule shift2_inv_init)
	+ thus ?thesis unfolding shift_def using assms(4) by (rule shift2_7)
	+qed
	+
	+lemma cone_decomp_shift:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp (Suc m) qs"
	+ and "cone_decomp T qs"
	+ shows "cone_decomp T (shift qs)"
	+proof -
	+ from assms(1, 2, 3) have "shift2_inv k qs" by (rule shift2_inv_init)
	+ thus ?thesis unfolding shift_def using assms(4) by (rule shift2_3)
	+qed
	+
	+lemma Max_shift_ge:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp (Suc m) qs"
	+ shows "Max (poly_deg ` fst ` set qs) \<le> Max (poly_deg ` fst ` set (shift qs))"
	+proof -
	+ from assms(1-3) have "shift2_inv k qs" by (rule shift2_inv_init)
	+ thus ?thesis unfolding shift_def by (rule shift2_4)
	+qed
	+
	+lemma shift_Nil_iff:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp (Suc m) qs"
	+ shows "shift qs = [] \<longleftrightarrow> qs = []"
	+proof -
	+ from assms(1-3) have "shift2_inv k qs" by (rule shift2_inv_init)
	+ thus ?thesis unfolding shift_def by (rule shift2_5)
	+qed
	+
	+end
	+
	+primrec exact_aux :: "nat \<Rightarrow> nat \<Rightarrow> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list \<Rightarrow>
	+ ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors}) \<times> 'x set) list" where
	+ "exact_aux k 0 qs = qs" \|
	+ "exact_aux k (Suc m) qs = exact_aux k m (shift k m qs)"
	+
	+lemma exact_aux:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp m qs"
	+ shows "valid_decomp X (exact_aux k m qs)" (is ?thesis1)
	+ and "standard_decomp k (exact_aux k m qs)" (is ?thesis2)
	+ and "exact_decomp 0 (exact_aux k m qs)" (is ?thesis3)
	+proof -
	+ from assms have "?thesis1 \<and> ?thesis2 \<and> ?thesis3"
	+ proof (induct m arbitrary: qs)
	+ case 0
	+ thus ?case by simp
	+ next
	+ case (Suc m)
	+ let ?qs = "shift k m qs"
	+ have "valid_decomp X (exact_aux k m ?qs) \<and> standard_decomp k (exact_aux k m ?qs) \<and>
	+ exact_decomp 0 (exact_aux k m ?qs)"
	+ proof (rule Suc)
	+ from Suc.prems show "valid_decomp X ?qs" and "standard_decomp k ?qs" and "exact_decomp m ?qs"
	+ by (rule shift)+
	+ qed
	+ thus ?case by simp
	+ qed
	+ thus ?thesis1 and ?thesis2 and ?thesis3 by simp_all
	+qed
	+
	+lemma monomial_decomp_exact_aux:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp m qs" and "monomial_decomp qs"
	+ shows "monomial_decomp (exact_aux k m qs)"
	+ using assms
	+proof (induct m arbitrary: qs)
	+ case 0
	+ thus ?case by simp
	+next
	+ case (Suc m)
	+ let ?qs = "shift k m qs"
	+ have "monomial_decomp (exact_aux k m ?qs)"
	+ proof (rule Suc)
	+ show "valid_decomp X ?qs" and "standard_decomp k ?qs" and "exact_decomp m ?qs"
	+ using Suc.prems(1, 2, 3) by (rule shift)+
	+ next
	+ from Suc.prems show "monomial_decomp ?qs" by (rule monomial_decomp_shift)
	+ qed
	+ thus ?case by simp
	+qed
	+
	+lemma hom_decomp_exact_aux:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp m qs" and "hom_decomp qs"
	+ shows "hom_decomp (exact_aux k m qs)"
	+ using assms
	+proof (induct m arbitrary: qs)
	+ case 0
	+ thus ?case by simp
	+next
	+ case (Suc m)
	+ let ?qs = "shift k m qs"
	+ have "hom_decomp (exact_aux k m ?qs)"
	+ proof (rule Suc)
	+ show "valid_decomp X ?qs" and "standard_decomp k ?qs" and "exact_decomp m ?qs"
	+ using Suc.prems(1, 2, 3) by (rule shift)+
	+ next
	+ from Suc.prems show "hom_decomp ?qs" by (rule hom_decomp_shift)
	+ qed
	+ thus ?case by simp
	+qed
	+
	+lemma cone_decomp_exact_aux:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp m qs" and "cone_decomp T qs"
	+ shows "cone_decomp T (exact_aux k m qs)"
	+ using assms
	+proof (induct m arbitrary: qs)
	+ case 0
	+ thus ?case by simp
	+next
	+ case (Suc m)
	+ let ?qs = "shift k m qs"
	+ have "cone_decomp T (exact_aux k m ?qs)"
	+ proof (rule Suc)
	+ show "valid_decomp X ?qs" and "standard_decomp k ?qs" and "exact_decomp m ?qs"
	+ using Suc.prems(1, 2, 3) by (rule shift)+
	+ next
	+ from Suc.prems show "cone_decomp T ?qs" by (rule cone_decomp_shift)
	+ qed
	+ thus ?case by simp
	+qed
	+
	+lemma Max_exact_aux_ge:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp m qs"
	+ shows "Max (poly_deg ` fst ` set qs) \<le> Max (poly_deg ` fst ` set (exact_aux k m qs))"
	+ using assms
	+proof (induct m arbitrary: qs)
	+ case 0
	+ thus ?case by simp
	+next
	+ case (Suc m)
	+ let ?qs = "shift k m qs"
	+ from Suc.prems have "Max (poly_deg ` fst ` set qs) \<le> Max (poly_deg ` fst ` set ?qs)"
	+ by (rule Max_shift_ge)
	+ also have "\<dots> \<le> Max (poly_deg ` fst ` set (exact_aux k m ?qs))"
	+ proof (rule Suc)
	+ from Suc.prems show "valid_decomp X ?qs" and "standard_decomp k ?qs" and "exact_decomp m ?qs"
	+ by (rule shift)+
	+ qed
	+ finally show ?case by simp
	+qed
	+
	+lemma exact_aux_Nil_iff:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "exact_decomp m qs"
	+ shows "exact_aux k m qs = [] \<longleftrightarrow> qs = []"
	+ using assms
	+proof (induct m arbitrary: qs)
	+ case 0
	+ thus ?case by simp
	+next
	+ case (Suc m)
	+ let ?qs = "shift k m qs"
	+ have "exact_aux k m ?qs = [] \<longleftrightarrow> ?qs = []"
	+ proof (rule Suc)
	+ from Suc.prems show "valid_decomp X ?qs" and "standard_decomp k ?qs" and "exact_decomp m ?qs"
	+ by (rule shift)+
	+ qed
	+ also from Suc.prems have "\<dots> \<longleftrightarrow> qs = []" by (rule shift_Nil_iff)
	+ finally show ?case by simp
	+qed
	+
	+definition exact :: "nat \<Rightarrow> ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) list \<Rightarrow>
	+ ((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::{comm_ring_1,ring_no_zero_divisors}) \<times> 'x set) list"
	+ where "exact k qs = exact_aux k (card X) qs"
	+
	+lemma exact:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs"
	+ shows "valid_decomp X (exact k qs)" (is ?thesis1)
	+ and "standard_decomp k (exact k qs)" (is ?thesis2)
	+ and "exact_decomp 0 (exact k qs)" (is ?thesis3)
	+proof -
	+ from assms(1) le_refl have "exact_decomp (card X) qs" by (rule exact_decomp_card_X)
	+ with assms show ?thesis1 and ?thesis2 and ?thesis3 unfolding exact_def by (rule exact_aux)+
	+qed
	+
	+lemma monomial_decomp_exact:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "monomial_decomp qs"
	+ shows "monomial_decomp (exact k qs)"
	+proof -
	+ from assms(1) le_refl have "exact_decomp (card X) qs" by (rule exact_decomp_card_X)
	+ with assms(1, 2) show ?thesis unfolding exact_def using assms(3) by (rule monomial_decomp_exact_aux)
	+qed
	+
	+lemma hom_decomp_exact:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "hom_decomp qs"
	+ shows "hom_decomp (exact k qs)"
	+proof -
	+ from assms(1) le_refl have "exact_decomp (card X) qs" by (rule exact_decomp_card_X)
	+ with assms(1, 2) show ?thesis unfolding exact_def using assms(3) by (rule hom_decomp_exact_aux)
	+qed
	+
	+lemma cone_decomp_exact:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "cone_decomp T qs"
	+ shows "cone_decomp T (exact k qs)"
	+proof -
	+ from assms(1) le_refl have "exact_decomp (card X) qs" by (rule exact_decomp_card_X)
	+ with assms(1, 2) show ?thesis unfolding exact_def using assms(3) by (rule cone_decomp_exact_aux)
	+qed
	+
	+lemma Max_exact_ge:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs"
	+ shows "Max (poly_deg ` fst ` set qs) \<le> Max (poly_deg ` fst ` set (exact k qs))"
	+proof -
	+ from assms(1) le_refl have "exact_decomp (card X) qs" by (rule exact_decomp_card_X)
	+ with assms(1, 2) show ?thesis unfolding exact_def by (rule Max_exact_aux_ge)
	+qed
	+
	+lemma exact_Nil_iff:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs"
	+ shows "exact k qs = [] \<longleftrightarrow> qs = []"
	+proof -
	+ from assms(1) le_refl have "exact_decomp (card X) qs" by (rule exact_decomp_card_X)
	+ with assms(1, 2) show ?thesis unfolding exact_def by (rule exact_aux_Nil_iff)
	+qed
	+
	+corollary \<b>_zero_exact:
	+ assumes "valid_decomp X qs" and "standard_decomp k qs" and "qs \<noteq> []"
	+ shows "Suc (Max (poly_deg ` fst ` set qs)) \<le> \<b> (exact k qs) 0"
	+proof -
	+ from assms(1, 2) have "Max (poly_deg ` fst ` set qs) \<le> Max (poly_deg ` fst ` set (exact k qs))"
	+ by (rule Max_exact_ge)
	+ also have "Suc \<dots> \<le> \<b> (exact k qs) 0"
	+ proof (rule \<b>_zero)
	+ from assms show "exact k qs \<noteq> []" by (simp add: exact_Nil_iff)
	+ qed
	+ finally show ?thesis by simp
	+qed
	+
	+lemma normal_form_exact_decompE:
	+ assumes "F \<subseteq> P[X]"
	+ obtains qs where "valid_decomp X qs" and "standard_decomp 0 qs" and "monomial_decomp qs"
	+ and "cone_decomp (normal_form F ` P[X]) qs" and "exact_decomp 0 qs"
	+ and "\<And>g. (\<And>f. f \<in> F \<Longrightarrow> homogeneous f) \<Longrightarrow> g \<in> punit.reduced_GB F \<Longrightarrow> poly_deg g \<le> \<b> qs 0"
	+proof -
	+ let ?G = "punit.reduced_GB F"
	+ let ?S = "lpp ` ?G"
	+ let ?N = "normal_form F ` P[X]"
	+ define qs::"((_ \<Rightarrow>\<^sub>0 'a) \<times> _) list" where "qs = snd (split 0 X ?S)"
	+ from fin_X assms have std: "standard_decomp 0 qs" and cn: "cone_decomp ?N qs"
	+ unfolding qs_def by (rule standard_cone_decomp_snd_split)+
	+ from fin_X assms have "finite ?G" by (rule finite_reduced_GB_Polys)
	+ hence "finite ?S" by (rule finite_imageI)
	+ with fin_X subset_refl have valid: "valid_decomp X qs" unfolding qs_def using zero_in_PPs
	+ by (rule valid_decomp_split)
	+ from fin_X subset_refl \<open>finite ?S\<close> have md: "monomial_decomp qs"
	+ unfolding qs_def by (rule monomial_decomp_split)
	+ let ?qs = "exact 0 qs"
	+ from valid std have "valid_decomp X ?qs" and "standard_decomp 0 ?qs" by (rule exact)+
	+ moreover from valid std md have "monomial_decomp ?qs" by (rule monomial_decomp_exact)
	+ moreover from valid std cn have "cone_decomp ?N ?qs" by (rule cone_decomp_exact)
	+ moreover from valid std have "exact_decomp 0 ?qs" by (rule exact)
	+ moreover have "poly_deg g \<le> \<b> ?qs 0" if "\<And>f. f \<in> F \<Longrightarrow> homogeneous f" and "g \<in> ?G" for g
	+ proof (cases "qs = []")
	+ case True
	+ from one_in_Polys have "normal_form F 1 \<in> ?N" by (rule imageI)
	+ also from True cn have "\<dots> = {0}" by (simp add: cone_decomp_def direct_decomp_def bij_betw_def)
	+ finally have "?G = {1}" using fin_X assms
	+ by (simp add: normal_form_zero_iff ideal_eq_UNIV_iff_reduced_GB_eq_one_Polys
	+ flip: ideal_eq_UNIV_iff_contains_one)
	+ with that(2) show ?thesis by simp
	+ next
	+ case False
	+ from fin_X assms that have "poly_deg g \<le> Suc (Max (poly_deg ` fst ` set qs))"
	+ unfolding qs_def by (rule standard_cone_decomp_snd_split)
	+ also from valid std False have "\<dots> \<le> \<b> ?qs 0" by (rule \<b>_zero_exact)
	+ finally show ?thesis .
	+ qed
	+ ultimately show ?thesis ..
	+qed
	+
	+end
	+
	+end
	+
	+end (* pm_powerprod *)
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Degree_Bound_Utils.thy b/thys/Groebner_Macaulay/Degree_Bound_Utils.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Degree_Bound_Utils.thy
	@@ -0,0 +1,314 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Utility Definitions and Lemmas about Degree Bounds for Gr\"obner Bases\<close>
	+
	+theory Degree_Bound_Utils
	+ imports Groebner_Bases.Groebner_PM
	+begin
	+
	+context pm_powerprod
	+begin
	+
	+definition is_GB_cofactor_bound :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'b::field) set \<Rightarrow> nat \<Rightarrow> bool"
	+ where "is_GB_cofactor_bound F b \<longleftrightarrow>
	+ (\<exists>G. punit.is_Groebner_basis G \<and> ideal G = ideal F \<and> UNION G indets \<subseteq> UNION F indets \<and>
	+ (\<forall>g\<in>G. \<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and> (\<forall>f\<in>F'. poly_deg (q f * f) \<le> b)))"
	+
	+definition is_hom_GB_bound :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'b::field) set \<Rightarrow> nat \<Rightarrow> bool"
	+ where "is_hom_GB_bound F b \<longleftrightarrow> ((\<forall>f\<in>F. homogeneous f) \<longrightarrow> (\<forall>g\<in>punit.reduced_GB F. poly_deg g \<le> b))"
	+
	+lemma is_GB_cofactor_boundI:
	+ assumes "punit.is_Groebner_basis G" and "ideal G = ideal F" and "UNION G indets \<subseteq> UNION F indets"
	+ and "\<And>g. g \<in> G \<Longrightarrow> \<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and> (\<forall>f\<in>F'. poly_deg (q f * f) \<le> b)"
	+ shows "is_GB_cofactor_bound F b"
	+ unfolding is_GB_cofactor_bound_def using assms by blast
	+
	+lemma is_GB_cofactor_boundE:
	+ fixes F :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'b::field) set"
	+ assumes "is_GB_cofactor_bound F b"
	+ obtains G where "punit.is_Groebner_basis G" and "ideal G = ideal F" and "UNION G indets \<subseteq> UNION F indets"
	+ and "\<And>g. g \<in> G \<Longrightarrow> \<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. indets (q f) \<subseteq> UNION F indets \<and> poly_deg (q f * f) \<le> b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+proof -
	+ let ?X = "UNION F indets"
	+ from assms obtain G where "punit.is_Groebner_basis G" and "ideal G = ideal F" and "UNION G indets \<subseteq> ?X"
	+ and 1: "\<And>g. g \<in> G \<Longrightarrow> \<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and> (\<forall>f\<in>F'. poly_deg (q f * f) \<le> b)"
	+ by (auto simp: is_GB_cofactor_bound_def)
	+ from this(1, 2, 3) show ?thesis
	+ proof
	+ fix g
	+ assume "g \<in> G"
	+ show "\<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. indets (q f) \<subseteq> ?X \<and> poly_deg (q f * f) \<le> b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+ proof (cases "g = 0")
	+ case True
	+ define q where "q = (\<lambda>f::('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'b. 0::('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'b)"
	+ show ?thesis
	+ proof (intro exI conjI allI)
	+ show "g = (\<Sum>f\<in>{}. q f * f)" by (simp add: True q_def)
	+ qed (simp_all add: q_def)
	+ next
	+ case False
	+ let ?X = "UNION F indets"
	+ from \<open>g \<in> G\<close> have "\<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and> (\<forall>f\<in>F'. poly_deg (q f * f) \<le> b)"
	+ by (rule 1)
	+ then obtain F' q0 where "finite F'" and "F' \<subseteq> F" and g: "g = (\<Sum>f\<in>F'. q0 f * f)"
	+ and q0: "\<And>f. f \<in> F' \<Longrightarrow> poly_deg (q0 f * f) \<le> b" by blast
	+ define sub where "sub = (\<lambda>x::'x. if x \<in> ?X then
	+ monomial (1::'b) (Poly_Mapping.single x (1::nat))
	+ else 1)"
	+ have 1: "sub x = monomial 1 (monomial 1 x)" if "x \<in> indets g" for x
	+ proof (simp add: sub_def, rule)
	+ from that \<open>g \<in> G\<close> have "x \<in> UNION G indets" by blast
	+ also have "\<dots> \<subseteq> ?X" by fact
	+ finally obtain f where "f \<in> F" and "x \<in> indets f" ..
	+ assume "\<forall>f\<in>F. x \<notin> indets f"
	+ hence "x \<notin> indets f" using \<open>f \<in> F\<close> ..
	+ thus "monomial 1 (monomial (Suc 0) x) = 1" using \<open>x \<in> indets f\<close> ..
	+ qed
	+ have 2: "sub x = monomial 1 (monomial 1 x)" if "f \<in> F'" and "x \<in> indets f" for f x
	+ proof (simp add: sub_def, rule)
	+ assume "\<forall>f\<in>F. x \<notin> indets f"
	+ moreover from that(1) \<open>F' \<subseteq> F\<close> have "f \<in> F" ..
	+ ultimately have "x \<notin> indets f" ..
	+ thus "monomial 1 (monomial (Suc 0) x) = 1" using that(2) ..
	+ qed
	+ have 3: "poly_subst sub f = f" if "f \<in> F'" for f by (rule poly_subst_id, rule 2, rule that)
	+ define q where "q = (\<lambda>f. if f \<in> F' then poly_subst sub (q0 f) else 0)"
	+ show ?thesis
	+ proof (intro exI allI conjI impI)
	+ from 1 have "g = poly_subst sub g" by (rule poly_subst_id[symmetric])
	+ also have "\<dots> = (\<Sum>f\<in>F'. q f * (poly_subst sub f))"
	+ by (simp add: g poly_subst_sum poly_subst_times q_def cong: sum.cong)
	+ also from refl have "\<dots> = (\<Sum>f\<in>F'. q f * f)"
	+ proof (rule sum.cong)
	+ fix f
	+ assume "f \<in> F'"
	+ hence "poly_subst sub f = f" by (rule 3)
	+ thus "q f * poly_subst sub f = q f * f" by simp
	+ qed
	+ finally show "g = (\<Sum>f\<in>F'. q f * f)" .
	+ next
	+ fix f
	+ have "indets (q f) \<subseteq> ?X \<and> poly_deg (q f * f) \<le> b"
	+ proof (cases "f \<in> F'")
	+ case True
	+ hence qf: "q f = poly_subst sub (q0 f)" by (simp add: q_def)
	+ show ?thesis
	+ proof
	+ show "indets (q f) \<subseteq> ?X"
	+ proof
	+ fix x
	+ assume "x \<in> indets (q f)"
	+ then obtain y where "x \<in> indets (sub y)" unfolding qf by (rule in_indets_poly_substE)
	+ hence y: "y \<in> ?X" and "x \<in> indets (monomial (1::'b) (monomial (1::nat) y))"
	+ by (simp_all add: sub_def split: if_splits)
	+ from this(2) have "x = y" by (simp add: indets_monomial)
	+ with y show "x \<in> ?X" by (simp only:)
	+ qed
	+ next
	+ from \<open>f \<in> F'\<close> have "poly_subst sub f = f" by (rule 3)
	+ hence "poly_deg (q f * f) = poly_deg (q f * poly_subst sub f)" by (simp only:)
	+ also have "\<dots> = poly_deg (poly_subst sub (q0 f * f))" by (simp only: qf poly_subst_times)
	+ also have "\<dots> \<le> poly_deg (q0 f * f)"
	+ proof (rule poly_deg_poly_subst_le)
	+ fix x
	+ show "poly_deg (sub x) \<le> 1" by (simp add: sub_def poly_deg_monomial deg_pm_single)
	+ qed
	+ also from \<open>f \<in> F'\<close> have "\<dots> \<le> b" by (rule q0)
	+ finally show "poly_deg (q f * f) \<le> b" .
	+ qed
	+ next
	+ case False
	+ thus ?thesis by (simp add: q_def)
	+ qed
	+ thus "indets (q f) \<subseteq> ?X" and "poly_deg (q f * f) \<le> b" by simp_all
	+
	+ assume "f \<notin> F'"
	+ thus "q f = 0" by (simp add: q_def)
	+ qed fact+
	+ qed
	+ qed
	+qed
	+
	+lemma is_GB_cofactor_boundE_Polys:
	+ fixes F :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'b::field) set"
	+ assumes "is_GB_cofactor_bound F b" and "F \<subseteq> P[X]"
	+ obtains G where "punit.is_Groebner_basis G" and "ideal G = ideal F" and "G \<subseteq> P[X]"
	+ and "\<And>g. g \<in> G \<Longrightarrow> \<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+proof -
	+ let ?X = "UNION F indets"
	+ have "?X \<subseteq> X"
	+ proof
	+ fix x
	+ assume "x \<in> ?X"
	+ then obtain f where "f \<in> F" and "x \<in> indets f" ..
	+ from this(1) assms(2) have "f \<in> P[X]" ..
	+ hence "indets f \<subseteq> X" by (rule PolysD)
	+ with \<open>x \<in> indets f\<close> show "x \<in> X" ..
	+ qed
	+ from assms(1) obtain G where "punit.is_Groebner_basis G" and "ideal G = ideal F"
	+ and 1: "UNION G indets \<subseteq> ?X"
	+ and 2: "\<And>g. g \<in> G \<Longrightarrow> \<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. indets (q f) \<subseteq> ?X \<and> poly_deg (q f * f) \<le> b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+ by (rule is_GB_cofactor_boundE) blast
	+ from this(1, 2) show ?thesis
	+ proof
	+ show "G \<subseteq> P[X]"
	+ proof
	+ fix g
	+ assume "g \<in> G"
	+ hence "indets g \<subseteq> UNION G indets" by blast
	+ also have "\<dots> \<subseteq> ?X" by fact
	+ also have "\<dots> \<subseteq> X" by fact
	+ finally show "g \<in> P[X]" by (rule PolysI_alt)
	+ qed
	+ next
	+ fix g
	+ assume "g \<in> G"
	+ hence "\<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. indets (q f) \<subseteq> ?X \<and> poly_deg (q f * f) \<le> b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+ by (rule 2)
	+ then obtain F' q where "finite F'" and "F' \<subseteq> F" and "g = (\<Sum>f\<in>F'. q f * f)"
	+ and "\<And>f. indets (q f) \<subseteq> ?X" and "\<And>f. poly_deg (q f * f) \<le> b" and "\<And>f. f \<notin> F' \<Longrightarrow> q f = 0"
	+ by blast
	+ show "\<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+ proof (intro exI allI conjI impI)
	+ fix f
	+ from \<open>indets (q f) \<subseteq> ?X\<close> \<open>?X \<subseteq> X\<close> have "indets (q f) \<subseteq> X" by (rule subset_trans)
	+ thus "q f \<in> P[X]" by (rule PolysI_alt)
	+ qed fact+
	+ qed
	+qed
	+
	+lemma is_GB_cofactor_boundE_finite_Polys:
	+ fixes F :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'b::field) set"
	+ assumes "is_GB_cofactor_bound F b" and "finite F" and "F \<subseteq> P[X]"
	+ obtains G where "punit.is_Groebner_basis G" and "ideal G = ideal F" and "G \<subseteq> P[X]"
	+ and "\<And>g. g \<in> G \<Longrightarrow> \<exists>q. g = (\<Sum>f\<in>F. q f * f) \<and> (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> b)"
	+proof -
	+ from assms(1, 3) obtain G where "punit.is_Groebner_basis G" and "ideal G = ideal F" and "G \<subseteq> P[X]"
	+ and 1: "\<And>g. g \<in> G \<Longrightarrow> \<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+ by (rule is_GB_cofactor_boundE_Polys) blast
	+ from this(1, 2, 3) show ?thesis
	+ proof
	+ fix g
	+ assume "g \<in> G"
	+ hence "\<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+ by (rule 1)
	+ then obtain F' q where "F' \<subseteq> F" and g: "g = (\<Sum>f\<in>F'. q f * f)"
	+ and "\<And>f. q f \<in> P[X]" and "\<And>f. poly_deg (q f * f) \<le> b" and 2: "\<And>f. f \<notin> F' \<Longrightarrow> q f = 0" by blast
	+ show "\<exists>q. g = (\<Sum>f\<in>F. q f * f) \<and> (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> b)"
	+ proof (intro exI conjI impI allI)
	+ from assms(2) \<open>F' \<subseteq> F\<close> have "(\<Sum>f\<in>F'. q f * f) = (\<Sum>f\<in>F. q f * f)"
	+ proof (intro sum.mono_neutral_left ballI)
	+ fix f
	+ assume "f \<in> F - F'"
	+ hence "f \<notin> F'" by simp
	+ hence "q f = 0" by (rule 2)
	+ thus "q f * f = 0" by simp
	+ qed
	+ thus "g = (\<Sum>f\<in>F. q f * f)" by (simp only: g)
	+ qed fact+
	+ qed
	+qed
	+
	+lemma is_GB_cofactor_boundI_subset_zero:
	+ assumes "F \<subseteq> {0}"
	+ shows "is_GB_cofactor_bound F b"
	+ using punit.is_Groebner_basis_empty
	+proof (rule is_GB_cofactor_boundI)
	+ from assms show "ideal {} = ideal F" by (metis ideal.span_empty ideal_eq_zero_iff)
	+qed simp_all
	+
	+lemma is_hom_GB_boundI:
	+ "(\<And>g. (\<And>f. f \<in> F \<Longrightarrow> homogeneous f) \<Longrightarrow> g \<in> punit.reduced_GB F \<Longrightarrow> poly_deg g \<le> b) \<Longrightarrow> is_hom_GB_bound F b"
	+ unfolding is_hom_GB_bound_def by blast
	+
	+lemma is_hom_GB_boundD:
	+ "is_hom_GB_bound F b \<Longrightarrow> (\<And>f. f \<in> F \<Longrightarrow> homogeneous f) \<Longrightarrow> g \<in> punit.reduced_GB F \<Longrightarrow> poly_deg g \<le> b"
	+ unfolding is_hom_GB_bound_def by blast
	+
	+text \<open>The following is the main theorem in this theory. It shows that a bound for Gr\"obner bases of
	+ homogenized input sets is always also a cofactor bound for the original input sets.\<close>
	+
	+lemma (in extended_ord_pm_powerprod) hom_GB_bound_is_GB_cofactor_bound:
	+ assumes "finite X" and "F \<subseteq> P[X]" and "extended_ord.is_hom_GB_bound (homogenize None ` extend_indets ` F) b"
	+ shows "is_GB_cofactor_bound F b"
	+proof -
	+ let ?F = "homogenize None ` extend_indets ` F"
	+ define Y where "Y = \<Union> (indets ` F)"
	+ define G where "G = restrict_indets ` (extended_ord.punit.reduced_GB ?F)"
	+ have "Y \<subseteq> X"
	+ proof
	+ fix x
	+ assume "x \<in> Y"
	+ then obtain f where "f \<in> F" and "x \<in> indets f" unfolding Y_def ..
	+ from this(1) assms(2) have "f \<in> P[X]" ..
	+ hence "indets f \<subseteq> X" by (rule PolysD)
	+ with \<open>x \<in> indets f\<close> show "x \<in> X" ..
	+ qed
	+ hence "finite Y" using assms(1) by (rule finite_subset)
	+ moreover have "F \<subseteq> P[Y]" by (auto simp: Y_def Polys_alt)
	+ ultimately have "punit.is_Groebner_basis G" and "ideal G = ideal F" and "G \<subseteq> P[Y]"
	+ unfolding G_def by (rule restrict_indets_reduced_GB)+
	+ from this(1, 2) show ?thesis
	+ proof (rule is_GB_cofactor_boundI)
	+ from \<open>G \<subseteq> P[Y]\<close> show "\<Union> (indets ` G) \<subseteq> \<Union> (indets ` F)" by (auto simp: Y_def Polys_alt)
	+ next
	+ fix g
	+ assume "g \<in> G"
	+ then obtain g' where g': "g' \<in> extended_ord.punit.reduced_GB ?F"
	+ and g: "g = restrict_indets g'" unfolding G_def ..
	+ have "f \<in> ?F \<Longrightarrow> homogeneous f" for f by (auto simp: homogeneous_homogenize)
	+ with assms(3) have "poly_deg g' \<le> b" using g' by (rule extended_ord.is_hom_GB_boundD)
	+ from g' have "g' \<in> ideal (extended_ord.punit.reduced_GB ?F)" by (rule ideal.span_base)
	+ also have "\<dots> = ideal ?F"
	+ proof (rule extended_ord.reduced_GB_ideal_Polys)
	+ from \<open>finite Y\<close> show "finite (insert None (Some ` Y))" by simp
	+ next
	+ show "?F \<subseteq> P[insert None (Some ` Y)]"
	+ proof
	+ fix f0
	+ assume "f0 \<in> ?F"
	+ then obtain f where "f \<in> F" and f0: "f0 = homogenize None (extend_indets f)" by blast
	+ from this(1) \<open>F \<subseteq> P[Y]\<close> have "f \<in> P[Y]" ..
	+ hence "extend_indets f \<in> P[Some ` Y]" by (auto simp: indets_extend_indets Polys_alt)
	+ thus "f0 \<in> P[insert None (Some ` Y)]" unfolding f0 by (rule homogenize_in_Polys)
	+ qed
	+ qed
	+ finally have "g' \<in> ideal ?F" .
	+ with \<open>\<And>f. f \<in> ?F \<Longrightarrow> homogeneous f\<close> obtain F0 q where "finite F0" and "F0 \<subseteq> ?F"
	+ and g': "g' = (\<Sum>f\<in>F0. q f * f)" and deg_le: "\<And>f. poly_deg (q f * f) \<le> poly_deg g'"
	+ by (rule homogeneous_idealE) blast+
	+ from this(2) obtain F' where "F' \<subseteq> F" and F0: "F0 = homogenize None ` extend_indets ` F'"
	+ and inj_on: "inj_on (homogenize None \<circ> extend_indets) F'"
	+ unfolding image_comp by (rule subset_imageE_inj)
	+ show "\<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and> (\<forall>f\<in>F'. poly_deg (q f * f) \<le> b)"
	+ proof (intro exI conjI ballI)
	+ from inj_on \<open>finite F0\<close> show "finite F'" by (simp only: finite_image_iff F0 image_comp)
	+ next
	+ from inj_on show "g = (\<Sum>f\<in>F'. (restrict_indets \<circ> q \<circ> homogenize None \<circ> extend_indets) f * f)"
	+ by (simp add: g g' F0 restrict_indets_sum restrict_indets_times sum.reindex image_comp o_def)
	+ next
	+ fix f
	+ assume "f \<in> F'"
	+ have "poly_deg ((restrict_indets \<circ> q \<circ> homogenize None \<circ> extend_indets) f * f) =
	+ poly_deg (restrict_indets (q (homogenize None (extend_indets f)) * homogenize None (extend_indets f)))"
	+ by (simp add: restrict_indets_times)
	+ also have "\<dots> \<le> poly_deg (q (homogenize None (extend_indets f)) * homogenize None (extend_indets f))"
	+ by (rule poly_deg_restrict_indets_le)
	+ also have "\<dots> \<le> poly_deg g'" by (rule deg_le)
	+ also have "\<dots> \<le> b" by fact
	+ finally show "poly_deg ((restrict_indets \<circ> q \<circ> homogenize None \<circ> extend_indets) f * f) \<le> b" .
	+ qed fact
	+ qed
	+qed
	+
	+end (* pm_powerprod *)
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Degree_Section.thy b/thys/Groebner_Macaulay/Degree_Section.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Degree_Section.thy
	@@ -0,0 +1,305 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Degree Sections of Power-Products\<close>
	+
	+theory Degree_Section
	+ imports Polynomials.MPoly_PM
	+begin
	+
	+definition deg_sect :: "'x set \<Rightarrow> nat \<Rightarrow> ('x::countable \<Rightarrow>\<^sub>0 nat) set"
	+ where "deg_sect X d = .[X] \<inter> {t. deg_pm t = d}"
	+
	+definition deg_le_sect :: "'x set \<Rightarrow> nat \<Rightarrow> ('x::countable \<Rightarrow>\<^sub>0 nat) set"
	+ where "deg_le_sect X d = (\<Union>d0\<le>d. deg_sect X d0)"
	+
	+lemma deg_sectI: "t \<in> .[X] \<Longrightarrow> deg_pm t = d \<Longrightarrow> t \<in> deg_sect X d"
	+ by (simp add: deg_sect_def)
	+
	+lemma deg_sectD:
	+ assumes "t \<in> deg_sect X d"
	+ shows "t \<in> .[X]" and "deg_pm t = d"
	+ using assms by (simp_all add: deg_sect_def)
	+
	+lemma deg_le_sect_alt: "deg_le_sect X d = .[X] \<inter> {t. deg_pm t \<le> d}"
	+ by (auto simp: deg_le_sect_def deg_sect_def)
	+
	+lemma deg_le_sectI: "t \<in> .[X] \<Longrightarrow> deg_pm t \<le> d \<Longrightarrow> t \<in> deg_le_sect X d"
	+ by (simp add: deg_le_sect_alt)
	+
	+lemma deg_le_sectD:
	+ assumes "t \<in> deg_le_sect X d"
	+ shows "t \<in> .[X]" and "deg_pm t \<le> d"
	+ using assms by (simp_all add: deg_le_sect_alt)
	+
	+lemma deg_sect_zero [simp]: "deg_sect X 0 = {0}"
	+ by (auto simp: deg_sect_def zero_in_PPs)
	+
	+lemma deg_sect_empty: "deg_sect {} d = (if d = 0 then {0} else {})"
	+ by (auto simp: deg_sect_def)
	+
	+lemma deg_sect_singleton [simp]: "deg_sect {x} d = {Poly_Mapping.single x d}"
	+ by (auto simp: deg_sect_def deg_pm_single PPs_singleton)
	+
	+lemma deg_le_sect_zero [simp]: "deg_le_sect X 0 = {0}"
	+ by (auto simp: deg_le_sect_def)
	+
	+lemma deg_le_sect_empty [simp]: "deg_le_sect {} d = {0}"
	+ by (auto simp: deg_le_sect_alt varnum_eq_zero_iff)
	+
	+lemma deg_le_sect_singleton: "deg_le_sect {x} d = Poly_Mapping.single x ` {..d}"
	+ by (auto simp: deg_le_sect_alt deg_pm_single PPs_singleton)
	+
	+lemma deg_sect_mono: "X \<subseteq> Y \<Longrightarrow> deg_sect X d \<subseteq> deg_sect Y d"
	+ by (auto simp: deg_sect_def dest: PPs_mono)
	+
	+lemma deg_le_sect_mono_1: "X \<subseteq> Y \<Longrightarrow> deg_le_sect X d \<subseteq> deg_le_sect Y d"
	+ by (auto simp: deg_le_sect_alt dest: PPs_mono)
	+
	+lemma deg_le_sect_mono_2: "d1 \<le> d2 \<Longrightarrow> deg_le_sect X d1 \<subseteq> deg_le_sect X d2"
	+ by (auto simp: deg_le_sect_alt)
	+
	+lemma zero_in_deg_le_sect: "0 \<in> deg_le_sect n d"
	+ by (simp add: deg_le_sect_alt zero_in_PPs)
	+
	+lemma deg_sect_disjoint: "d1 \<noteq> d2 \<Longrightarrow> deg_sect X d1 \<inter> deg_sect Y d2 = {}"
	+ by (auto simp: deg_sect_def)
	+
	+lemma deg_le_sect_deg_sect_disjoint: "d1 < d2 \<Longrightarrow> deg_le_sect Y d1 \<inter> deg_sect X d2 = {}"
	+ by (auto simp: deg_sect_def deg_le_sect_alt)
	+
	+lemma deg_sect_Suc:
	+ "deg_sect X (Suc d) = (\<Union>x\<in>X. (+) (Poly_Mapping.single x 1) ` deg_sect X d)" (is "?A = ?B")
	+proof (rule set_eqI)
	+ fix t
	+ show "t \<in> ?A \<longleftrightarrow> t \<in> ?B"
	+ proof
	+ assume "t \<in> ?A"
	+ hence "t \<in> .[X]" and "deg_pm t = Suc d" by (rule deg_sectD)+
	+ from this(2) have "keys t \<noteq> {}" by auto
	+ then obtain x where "x \<in> keys t" by blast
	+ hence "1 \<le> lookup t x" by (simp add: in_keys_iff)
	+ from \<open>t \<in> .[X]\<close> have "keys t \<subseteq> X" by (rule PPsD)
	+ with \<open>x \<in> keys t\<close> have "x \<in> X" ..
	+ let ?s = "Poly_Mapping.single x (1::nat)"
	+ from \<open>1 \<le> lookup t x\<close> have "?s adds t"
	+ by (auto simp: lookup_single when_def intro!: adds_poly_mappingI le_funI)
	+ hence t: "?s + (t - ?s) = t" by (metis add.commute adds_minus)
	+ have "t - ?s \<in> deg_sect X d"
	+ proof (rule deg_sectI)
	+ from \<open>t \<in> .[X]\<close> show "t - ?s \<in> .[X]" by (rule PPs_closed_minus)
	+ next
	+ from deg_pm_plus[of ?s "t - ?s"] have "deg_pm t = Suc (deg_pm (t - ?s))"
	+ by (simp only: t deg_pm_single)
	+ thus "deg_pm (t - ?s) = d" by (simp add: \<open>deg_pm t = Suc d\<close>)
	+ qed
	+ hence "?s + (t - ?s) \<in> (+) ?s ` deg_sect X d" by (rule imageI)
	+ hence "t \<in> (+) ?s ` deg_sect X d" by (simp only: t)
	+ with \<open>x \<in> X\<close> show "t \<in> ?B" ..
	+ next
	+ assume "t \<in> ?B"
	+ then obtain x where "x \<in> X" and "t \<in> (+) (Poly_Mapping.single x 1) ` deg_sect X d" ..
	+ from this(2) obtain s where s: "s \<in> deg_sect X d"
	+ and t: "t = Poly_Mapping.single x 1 + s" (is "t = ?s + s") ..
	+ show "t \<in> ?A"
	+ proof (rule deg_sectI)
	+ from \<open>x \<in> X\<close> have "?s \<in> .[X]" by (rule PPs_closed_single)
	+ moreover from s have "s \<in> .[X]" by (rule deg_sectD)
	+ ultimately show "t \<in> .[X]" unfolding t by (rule PPs_closed_plus)
	+ next
	+ from s have "deg_pm s = d" by (rule deg_sectD)
	+ thus "deg_pm t = Suc d" by (simp add: t deg_pm_single deg_pm_plus)
	+ qed
	+ qed
	+qed
	+
	+lemma deg_sect_insert:
	+ "deg_sect (insert x X) d = (\<Union>d0\<le>d. (+) (Poly_Mapping.single x (d - d0)) ` deg_sect X d0)"
	+ (is "?A = ?B")
	+proof (rule set_eqI)
	+ fix t
	+ show "t \<in> ?A \<longleftrightarrow> t \<in> ?B"
	+ proof
	+ assume "t \<in> ?A"
	+ hence "t \<in> .[insert x X]" and "deg_pm t = d" by (rule deg_sectD)+
	+ from this(1) obtain e tx where "tx \<in> .[X]" and t: "t = Poly_Mapping.single x e + tx"
	+ by (rule PPs_insertE)
	+ have "e + deg_pm tx = deg_pm t" by (simp add: t deg_pm_plus deg_pm_single)
	+ hence "e + deg_pm tx = d" by (simp only: \<open>deg_pm t = d\<close>)
	+ hence "deg_pm tx \<in> {..d}" and e: "e = d - deg_pm tx" by simp_all
	+ from \<open>tx \<in> .[X]\<close> refl have "tx \<in> deg_sect X (deg_pm tx)" by (rule deg_sectI)
	+ hence "t \<in> (+) (Poly_Mapping.single x (d - deg_pm tx)) ` deg_sect X (deg_pm tx)"
	+ unfolding t e by (rule imageI)
	+ with \<open>deg_pm tx \<in> {..d}\<close> show "t \<in> ?B" ..
	+ next
	+ assume "t \<in> ?B"
	+ then obtain d0 where "d0 \<in> {..d}" and "t \<in> (+) (Poly_Mapping.single x (d - d0)) ` deg_sect X d0" ..
	+ from this(2) obtain s where s: "s \<in> deg_sect X d0"
	+ and t: "t = Poly_Mapping.single x (d - d0) + s" (is "t = ?s + s") ..
	+ show "t \<in> ?A"
	+ proof (rule deg_sectI)
	+ have "?s \<in> .[insert x X]" by (rule PPs_closed_single, simp)
	+ from s have "s \<in> .[X]" by (rule deg_sectD)
	+ also have "... \<subseteq> .[insert x X]" by (rule PPs_mono, blast)
	+ finally have "s \<in> .[insert x X]" .
	+ with \<open>?s \<in> .[insert x X]\<close> show "t \<in> .[insert x X]" unfolding t by (rule PPs_closed_plus)
	+ next
	+ from s have "deg_pm s = d0" by (rule deg_sectD)
	+ moreover from \<open>d0 \<in> {..d}\<close> have "d0 \<le> d" by simp
	+ ultimately show "deg_pm t = d" by (simp add: t deg_pm_single deg_pm_plus)
	+ qed
	+ qed
	+qed
	+
	+lemma deg_le_sect_Suc: "deg_le_sect X (Suc d) = deg_le_sect X d \<union> deg_sect X (Suc d)"
	+ by (simp add: deg_le_sect_def atMost_Suc Un_commute)
	+
	+lemma deg_le_sect_Suc_2:
	+ "deg_le_sect X (Suc d) = insert 0 (\<Union>x\<in>X. (+) (Poly_Mapping.single x 1) ` deg_le_sect X d)"
	+ (is "?A = ?B")
	+proof -
	+ have eq1: "{Suc 0..Suc d} = Suc ` {..d}" by (simp add: image_Suc_atMost)
	+ have "insert 0 {1..Suc d} = {..Suc d}" by fastforce
	+ hence "?A = (\<Union>d0\<in>insert 0 {1..Suc d}. deg_sect X d0)" by (simp add: deg_le_sect_def)
	+ also have "... = insert 0 (\<Union>d0\<le>d. deg_sect X (Suc d0))" by (simp add: eq1)
	+ also have "... = insert 0 (\<Union>d0\<le>d. (\<Union>x\<in>X. (+) (Poly_Mapping.single x 1) ` deg_sect X d0))"
	+ by (simp only: deg_sect_Suc)
	+ also have "... = insert 0 (\<Union>x\<in>X. (+) (Poly_Mapping.single x 1) ` (\<Union>d0\<le>d. deg_sect X d0))"
	+ by fastforce
	+ also have "... = ?B" by (simp only: deg_le_sect_def)
	+ finally show ?thesis .
	+qed
	+
	+lemma finite_deg_sect:
	+ assumes "finite X"
	+ shows "finite ((deg_sect X d)::('x::countable \<Rightarrow>\<^sub>0 nat) set)"
	+proof (induct d)
	+ case 0
	+ show ?case by simp
	+next
	+ case (Suc d)
	+ with assms show ?case by (simp add: deg_sect_Suc)
	+qed
	+
	+corollary finite_deg_le_sect: "finite X \<Longrightarrow> finite ((deg_le_sect X d)::('x::countable \<Rightarrow>\<^sub>0 nat) set)"
	+ by (simp add: deg_le_sect_def finite_deg_sect)
	+
	+lemma keys_subset_deg_le_sectI:
	+ assumes "p \<in> P[X]" and "poly_deg p \<le> d"
	+ shows "keys p \<subseteq> deg_le_sect X d"
	+proof
	+ fix t
	+ assume "t \<in> keys p"
	+ also from assms(1) have "... \<subseteq> .[X]" by (rule PolysD)
	+ finally have "t \<in> .[X]" .
	+ from \<open>t \<in> keys p\<close> have "deg_pm t \<le> poly_deg p" by (rule poly_deg_max_keys)
	+ from this assms(2) have "deg_pm t \<le> d" by (rule le_trans)
	+ with \<open>t \<in> .[X]\<close> show "t \<in> deg_le_sect X d" by (rule deg_le_sectI)
	+qed
	+
	+lemma binomial_symmetric_plus: "(n + k) choose n = (n + k) choose k"
	+ by (metis add_diff_cancel_left' binomial_symmetric le_add1)
	+
	+lemma card_deg_sect:
	+ assumes "finite X" and "X \<noteq> {}"
	+ shows "card (deg_sect X d) = (d + (card X - 1)) choose (card X - 1)"
	+ using assms
	+proof (induct X arbitrary: d)
	+ case empty
	+ thus ?case by simp
	+next
	+ case (insert x X)
	+ from insert(1, 2) have eq1: "card (insert x X) = Suc (card X)" by simp
	+ show ?case
	+ proof (cases "X = {}")
	+ case True
	+ thus ?thesis by simp
	+ next
	+ case False
	+ with insert.hyps(1) have "0 < card X" by (simp add: card_gt_0_iff)
	+ let ?f = "\<lambda>d0. Poly_Mapping.single x (d - d0)"
	+ from False have eq2: "card (deg_sect X d0) = d0 + (card X - 1) choose (card X - 1)" for d0
	+ by (rule insert.hyps)
	+ have "finite {..d}" by simp
	+ moreover from insert.hyps(1) have "\<forall>d0\<in>{..d}. finite ((+) (?f d0) ` deg_sect X d0)"
	+ by (simp add: finite_deg_sect)
	+ moreover have "\<forall>d0\<in>{..d}. \<forall>d1\<in>{..d}. d0 \<noteq> d1 \<longrightarrow>
	+ ((+) (?f d0) ` deg_sect X d0) \<inter> ((+) (?f d1) ` deg_sect X d1) = {}"
	+ proof (intro ballI impI, rule ccontr)
	+ fix d1 d2 :: nat
	+ assume "d1 \<noteq> d2"
	+ assume "((+) (?f d1) ` deg_sect X d1) \<inter> ((+) (?f d2) ` deg_sect X d2) \<noteq> {}"
	+ then obtain t where "t \<in> ((+) (?f d1) ` deg_sect X d1) \<inter> ((+) (?f d2) ` deg_sect X d2)"
	+ by blast
	+ hence t1: "t \<in> (+) (?f d1) ` deg_sect X d1" and t2: "t \<in> (+) (?f d2) ` deg_sect X d2" by simp_all
	+ from t1 obtain s1 where "s1 \<in> deg_sect X d1" and s1: "t = ?f d1 + s1" ..
	+ from this(1) have "s1 \<in> .[X]" by (rule deg_sectD)
	+ hence "keys s1 \<subseteq> X" by (rule PPsD)
	+ with insert.hyps(2) have eq3: "lookup s1 x = 0" by (auto simp: in_keys_iff)
	+ from t2 obtain s2 where "s2 \<in> deg_sect X d2" and s2: "t = ?f d2 + s2" ..
	+ from this(1) have "s2 \<in> .[X]" by (rule deg_sectD)
	+ hence "keys s2 \<subseteq> X" by (rule PPsD)
	+ with insert.hyps(2) have eq4: "lookup s2 x = 0" by (auto simp: in_keys_iff)
	+ from s2 have "lookup (?f d1 + s1) x = lookup (?f d2 + s2) x" by (simp only: s1)
	+ hence "d - d1 = d - d2" by (simp add: lookup_add eq3 eq4)
	+ moreover assume "d1 \<in> {..d}" and "d2 \<in> {..d}"
	+ ultimately have "d1 = d2" by simp
	+ with \<open>d1 \<noteq> d2\<close> show False ..
	+ qed
	+ ultimately have "card (deg_sect (insert x X) d) =
	+ (\<Sum>d0\<le>d. card ((+) (monomial (d - d0) x) ` deg_sect X d0))"
	+ unfolding deg_sect_insert by (rule card_UN_disjoint)
	+ also from refl have "... = (\<Sum>d0\<le>d. card (deg_sect X d0))"
	+ proof (rule sum.cong)
	+ fix d0
	+ have "inj_on ((+) (monomial (d - d0) x)) (deg_sect X d0)" by (rule, rule add_left_imp_eq)
	+ thus "card ((+) (monomial (d - d0) x) ` deg_sect X d0) = card (deg_sect X d0)"
	+ by (rule card_image)
	+ qed
	+ also have "... = (\<Sum>d0\<le>d. (card X - 1) + d0 choose (card X - 1))" by (simp only: eq2 add.commute)
	+ also have "... = (\<Sum>d0\<le>d. (card X - 1) + d0 choose d0)" by (simp only: binomial_symmetric_plus)
	+ also have "... = Suc ((card X - 1) + d) choose d" by (rule sum_choose_lower)
	+ also from \<open>0 < card X\<close> have "... = d + (card (insert x X) - 1) choose d"
	+ by (simp add: eq1 add.commute)
	+ also have "... = d + (card (insert x X) - 1) choose (card (insert x X) - 1)"
	+ by (fact binomial_symmetric_plus)
	+ finally show ?thesis .
	+ qed
	+qed
	+
	+corollary card_deg_sect_Suc:
	+ assumes "finite X"
	+ shows "card (deg_sect X (Suc d)) = (d + card X) choose (Suc d)"
	+proof (cases "X = {}")
	+ case True
	+ thus ?thesis by (simp add: deg_sect_empty)
	+next
	+ case False
	+ with assms have "0 < card X" by (simp add: card_gt_0_iff)
	+ from assms False have "card (deg_sect X (Suc d)) = (Suc d + (card X - 1)) choose (card X - 1)"
	+ by (rule card_deg_sect)
	+ also have "... = (Suc d + (card X - 1)) choose (Suc d)" by (rule sym, rule binomial_symmetric_plus)
	+ also from \<open>0 < card X\<close> have "... = (d + card X) choose (Suc d)" by simp
	+ finally show ?thesis .
	+qed
	+
	+corollary card_deg_le_sect:
	+ assumes "finite X"
	+ shows "card (deg_le_sect X d) = (d + card X) choose card X"
	+proof (induct d)
	+ case 0
	+ show ?case by simp
	+next
	+ case (Suc d)
	+ from assms have "finite (deg_le_sect X d)" by (rule finite_deg_le_sect)
	+ moreover from assms have "finite (deg_sect X (Suc d))" by (rule finite_deg_sect)
	+ moreover from lessI have "deg_le_sect X d \<inter> deg_sect X (Suc d) = {}"
	+ by (rule deg_le_sect_deg_sect_disjoint)
	+ ultimately have "card (deg_le_sect X (Suc d)) = card (deg_le_sect X d) + card (deg_sect X (Suc d))"
	+ unfolding deg_le_sect_Suc by (rule card_Un_disjoint)
	+ also from assms have "... = (Suc d + card X) choose Suc d"
	+ by (simp add: Suc.hyps card_deg_sect_Suc binomial_symmetric_plus[of d])
	+ also have "... = (Suc d + card X) choose card X" by (rule binomial_symmetric_plus)
	+ finally show ?case .
	+qed
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Dube_Bound.thy b/thys/Groebner_Macaulay/Dube_Bound.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Dube_Bound.thy
	@@ -0,0 +1,1583 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Dub\'{e}'s Degree-Bound for Homogeneous Gr\"obner Bases\<close>
	+
	+theory Dube_Bound
	+ imports Poly_Fun Cone_Decomposition Degree_Bound_Utils
	+begin
	+
	+context fixes n d :: nat
	+begin
	+
	+function Dube_aux :: "nat \<Rightarrow> nat" where
	+ "Dube_aux j = (if j + 2 < n then
	+ 2 + ((Dube_aux (j + 1)) choose 2) + (\<Sum>i=j+3..n-1. (Dube_aux i) choose (Suc (i - j)))
	+ else if j + 2 = n then d\<^sup>2 + 2 * d else 2 * d)"
	+ by pat_completeness auto
	+termination proof
	+ show "wf (measure ((-) n))" by (fact wf_measure)
	+qed auto
	+
	+definition Dube :: nat where "Dube = (if n \<le> 1 \<or> d = 0 then d else Dube_aux 1)"
	+
	+lemma Dube_aux_ge_d: "d \<le> Dube_aux j"
	+proof (induct j rule: Dube_aux.induct)
	+ case step: (1 j)
	+ have "j + 2 < n \<or> j + 2 = n \<or> n < j + 2" by auto
	+ show ?case
	+ proof (rule linorder_cases)
	+ assume *: "j + 2 < n"
	+ hence 1: "d \<le> Dube_aux (j + 1)"
	+ by (rule step.hyps)+
	+ show ?thesis
	+ proof (cases "d \<le> 2")
	+ case True
	+ also from * have "2 \<le> Dube_aux j" by simp
	+ finally show ?thesis .
	+ next
	+ case False
	+ hence "2 < d" by simp
	+ hence "2 < Dube_aux (j + 1)" using 1 by (rule less_le_trans)
	+ with _ have "Dube_aux (j + 1) \<le> Dube_aux (j + 1) choose 2" by (rule upper_le_binomial) simp
	+ also from * have "\<dots> \<le> Dube_aux j" by simp
	+ finally have "Dube_aux (j + 1) \<le> Dube_aux j" .
	+ with 1 show ?thesis by (rule le_trans)
	+ qed
	+ next
	+ assume "j + 2 = n"
	+ thus ?thesis by simp
	+ next
	+ assume "n < j + 2"
	+ thus ?thesis by simp
	+ qed
	+qed
	+
	+corollary Dube_ge_d: "d \<le> Dube"
	+ by (simp add: Dube_def Dube_aux_ge_d del: Dube_aux.simps)
	+
	+text \<open>Dub\'{e} in @{cite Dube1990} proves the following theorem, to obtain a short closed form for
	+ the degree bound. However, the proof he gives is wrong: In the last-but-one proof step of Lemma 8.1
	+ the sum on the right-hand-side of the inequality can be greater than 1/2 (e.g. for @{prop "n = 7"},
	+ @{prop "d = 2"} and @{prop "j = 1"}), rendering the value inside the big brackets negative. This is
	+ also true without the additional summand \<open>2\<close> we had to introduce in function @{const Dube_aux} to
	+ correct another mistake found in @{cite Dube1990}.
	+ Nonetheless, experiments carried out in Mathematica still suggest that the short closed form is a
	+ valid upper bound for @{const Dube}, even with the additional summand \<open>2\<close>. So, with some effort it
	+ might be possible to prove the theorem below; but in fact function @{const Dube} gives typically
	+ much better (i.e. smaller) values for concrete values of \<open>n\<close> and \<open>d\<close>, so it is better to stick to
	+ @{const Dube} instead of the closed form anyway. Asymptotically, as \<open>n\<close> tends to infinity,
	+ @{const Dube} grows double exponentially, too.\<close>
	+
	+theorem "rat_of_nat Dube \<le> 2 * ((rat_of_nat d)\<^sup>2 / 2 + (rat_of_nat d)) ^ (2 ^ (n - 2))"
	+ oops
	+
	+end
	+
	+subsection \<open>Hilbert Function and Hilbert Polynomial\<close>
	+
	+context pm_powerprod
	+begin
	+
	+context
	+ fixes X :: "'x set"
	+ assumes fin_X: "finite X"
	+begin
	+
	+lemma Hilbert_fun_cone_aux:
	+ assumes "h \<in> P[X]" and "h \<noteq> 0" and "U \<subseteq> X" and "homogeneous (h::_ \<Rightarrow>\<^sub>0 'a::field)"
	+ shows "Hilbert_fun (cone (h, U)) z = card {t \<in> .[U]. deg_pm t + poly_deg h = z}"
	+proof -
	+ from assms(2) have "lpp h \<in> keys h" by (rule punit.lt_in_keys)
	+ with assms(4) have deg_h[symmetric]: "deg_pm (lpp h) = poly_deg h"
	+ by (rule homogeneousD_poly_deg)
	+ from assms(1, 3) have "cone (h, U) \<subseteq> P[X]" by (rule cone_subset_PolysI)
	+ with fin_X have "Hilbert_fun (cone (h, U)) z = card (lpp ` (hom_deg_set z (cone (h, U)) - {0}))"
	+ using subspace_cone[of "(h, U)"] by (simp only: Hilbert_fun_alt)
	+ also from assms(4) have "lpp ` (hom_deg_set z (cone (h, U)) - {0}) =
	+ {t \<in> lpp ` (cone (h, U) - {0}). deg_pm t = z}"
	+ by (intro image_lt_hom_deg_set homogeneous_set_coneI)
	+ also have "{t \<in> lpp ` (cone (h, U) - {0}). deg_pm t = z} =
	+ (\<lambda>t. t + lpp h) ` {t \<in> .[U]. deg_pm t + poly_deg h = z}" (is "?A = ?B")
	+ proof
	+ show "?A \<subseteq> ?B"
	+ proof
	+ fix t
	+ assume "t \<in> ?A"
	+ hence "t \<in> lpp ` (cone (h, U) - {0})" and "deg_pm t = z" by simp_all
	+ from this(1) obtain a where "a \<in> cone (h, U) - {0}" and 2: "t = lpp a" ..
	+ from this(1) have "a \<in> cone (h, U)" and "a \<noteq> 0" by simp_all
	+ from this(1) obtain q where "q \<in> P[U]" and a: "a = q * h" by (rule coneE)
	+ from \<open>a \<noteq> 0\<close> have "q \<noteq> 0" by (auto simp: a)
	+ hence t: "t = lpp q + lpp h" using assms(2) unfolding 2 a by (rule lp_times)
	+ hence "deg_pm (lpp q) + poly_deg h = deg_pm t" by (simp add: deg_pm_plus deg_h)
	+ also have "\<dots> = z" by fact
	+ finally have "deg_pm (lpp q) + poly_deg h = z" .
	+ moreover from \<open>q \<in> P[U]\<close> have "lpp q \<in> .[U]" by (rule PPs_closed_lpp)
	+ ultimately have "lpp q \<in> {t \<in> .[U]. deg_pm t + poly_deg h = z}" by simp
	+ moreover have "t = lpp q + lpp h" by (simp only: t)
	+ ultimately show "t \<in> ?B" by (rule rev_image_eqI)
	+ qed
	+ next
	+ show "?B \<subseteq> ?A"
	+ proof
	+ fix t
	+ assume "t \<in> ?B"
	+ then obtain s where "s \<in> {t \<in> .[U]. deg_pm t + poly_deg h = z}"
	+ and t1: "t = s + lpp h" ..
	+ from this(1) have "s \<in> .[U]" and 1: "deg_pm s + poly_deg h = z" by simp_all
	+ let ?q = "monomial (1::'a) s"
	+ have "?q \<noteq> 0" by (simp add: monomial_0_iff)
	+ hence "?q * h \<noteq> 0" and "lpp (?q * h) = lpp ?q + lpp h" using \<open>h \<noteq> 0\<close>
	+ by (rule times_not_zero, rule lp_times)
	+ hence t: "t = lpp (?q * h)" by (simp add: t1 punit.lt_monomial)
	+ from \<open>s \<in> .[U]\<close> have "?q \<in> P[U]" by (rule Polys_closed_monomial)
	+ with refl have "?q * h \<in> cone (h, U)" by (rule coneI)
	+ moreover from _ assms(2) have "?q * h \<noteq> 0" by (rule times_not_zero) (simp add: monomial_0_iff)
	+ ultimately have "?q * h \<in> cone (h, U) - {0}" by simp
	+ hence "t \<in> lpp ` (cone (h, U) - {0})" unfolding t by (rule imageI)
	+ moreover have "deg_pm t = int z" by (simp add: t1) (simp add: deg_pm_plus deg_h flip: 1)
	+ ultimately show "t \<in> ?A" by simp
	+ qed
	+ qed
	+ also have "card \<dots> = card {t \<in> .[U]. deg_pm t + poly_deg h = z}" by (simp add: card_image)
	+ finally show ?thesis .
	+qed
	+
	+lemma Hilbert_fun_cone_empty:
	+ assumes "h \<in> P[X]" and "h \<noteq> 0" and "homogeneous (h::_ \<Rightarrow>\<^sub>0 'a::field)"
	+ shows "Hilbert_fun (cone (h, {})) z = (if poly_deg h = z then 1 else 0)"
	+proof -
	+ have "Hilbert_fun (cone (h, {})) z = card {t \<in> .[{}::'x set]. deg_pm t + poly_deg h = z}"
	+ using assms(1, 2) empty_subsetI assms(3) by (rule Hilbert_fun_cone_aux)
	+ also have "\<dots> = (if poly_deg h = z then 1 else 0)" by simp
	+ finally show ?thesis .
	+qed
	+
	+lemma Hilbert_fun_cone_nonempty:
	+ assumes "h \<in> P[X]" and "h \<noteq> 0" and "U \<subseteq> X" and "homogeneous (h::_ \<Rightarrow>\<^sub>0 'a::field)" and "U \<noteq> {}"
	+ shows "Hilbert_fun (cone (h, U)) z =
	+ (if poly_deg h \<le> z then ((z - poly_deg h) + (card U - 1)) choose (card U - 1) else 0)"
	+proof (cases "poly_deg h \<le> z")
	+ case True
	+ from assms(3) fin_X have "finite U" by (rule finite_subset)
	+ from assms(1-4) have "Hilbert_fun (cone (h, U)) z = card {t \<in> .[U]. deg_pm t + poly_deg h = z}"
	+ by (rule Hilbert_fun_cone_aux)
	+ also from True have "{t \<in> .[U]. deg_pm t + poly_deg h = z} = deg_sect U (z - poly_deg h)"
	+ by (auto simp: deg_sect_def)
	+ also from \<open>finite U\<close> assms(5) have "card \<dots> = (z - poly_deg h) + (card U - 1) choose (card U - 1)"
	+ by (rule card_deg_sect)
	+ finally show ?thesis by (simp add: True)
	+next
	+ case False
	+ from assms(1-4) have "Hilbert_fun (cone (h, U)) z = card {t \<in> .[U]. deg_pm t + poly_deg h = z}"
	+ by (rule Hilbert_fun_cone_aux)
	+ also from False have "{t \<in> .[U]. deg_pm t + poly_deg h = z} = {}" by auto
	+ hence "card {t \<in> .[U]. deg_pm t + poly_deg h = z} = card ({}::('x \<Rightarrow>\<^sub>0 nat) set)" by (rule arg_cong)
	+ also have "\<dots> = 0" by simp
	+ finally show ?thesis by (simp add: False)
	+qed
	+
	+corollary Hilbert_fun_Polys:
	+ assumes "X \<noteq> {}"
	+ shows "Hilbert_fun (P[X]::(_ \<Rightarrow>\<^sub>0 'a::field) set) z = (z + (card X - 1)) choose (card X - 1)"
	+proof -
	+ let ?one = "1::('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a"
	+ have "Hilbert_fun (P[X]::(_ \<Rightarrow>\<^sub>0 'a) set) z = Hilbert_fun (cone (?one, X)) z" by simp
	+ also have "\<dots> = (if poly_deg ?one \<le> z then ((z - poly_deg ?one) + (card X - 1)) choose (card X - 1) else 0)"
	+ using one_in_Polys _ subset_refl _ assms by (rule Hilbert_fun_cone_nonempty) simp_all
	+ also have "\<dots> = (z + (card X - 1)) choose (card X - 1)" by simp
	+ finally show ?thesis .
	+qed
	+
	+lemma Hilbert_fun_cone_decomp:
	+ assumes "cone_decomp T ps" and "valid_decomp X ps" and "hom_decomp ps"
	+ shows "Hilbert_fun T z = (\<Sum>hU\<in>set ps. Hilbert_fun (cone hU) z)"
	+proof -
	+ note fin_X
	+ moreover from assms(2, 1) have "T \<subseteq> P[X]" by (rule valid_cone_decomp_subset_Polys)
	+ moreover from assms(1) have dd: "direct_decomp T (map cone ps)" by (rule cone_decompD)
	+ ultimately have "Hilbert_fun T z = (\<Sum>s\<in>set (map cone ps). Hilbert_fun s z)"
	+ proof (rule Hilbert_fun_direct_decomp)
	+ fix cn
	+ assume "cn \<in> set (map cone ps)"
	+ then obtain hU where "hU \<in> set ps" and cn: "cn = cone hU" unfolding set_map ..
	+ note this(1)
	+ moreover obtain h U where hU: "hU = (h, U)" using prod.exhaust by blast
	+ ultimately have "(h, U) \<in> set ps" by simp
	+ with assms(3) have "homogeneous h" by (rule hom_decompD)
	+ thus "homogeneous_set cn" unfolding cn hU by (rule homogeneous_set_coneI)
	+ show "phull.subspace cn" unfolding cn by (fact subspace_cone)
	+ qed
	+ also have "\<dots> = (\<Sum>hU\<in>set ps. ((\<lambda>s. Hilbert_fun s z) \<circ> cone) hU)" unfolding set_map using finite_set
	+ proof (rule sum.reindex_nontrivial)
	+ fix hU1 hU2
	+ assume "hU1 \<in> set ps" and "hU2 \<in> set ps" and "hU1 \<noteq> hU2"
	+ with dd have "cone hU1 \<inter> cone hU2 = {0}" using zero_in_cone by (rule direct_decomp_map_Int_zero)
	+ moreover assume "cone hU1 = cone hU2"
	+ ultimately show "Hilbert_fun (cone hU1) z = 0" by simp
	+ qed
	+ finally show ?thesis by simp
	+qed
	+
	+definition Hilbert_poly :: "(nat \<Rightarrow> nat) \<Rightarrow> int \<Rightarrow> int"
	+ where "Hilbert_poly b =
	+ (\<lambda>z::int. let n = card X in
	+ ((z - b (Suc n) + n) gchoose n) - 1 - (\<Sum>i=1..n. (z - b i + i - 1) gchoose i))"
	+
	+lemma poly_fun_Hilbert_poly: "poly_fun (Hilbert_poly b)"
	+ by (simp add: Hilbert_poly_def Let_def)
	+
	+lemma Hilbert_fun_eq_Hilbert_poly_plus_card:
	+ assumes "X \<noteq> {}" and "valid_decomp X ps" and "hom_decomp ps" and "cone_decomp T ps"
	+ and "standard_decomp k ps" and "exact_decomp X 0 ps" and "\<b> ps (Suc 0) \<le> d"
	+ shows "int (Hilbert_fun T d) = card {h::_ \<Rightarrow>\<^sub>0 'a::field. (h, {}) \<in> set ps \<and> poly_deg h = d} + Hilbert_poly (\<b> ps) d"
	+proof -
	+ define n where "n = card X"
	+ with assms(1) have "0 < n" using fin_X by (simp add: card_gt_0_iff)
	+ hence "1 \<le> n" and "Suc 0 \<le> n" by simp_all
	+ from pos_decomp_subset have eq0: "(set ps - set (ps\<^sub>+)) \<union> set (ps\<^sub>+) = set ps" by blast
	+ have "set ps - set (ps\<^sub>+) \<subseteq> set ps" by blast
	+ hence fin2: "finite (set ps - set (ps\<^sub>+))" using finite_set by (rule finite_subset)
	+
	+ have "(\<Sum>hU\<in>set ps - set (ps\<^sub>+). Hilbert_fun (cone hU) d) =
	+ (\<Sum>(h, U)\<in>set ps - set (ps\<^sub>+). if poly_deg h = d then 1 else 0)"
	+ using refl
	+ proof (rule sum.cong)
	+ fix x
	+ assume "x \<in> set ps - set (ps\<^sub>+)"
	+ moreover obtain h U where x: "x = (h, U)" using prod.exhaust by blast
	+ ultimately have "U = {}" and "(h, U) \<in> set ps" by (simp_all add: pos_decomp_def)
	+ from assms(2) this(2) have "h \<in> P[X]" and "h \<noteq> 0" by (rule valid_decompD)+
	+ moreover from assms(3) \<open>(h, U) \<in> set ps\<close> have "homogeneous h" by (rule hom_decompD)
	+ ultimately show "Hilbert_fun (cone x) d = (case x of (h, U) \<Rightarrow> if poly_deg h = d then 1 else 0)"
	+ by (simp add: x \<open>U = {}\<close> Hilbert_fun_cone_empty split del: if_split)
	+ qed
	+ also from fin2 have "\<dots> = (\<Sum>(h, U)\<in>{(h', U') \<in> set ps - set (ps\<^sub>+). poly_deg h' = d}. 1)"
	+ by (rule sum.mono_neutral_cong_right) (auto split: if_splits)
	+ also have "\<dots> = card {(h, U) \<in> set ps - set (ps\<^sub>+). poly_deg h = d}" by auto
	+ also have "\<dots> = card {h. (h, {}) \<in> set ps \<and> poly_deg h = d}" by (fact card_Diff_pos_decomp)
	+ finally have eq1: "(\<Sum>hU\<in>set ps - set (ps\<^sub>+). Hilbert_fun (cone hU) d) =
	+ card {h. (h, {}) \<in> set ps \<and> poly_deg h = d}" .
	+
	+ let ?f = "\<lambda>a b. (int d) - a + b gchoose b"
	+ have "int (\<Sum>hU\<in>set (ps\<^sub>+). Hilbert_fun (cone hU) d) = (\<Sum>hU\<in>set (ps\<^sub>+). int (Hilbert_fun (cone hU) d))"
	+ by (simp add: int_sum prod.case_distrib)
	+ also have "\<dots> = (\<Sum>(h, U)\<in>(\<Union>i\<in>{1..n}. {(h, U) \<in> set (ps\<^sub>+). card U = i}). ?f (poly_deg h) (card U - 1))"
	+ proof (rule sum.cong)
	+ show "set (ps\<^sub>+) = (\<Union>i\<in>{1..n}. {(h, U). (h, U) \<in> set (ps\<^sub>+) \<and> card U = i})"
	+ proof (rule Set.set_eqI, rule)
	+ fix x
	+ assume "x \<in> set (ps\<^sub>+)"
	+ moreover obtain h U where x: "x = (h, U)" using prod.exhaust by blast
	+ ultimately have "(h, U) \<in> set (ps\<^sub>+)" by simp
	+ hence "(h, U) \<in> set ps" and "U \<noteq> {}" by (simp_all add: pos_decomp_def)
	+ from fin_X assms(6) this(1) have "U \<subseteq> X" by (rule exact_decompD)
	+ hence "finite U" using fin_X by (rule finite_subset)
	+ with \<open>U \<noteq> {}\<close> have "0 < card U" by (simp add: card_gt_0_iff)
	+ moreover from fin_X \<open>U \<subseteq> X\<close> have "card U \<le> n" unfolding n_def by (rule card_mono)
	+ ultimately have "card U \<in> {1..n}" by simp
	+ moreover from \<open>(h, U) \<in> set (ps\<^sub>+)\<close> have "(h, U) \<in> {(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> card U' = card U}"
	+ by simp
	+ ultimately show "x \<in> (\<Union>i\<in>{1..n}. {(h, U). (h, U) \<in> set (ps\<^sub>+) \<and> card U = i})" by (simp add: x)
	+ qed blast
	+ next
	+ fix x
	+ assume "x \<in> (\<Union>i\<in>{1..n}. {(h, U). (h, U) \<in> set (ps\<^sub>+) \<and> card U = i})"
	+ then obtain j where "j \<in> {1..n}" and "x \<in> {(h, U). (h, U) \<in> set (ps\<^sub>+) \<and> card U = j}" ..
	+ from this(2) obtain h U where "(h, U) \<in> set (ps\<^sub>+)" and "card U = j" and x: "x = (h, U)" by blast
	+ from fin_X assms(2, 5) this(1) have "poly_deg h < \<b> ps (Suc 0)" by (rule \<b>_one_gr)
	+ also have "\<dots> \<le> d" by fact
	+ finally have "poly_deg h < d" .
	+ hence int1: "int (d - poly_deg h) = int d - int (poly_deg h)" by simp
	+ from \<open>card U = j\<close> \<open>j \<in> {1..n}\<close> have "0 < card U" by simp
	+ hence int2: "int (card U - Suc 0) = int (card U) - 1" by simp
	+ from \<open>(h, U) \<in> set (ps\<^sub>+)\<close> have "(h, U) \<in> set ps" using pos_decomp_subset ..
	+ with assms(2) have "h \<in> P[X]" and "h \<noteq> 0" and "U \<subseteq> X" by (rule valid_decompD)+
	+ moreover from assms(3) \<open>(h, U) \<in> set ps\<close> have "homogeneous h" by (rule hom_decompD)
	+ moreover from \<open>0 < card U\<close> have "U \<noteq> {}" by auto
	+ ultimately have "Hilbert_fun (cone (h, U)) d =
	+ (if poly_deg h \<le> d then (d - poly_deg h + (card U - 1)) choose (card U - 1) else 0)"
	+ by (rule Hilbert_fun_cone_nonempty)
	+ also from \<open>poly_deg h < d\<close> have "\<dots> = (d - poly_deg h + (card U - 1)) choose (card U - 1)" by simp
	+ finally
	+ have "int (Hilbert_fun (cone (h, U)) d) = (int d - int (poly_deg h) + (int (card U - 1))) gchoose (card U - 1)"
	+ by (simp add: int_binomial int1 int2)
	+ thus "int (Hilbert_fun (cone x) d) =
	+ (case x of (h, U) \<Rightarrow> int d - int (poly_deg h) + (int (card U - 1)) gchoose (card U - 1))"
	+ by (simp add: x)
	+ qed
	+ also have "\<dots> = (\<Sum>j=1..n. \<Sum>(h, U)\<in>{(h', U') \<in> set (ps\<^sub>+). card U' = j}. ?f (poly_deg h) (card U - 1))"
	+ proof (intro sum.UNION_disjoint ballI)
	+ fix j
	+ have "{(h, U). (h, U) \<in> set (ps\<^sub>+) \<and> card U = j} \<subseteq> set (ps\<^sub>+)" by blast
	+ thus "finite {(h, U). (h, U) \<in> set (ps\<^sub>+) \<and> card U = j}" using finite_set by (rule finite_subset)
	+ qed blast+
	+ also from refl have "\<dots> = (\<Sum>j=1..n. ?f (\<b> ps (Suc j)) j - ?f (\<b> ps j) j)"
	+ proof (rule sum.cong)
	+ fix j
	+ assume "j \<in> {1..n}"
	+ hence "Suc 0 \<le> j" and "0 < j" and "j \<le> n" by simp_all
	+ from fin_X this(1) have "\<b> ps j \<le> \<b> ps (Suc 0)" by (rule \<b>_decreasing)
	+ also have "\<dots> \<le> d" by fact
	+ finally have "\<b> ps j \<le> d" .
	+ from fin_X have "\<b> ps (Suc j) \<le> \<b> ps j" by (rule \<b>_decreasing) simp
	+ hence "\<b> ps (Suc j) \<le> d" using \<open>\<b> ps j \<le> d\<close> by (rule le_trans)
	+ from \<open>0 < j\<close> have int_j: "int (j - Suc 0) = int j - 1" by simp
	+ have "(\<Sum>(h, U)\<in>{(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> card U' = j}. ?f (poly_deg h) (card U - 1)) =
	+ (\<Sum>(h, U)\<in>(\<Union>d0\<in>{\<b> ps (Suc j)..int (\<b> ps j) - 1}. {(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> int (poly_deg h') = d0 \<and> card U' = j}).
	+ ?f (poly_deg h) (card U - 1))"
	+ using _ refl
	+ proof (rule sum.cong)
	+ show "{(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> card U' = j} =
	+ (\<Union>d0\<in>{\<b> ps (Suc j)..int (\<b> ps j) - 1}. {(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> int (poly_deg h') = d0 \<and> card U' = j})"
	+ proof (rule Set.set_eqI, rule)
	+ fix x
	+ assume "x \<in> {(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> card U' = j}"
	+ moreover obtain h U where x: "x = (h, U)" using prod.exhaust by blast
	+ ultimately have "(h, U) \<in> set (ps\<^sub>+)" and "card U = j" by simp_all
	+ with fin_X assms(5, 6) \<open>Suc 0 \<le> j\<close> \<open>j \<le> n\<close> have "\<b> ps (Suc j) \<le> poly_deg h"
	+ unfolding n_def by (rule lem_6_1_3)
	+ moreover from fin_X have "poly_deg h < \<b> ps j"
	+ proof (rule \<b>)
	+ from \<open>(h, U) \<in> set (ps\<^sub>+)\<close> show "(h, U) \<in> set ps" using pos_decomp_subset ..
	+ next
	+ show "j \<le> card U" by (simp add: \<open>card U = j\<close>)
	+ qed
	+ ultimately have "poly_deg h \<in> {\<b> ps (Suc j)..int (\<b> ps j) - 1}" by simp
	+ moreover have "(h, U) \<in> {(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = poly_deg h \<and> card U' = card U}"
	+ using \<open>(h, U) \<in> set (ps\<^sub>+)\<close> by simp
	+ ultimately show "x \<in> (\<Union>d0\<in>{\<b> ps (Suc j)..int (\<b> ps j) - 1}.
	+ {(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> int (poly_deg h') = d0 \<and> card U' = j})"
	+ by (simp add: x \<open>card U = j\<close>)
	+ qed blast
	+ qed
	+ also have "\<dots> = (\<Sum>d0=\<b> ps (Suc j)..int (\<b> ps j) - 1.
	+ \<Sum>(h, U)\<in>{(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = d0 \<and> card U' = j}.
	+ ?f (poly_deg h) (card U - 1))"
	+ proof (intro sum.UNION_disjoint ballI)
	+ fix d0::int
	+ have "{(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = d0 \<and> card U' = j} \<subseteq> set (ps\<^sub>+)" by blast
	+ thus "finite {(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = d0 \<and> card U' = j}"
	+ using finite_set by (rule finite_subset)
	+ qed blast+
	+ also from refl have "\<dots> = (\<Sum>d0=\<b> ps (Suc j)..int (\<b> ps j) - 1. ?f d0 (j - 1))"
	+ proof (rule sum.cong)
	+ fix d0
	+ assume "d0 \<in> {\<b> ps (Suc j)..int (\<b> ps j) - 1}"
	+ hence "\<b> ps (Suc j) \<le> d0" and "d0 < int (\<b> ps j)" by simp_all
	+ hence "\<b> ps (Suc j) \<le> nat d0" and "nat d0 < \<b> ps j" by simp_all
	+ have "(\<Sum>(h, U)\<in>{(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = d0 \<and> card U' = j}. ?f (poly_deg h) (card U - 1)) =
	+ (\<Sum>(h, U)\<in>{(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = d0 \<and> card U' = j}. ?f d0 (j - 1))"
	+ using refl by (rule sum.cong) auto
	+ also have "\<dots> = card {(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = nat d0 \<and> card U' = j} * ?f d0 (j - 1)"
	+ using \<open>\<b> ps (Suc j) \<le> d0\<close> by (simp add: int_eq_iff)
	+ also have "\<dots> = ?f d0 (j - 1)"
	+ using fin_X assms(5, 6) \<open>Suc 0 \<le> j\<close> \<open>j \<le> n\<close> \<open>\<b> ps (Suc j) \<le> nat d0\<close> \<open>nat d0 < \<b> ps j\<close>
	+ by (simp only: n_def lem_6_1_2'(3))
	+ finally show "(\<Sum>(h, U)\<in>{(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> poly_deg h' = d0 \<and> card U' = j}.
	+ ?f (poly_deg h) (card U - 1)) = ?f d0 (j - 1)" .
	+ qed
	+ also have "\<dots> = (\<Sum>d0\<in>(-) (int d) ` {\<b> ps (Suc j)..int (\<b> ps j) - 1}. d0 + int (j - 1) gchoose (j - 1))"
	+ proof -
	+ have "inj_on ((-) (int d)) {\<b> ps (Suc j)..int (\<b> ps j) - 1}" by (auto simp: inj_on_def)
	+ thus ?thesis by (simp only: sum.reindex o_def)
	+ qed
	+ also have "\<dots> = (\<Sum>d0\<in>{0..int d - (\<b> ps (Suc j))}-{0..int d - \<b> ps j}. d0 + int (j - 1) gchoose (j - 1))"
	+ using _ refl
	+ proof (rule sum.cong)
	+ have "(-) (int d) ` {\<b> ps (Suc j)..int (\<b> ps j) - 1} = {int d - (int (\<b> ps j) - 1)..int d - int (\<b> ps (Suc j))}"
	+ by (simp only: image_diff_atLeastAtMost)
	+ also have "\<dots> = {0..int d - int (\<b> ps (Suc j))} - {0..int d - int (\<b> ps j)}"
	+ proof -
	+ from \<open>\<b> ps j \<le> d\<close> have "int (\<b> ps j) - 1 \<le> int d" by simp
	+ thus ?thesis by auto
	+ qed
	+ finally show "(-) (int d) ` {\<b> ps (Suc j)..int (\<b> ps j) - 1} =
	+ {0..int d - int (\<b> ps (Suc j))} - {0..int d - int (\<b> ps j)}" .
	+ qed
	+ also have "\<dots> = (\<Sum>d0=0..int d - (\<b> ps (Suc j)). d0 + int (j - 1) gchoose (j - 1)) -
	+ (\<Sum>d0=0..int d - \<b> ps j. d0 + int (j - 1) gchoose (j - 1))"
	+ by (rule sum_diff) (auto simp: \<open>\<b> ps (Suc j) \<le> \<b> ps j\<close>)
	+ also from \<open>\<b> ps (Suc j) \<le> d\<close> \<open>\<b> ps j \<le> d\<close> have "\<dots> = ?f (\<b> ps (Suc j)) j - ?f (\<b> ps j) j"
	+ by (simp add: gchoose_rising_sum, simp add: int_j ac_simps \<open>0 < j\<close>)
	+ finally show "(\<Sum>(h, U)\<in>{(h', U'). (h', U') \<in> set (ps\<^sub>+) \<and> card U' = j}. ?f (poly_deg h) (card U - 1)) =
	+ ?f (\<b> ps (Suc j)) j - ?f (\<b> ps j) j" .
	+ qed
	+ also have "\<dots> = (\<Sum>j=1..n. ?f (\<b> ps (Suc j)) j) - (\<Sum>j=1..n. ?f (\<b> ps j) j)"
	+ by (fact sum_subtractf)
	+ also have "\<dots> = ?f (\<b> ps (Suc n)) n + (\<Sum>j=1..n-1. ?f (\<b> ps (Suc j)) j) - (\<Sum>j=1..n. ?f (\<b> ps j) j)"
	+ by (simp only: sum_tail_nat[OF \<open>0 < n\<close> \<open>1 \<le> n\<close>])
	+ also have "\<dots> = ?f (\<b> ps (Suc n)) n - ?f (\<b> ps 1) 1 +
	+ ((\<Sum>j=1..n-1. ?f (\<b> ps (Suc j)) j) - (\<Sum>j=1..n-1. ?f (\<b> ps (Suc j)) (Suc j)))"
	+ by (simp only: sum.atLeast_Suc_atMost[OF \<open>1 \<le> n\<close>] sum_atLeast_Suc_shift[OF \<open>0 < n\<close> \<open>1 \<le> n\<close>])
	+ also have "\<dots> = ?f (\<b> ps (Suc n)) n - ?f (\<b> ps 1) 1 -
	+ (\<Sum>j=1..n-1. ?f (\<b> ps (Suc j)) (Suc j) - ?f (\<b> ps (Suc j)) j)"
	+ by (simp only: sum_subtractf)
	+ also have "\<dots> = ?f (\<b> ps (Suc n)) n - 1 - ((int d - \<b> ps (Suc 0)) gchoose (Suc 0)) -
	+ (\<Sum>j=1..n-1. (int d - \<b> ps (Suc j) + j) gchoose (Suc j))"
	+ proof -
	+ have "?f (\<b> ps 1) 1 = 1 + ((int d - \<b> ps (Suc 0)) gchoose (Suc 0))"
	+ by (simp add: plus_Suc_gbinomial)
	+ moreover from refl have "(\<Sum>j=1..n-1. ?f (\<b> ps (Suc j)) (Suc j) - ?f (\<b> ps (Suc j)) j) =
	+ (\<Sum>j=1..n-1. (int d - \<b> ps (Suc j) + j) gchoose (Suc j))"
	+ by (rule sum.cong) (simp add: plus_Suc_gbinomial)
	+ ultimately show ?thesis by (simp only:)
	+ qed
	+ also have "\<dots> = ?f (\<b> ps (Suc n)) n - 1 - (\<Sum>j=0..n-1. (int d - \<b> ps (Suc j) + j) gchoose (Suc j))"
	+ by (simp only: sum.atLeast_Suc_atMost[OF le0], simp)
	+ also have "\<dots> = ?f (\<b> ps (Suc n)) n - 1 - (\<Sum>j=Suc 0..Suc (n-1). (int d - \<b> ps j + j - 1) gchoose j)"
	+ by (simp only: sum.shift_bounds_cl_Suc_ivl, simp add: ac_simps)
	+ also have "\<dots> = Hilbert_poly (\<b> ps) d" using \<open>0 < n\<close> by (simp add: Hilbert_poly_def Let_def n_def)
	+ finally have eq2: "int (\<Sum>hU\<in>set (ps\<^sub>+). Hilbert_fun (cone hU) d) = Hilbert_poly (\<b> ps) (int d)" .
	+
	+ from assms(4, 2, 3) have "Hilbert_fun T d = (\<Sum>hU\<in>set ps. Hilbert_fun (cone hU) d)"
	+ by (rule Hilbert_fun_cone_decomp)
	+ also have "\<dots> = (\<Sum>hU\<in>(set ps - set (ps\<^sub>+)) \<union> set (ps\<^sub>+). Hilbert_fun (cone hU) d)" by (simp only: eq0)
	+ also have "\<dots> = (\<Sum>hU\<in>set ps - set (ps\<^sub>+). Hilbert_fun (cone hU) d) + (\<Sum>hU\<in>set (ps\<^sub>+). Hilbert_fun (cone hU) d)"
	+ using fin2 finite_set by (rule sum.union_disjoint) blast
	+ also have "\<dots> = card {h. (h, {}) \<in> set ps \<and> poly_deg h = d} + (\<Sum>hU\<in>set (ps\<^sub>+). Hilbert_fun (cone hU) d)"
	+ by (simp only: eq1)
	+ also have "int \<dots> = card {h. (h, {}) \<in> set ps \<and> poly_deg h = d} + Hilbert_poly (\<b> ps) d"
	+ by (simp only: eq2 int_plus)
	+ finally show ?thesis .
	+qed
	+
	+corollary Hilbert_fun_eq_Hilbert_poly:
	+ assumes "X \<noteq> {}" and "valid_decomp X ps" and "hom_decomp ps" and "cone_decomp T ps"
	+ and "standard_decomp k ps" and "exact_decomp X 0 ps" and "\<b> ps 0 \<le> d"
	+ shows "int (Hilbert_fun (T::(_ \<Rightarrow>\<^sub>0 'a::field) set) d) = Hilbert_poly (\<b> ps) d"
	+proof -
	+ from fin_X have "\<b> ps (Suc 0) \<le> \<b> ps 0" using le0 by (rule \<b>_decreasing)
	+ also have "\<dots> \<le> d" by fact
	+ finally have "\<b> ps (Suc 0) \<le> d" .
	+ with assms(1-6) have "int (Hilbert_fun T d) =
	+ int (card {h. (h, {}) \<in> set ps \<and> poly_deg h = d}) + Hilbert_poly (\<b> ps) (int d)"
	+ by (rule Hilbert_fun_eq_Hilbert_poly_plus_card)
	+ also have "\<dots> = Hilbert_poly (\<b> ps) (int d)"
	+ proof -
	+ have eq: "{h. (h, {}) \<in> set ps \<and> poly_deg h = d} = {}"
	+ proof -
	+ {
	+ fix h
	+ assume "(h, {}) \<in> set ps" and "poly_deg h = d"
	+ from fin_X this(1) le0 have "poly_deg h < \<b> ps 0" by (rule \<b>)
	+ with assms(7) have False by (simp add: \<open>poly_deg h = d\<close>)
	+ }
	+ thus ?thesis by blast
	+ qed
	+ show ?thesis by (simp add: eq)
	+ qed
	+ finally show ?thesis .
	+qed
	+
	+subsection \<open>Dub\'{e}'s Bound\<close>
	+
	+context
	+ fixes f :: "('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::field"
	+ fixes F
	+ assumes n_gr_1: "1 < card X" and fin_F: "finite F" and F_sub: "F \<subseteq> P[X]" and f_in: "f \<in> F"
	+ and hom_F: "\<And>f'. f' \<in> F \<Longrightarrow> homogeneous f'" and f_max: "\<And>f'. f' \<in> F \<Longrightarrow> poly_deg f' \<le> poly_deg f"
	+ and d_gr_0: "0 < poly_deg f" and ideal_f_neq: "ideal {f} \<noteq> ideal F"
	+begin
	+
	+private abbreviation (input) "n \<equiv> card X"
	+private abbreviation (input) "d \<equiv> poly_deg f"
	+
	+lemma f_in_Polys: "f \<in> P[X]"
	+ using f_in F_sub ..
	+
	+lemma hom_f: "homogeneous f"
	+ using f_in by (rule hom_F)
	+
	+lemma f_not_0: "f \<noteq> 0"
	+ using d_gr_0 by auto
	+
	+lemma X_not_empty: "X \<noteq> {}"
	+ using n_gr_1 by auto
	+
	+lemma n_gr_0: "0 < n"
	+ using \<open>1 < n\<close> by simp
	+
	+corollary int_n_minus_1 [simp]: "int (n - Suc 0) = int n - 1"
	+ using n_gr_0 by simp
	+
	+lemma int_n_minus_2 [simp]: "int (n - Suc (Suc 0)) = int n - 2"
	+ using n_gr_1 by simp
	+
	+lemma cone_f_X_sub: "cone (f, X) \<subseteq> P[X]"
	+proof -
	+ have "cone (f, X) = cone (f * 1, X)" by simp
	+ also from f_in_Polys have "\<dots> \<subseteq> cone (1, X)" by (rule cone_mono_1)
	+ finally show ?thesis by simp
	+qed
	+
	+lemma ideal_Int_Polys_eq_cone: "ideal {f} \<inter> P[X] = cone (f, X)"
	+proof (intro subset_antisym subsetI)
	+ fix p
	+ assume "p \<in> ideal {f} \<inter> P[X]"
	+ hence "p \<in> ideal {f}" and "p \<in> P[X]" by simp_all
	+ have "finite {f}" by simp
	+ then obtain q where "p = (\<Sum>f'\<in>{f}. q f' * f')" using \<open>p \<in> ideal {f}\<close>
	+ by (rule ideal.span_finiteE)
	+ hence p: "p = q f * f" by simp
	+ with \<open>p \<in> P[X]\<close> have "f * q f \<in> P[X]" by (simp only: mult.commute)
	+ hence "q f \<in> P[X]" using f_in_Polys f_not_0 by (rule times_in_PolysD)
	+ with p show "p \<in> cone (f, X)" by (rule coneI)
	+next
	+ fix p
	+ assume "p \<in> cone (f, X)"
	+ then obtain q where "q \<in> P[X]" and p: "p = q * f" by (rule coneE)
	+ have "f \<in> ideal {f}" by (rule ideal.span_base) simp
	+ with \<open>q \<in> P[X]\<close> f_in_Polys show "p \<in> ideal {f} \<inter> P[X]"
	+ unfolding p by (intro IntI ideal.span_scale Polys_closed_times)
	+qed
	+
	+private definition P_ps where
	+ "P_ps = (SOME x. valid_decomp X (snd x) \<and> standard_decomp d (snd x) \<and>
	+ exact_decomp X 0 (snd x) \<and> cone_decomp (fst x) (snd x) \<and> hom_decomp (snd x) \<and>
	+ direct_decomp (ideal F \<inter> P[X]) [ideal {f} \<inter> P[X], fst x])"
	+
	+private definition P where "P = fst P_ps"
	+
	+private definition ps where "ps = snd P_ps"
	+
	+lemma
	+ shows valid_ps: "valid_decomp X ps" (is ?thesis1)
	+ and std_ps: "standard_decomp d ps" (is ?thesis2)
	+ and ext_ps: "exact_decomp X 0 ps" (is ?thesis3)
	+ and cn_ps: "cone_decomp P ps" (is ?thesis4)
	+ and hom_ps: "hom_decomp ps" (is ?thesis5)
	+ and decomp_F: "direct_decomp (ideal F \<inter> P[X]) [ideal {f} \<inter> P[X], P]" (is ?thesis6)
	+proof -
	+ note fin_X
	+ moreover from fin_F have "finite (F - {f})" by simp
	+ moreover from F_sub have "F - {f} \<subseteq> P[X]" by blast
	+ ultimately obtain P' ps' where 1: "valid_decomp X ps'" and 2: "standard_decomp d ps'"
	+ and 3: "cone_decomp P' ps'" and 40: "(\<And>f'. f' \<in> F - {f} \<Longrightarrow> homogeneous f') \<Longrightarrow> hom_decomp ps'"
	+ and 50: "direct_decomp (ideal (insert f (F - {f})) \<inter> P[X]) [ideal {f} \<inter> P[X], P']"
	+ using f_in_Polys f_max by (rule ideal_decompE) blast+
	+ have 4: "hom_decomp ps'" by (intro 40 hom_F) simp
	+ from 50 f_in have 5: "direct_decomp (ideal F \<inter> P[X]) [ideal {f} \<inter> P[X], P']"
	+ by (simp add: insert_absorb)
	+ let ?ps = "exact X (poly_deg f) ps'"
	+ from fin_X 1 2 have "valid_decomp X ?ps" and "standard_decomp d ?ps" and "exact_decomp X 0 ?ps"
	+ by (rule exact)+
	+ moreover from fin_X 1 2 3 have "cone_decomp P' ?ps" by (rule cone_decomp_exact)
	+ moreover from fin_X 1 2 4 have "hom_decomp ?ps" by (rule hom_decomp_exact)
	+ ultimately have "valid_decomp X (snd (P', ?ps)) \<and> standard_decomp d (snd (P', ?ps)) \<and>
	+ exact_decomp X 0 (snd (P', ?ps)) \<and> cone_decomp (fst (P', ?ps)) (snd (P', ?ps)) \<and>
	+ hom_decomp (snd (P', ?ps)) \<and>
	+ direct_decomp (ideal F \<inter> P[X]) [ideal {f} \<inter> P[X], fst (P', ?ps)]"
	+ using 5 by simp
	+ hence "?thesis1 \<and> ?thesis2 \<and> ?thesis3 \<and> ?thesis4 \<and> ?thesis5 \<and> ?thesis6"
	+ unfolding P_def ps_def P_ps_def by (rule someI)
	+ thus ?thesis1 and ?thesis2 and ?thesis3 and ?thesis4 and ?thesis5 and ?thesis6 by simp_all
	+qed
	+
	+lemma P_sub: "P \<subseteq> P[X]"
	+ using valid_ps cn_ps by (rule valid_cone_decomp_subset_Polys)
	+
	+lemma ps_not_Nil: "ps\<^sub>+ \<noteq> []"
	+proof
	+ assume "ps\<^sub>+ = []"
	+ have "Keys P \<subseteq> (\<Union>hU\<in>set ps. keys (fst hU))" (is "_ \<subseteq> ?A")
	+ proof
	+ fix t
	+ assume "t \<in> Keys P"
	+ then obtain p where "p \<in> P" and "t \<in> keys p" by (rule in_KeysE)
	+ from cn_ps have "direct_decomp P (map cone ps)" by (rule cone_decompD)
	+ then obtain qs where qs: "qs \<in> listset (map cone ps)" and p: "p = sum_list qs" using \<open>p \<in> P\<close>
	+ by (rule direct_decompE)
	+ from \<open>t \<in> keys p\<close> keys_sum_list_subset have "t \<in> Keys (set qs)" unfolding p ..
	+ then obtain q where "q \<in> set qs" and "t \<in> keys q" by (rule in_KeysE)
	+ from this(1) obtain i where "i < length qs" and "q = qs ! i" by (metis in_set_conv_nth)
	+ with qs have "i < length ps" and "q \<in> (map cone ps) ! i" by (simp_all add: listsetD del: nth_map)
	+ hence "q \<in> cone (ps ! i)" by simp
	+ obtain h U where eq: "ps ! i = (h, U)" using prod.exhaust by blast
	+ from \<open>i < length ps\<close> this[symmetric] have "(h, U) \<in> set ps" by simp
	+ have "U = {}"
	+ proof (rule ccontr)
	+ assume "U \<noteq> {}"
	+ with \<open>(h, U) \<in> set ps\<close> have "(h, U) \<in> set (ps\<^sub>+)" by (simp add: pos_decomp_def)
	+ with \<open>ps\<^sub>+ = []\<close> show False by simp
	+ qed
	+ with \<open>q \<in> cone (ps ! i)\<close> have "q \<in> range (\<lambda>c. c \<cdot> h)" by (simp only: eq cone_empty)
	+ then obtain c where "q = c \<cdot> h" ..
	+ also have "keys \<dots> \<subseteq> keys h" by (fact keys_map_scale_subset)
	+ finally have "t \<in> keys h" using \<open>t \<in> keys q\<close> ..
	+ hence "t \<in> keys (fst (h, U))" by simp
	+ with \<open>(h, U) \<in> set ps\<close> show "t \<in> ?A" ..
	+ qed
	+ moreover from finite_set finite_keys have "finite ?A" by (rule finite_UN_I)
	+ ultimately have "finite (Keys P)" by (rule finite_subset)
	+
	+ have "\<exists>q\<in>ideal F. q \<in> P[X] \<and> q \<noteq> 0 \<and> \<not> lpp f adds lpp q"
	+ proof (rule ccontr)
	+ assume "\<not> (\<exists>q\<in>ideal F. q \<in> P[X] \<and> q \<noteq> 0 \<and> \<not> lpp f adds lpp q)"
	+ hence adds: "lpp f adds lpp q" if "q \<in> ideal F" and "q \<in> P[X]" and "q \<noteq> 0" for q
	+ using that by blast
	+ from fin_X _ F_sub have "ideal {f} = ideal F"
	+ proof (rule punit.pmdl_eqI_adds_lt_dgrad_p_set[simplified, OF dickson_grading_varnum,
	+ where m=0, simplified dgrad_p_set_varnum])
	+ from f_in_Polys show "{f} \<subseteq> P[X]" by simp
	+ next
	+ from f_in have "{f} \<subseteq> F" by simp
	+ thus "ideal {f} \<subseteq> ideal F" by (rule ideal.span_mono)
	+ next
	+ fix q
	+ assume "q \<in> ideal F" and "q \<in> P[X]" and "q \<noteq> 0"
	+ hence "lpp f adds lpp q" by (rule adds)
	+ with f_not_0 show "\<exists>g\<in>{f}. g \<noteq> 0 \<and> lpp g adds lpp q" by blast
	+ qed
	+ with ideal_f_neq show False ..
	+ qed
	+ then obtain q0 where "q0 \<in> ideal F" and "q0 \<in> P[X]" and "q0 \<noteq> 0"
	+ and nadds_q0: "\<not> lpp f adds lpp q0" by blast
	+ define q where "q = hom_component q0 (deg_pm (lpp q0))"
	+ from hom_F \<open>q0 \<in> ideal F\<close> have "q \<in> ideal F" unfolding q_def by (rule homogeneous_ideal)
	+ from homogeneous_set_Polys \<open>q0 \<in> P[X]\<close> have "q \<in> P[X]" unfolding q_def by (rule homogeneous_setD)
	+ from \<open>q0 \<noteq> 0\<close> have "q \<noteq> 0" and "lpp q = lpp q0" unfolding q_def by (rule hom_component_lpp)+
	+ from nadds_q0 this(2) have nadds_q: "\<not> lpp f adds lpp q" by simp
	+ have hom_q: "homogeneous q" by (simp only: q_def homogeneous_hom_component)
	+ from nadds_q obtain x where x: "\<not> lookup (lpp f) x \<le> lookup (lpp q) x"
	+ by (auto simp add: adds_poly_mapping le_fun_def)
	+ obtain y where "y \<in> X" and "y \<noteq> x"
	+ proof -
	+ from n_gr_1 have "2 \<le> n" by simp
	+ then obtain Y where "Y \<subseteq> X" and "card Y = 2" by (rule card_geq_ex_subset)
	+ from this(2) obtain u v where "u \<noteq> v" and "Y = {u, v}" by (rule card_2_E)
	+ from this obtain y where "y \<in> Y" and "y \<noteq> x" by blast
	+ from this(1) \<open>Y \<subseteq> X\<close> have "y \<in> X" ..
	+ thus ?thesis using \<open>y \<noteq> x\<close> ..
	+ qed
	+ define q' where "q' = (\<lambda>k. punit.monom_mult 1 (Poly_Mapping.single y k) q)"
	+ have inj1: "inj q'" by (auto intro!: injI simp: q'_def \<open>q \<noteq> 0\<close> dest: punit.monom_mult_inj_2 monomial_inj)
	+ have q'_in: "q' k \<in> ideal F \<inter> P[X]" for k unfolding q'_def using \<open>q \<in> ideal F\<close> \<open>q \<in> P[X]\<close> \<open>y \<in> X\<close>
	+ by (intro IntI punit.pmdl_closed_monom_mult[simplified] Polys_closed_monom_mult PPs_closed_single)
	+ have lpp_q': "lpp (q' k) = Poly_Mapping.single y k + lpp q" for k
	+ using \<open>q \<noteq> 0\<close> by (simp add: q'_def punit.lt_monom_mult)
	+ have inj2: "inj_on (deg_pm \<circ> lpp) (range q')"
	+ by (auto intro!: inj_onI simp: lpp_q' deg_pm_plus deg_pm_single dest: monomial_inj)
	+ have "(deg_pm \<circ> lpp) ` range q' \<subseteq> deg_pm ` Keys P"
	+ proof
	+ fix d
	+ assume "d \<in> (deg_pm \<circ> lpp) ` range q'"
	+ then obtain k where d: "d = deg_pm (lpp (q' k))" (is "_ = deg_pm ?t") by auto
	+ from hom_q have hom_q': "homogeneous (q' k)" by (simp add: q'_def homogeneous_monom_mult)
	+ from \<open>q \<noteq> 0\<close> have "q' k \<noteq> 0" by (simp add: q'_def punit.monom_mult_eq_zero_iff)
	+ hence "?t \<in> keys (q' k)" by (rule punit.lt_in_keys)
	+ with hom_q' have deg_q': "d = poly_deg (q' k)" unfolding d by (rule homogeneousD_poly_deg)
	+ from decomp_F q'_in obtain qs where "qs \<in> listset [ideal {f} \<inter> P[X], P]" and "q' k = sum_list qs"
	+ by (rule direct_decompE)
	+ moreover from this(1) obtain f0 p0 where f0: "f0 \<in> ideal {f} \<inter> P[X]" and p0: "p0 \<in> P"
	+ and "qs = [f0, p0]" by (rule listset_doubletonE)
	+ ultimately have q': "q' k = f0 + p0" by simp
	+ define f1 where "f1 = hom_component f0 d"
	+ define p1 where "p1 = hom_component p0 d"
	+ from hom_q have "homogeneous (q' k)" by (simp add: q'_def homogeneous_monom_mult)
	+ hence "q' k = hom_component (q' k) d" by (simp add: hom_component_of_homogeneous deg_q')
	+ also have "\<dots> = f1 + p1" by (simp only: q' hom_component_plus f1_def p1_def)
	+ finally have "q' k = f1 + p1" .
	+ have "keys p1 \<noteq> {}"
	+ proof
	+ assume "keys p1 = {}"
	+ with \<open>q' k = f1 + p1\<close> \<open>q' k \<noteq> 0\<close> have t: "?t = lpp f1" and "f1 \<noteq> 0" by simp_all
	+ from f0 have "f0 \<in> ideal {f}" by simp
	+ with _ have "f1 \<in> ideal {f}" unfolding f1_def by (rule homogeneous_ideal) (simp add: hom_f)
	+ with punit.is_Groebner_basis_singleton obtain g where "g \<in> {f}" and "lpp g adds lpp f1"
	+ using \<open>f1 \<noteq> 0\<close> by (rule punit.GB_adds_lt[simplified])
	+ hence "lpp f adds ?t" by (simp add: t)
	+ hence "lookup (lpp f) x \<le> lookup ?t x" by (simp add: adds_poly_mapping le_fun_def)
	+ also have "\<dots> = lookup (lpp q) x" by (simp add: lpp_q' lookup_add lookup_single \<open>y \<noteq> x\<close>)
	+ finally have "lookup (lpp f) x \<le> lookup (lpp q) x" .
	+ with x show False ..
	+ qed
	+ then obtain t where "t \<in> keys p1" by blast
	+ hence "d = deg_pm t" by (simp add: p1_def keys_hom_component)
	+ from cn_ps hom_ps have "homogeneous_set P" by (intro homogeneous_set_cone_decomp)
	+ hence "p1 \<in> P" using \<open>p0 \<in> P\<close> unfolding p1_def by (rule homogeneous_setD)
	+ with \<open>t \<in> keys p1\<close> have "t \<in> Keys P" by (rule in_KeysI)
	+ with \<open>d = deg_pm t\<close> show "d \<in> deg_pm ` Keys P" by (rule image_eqI)
	+ qed
	+ moreover from inj1 inj2 have "infinite ((deg_pm \<circ> lpp) ` range q')"
	+ by (simp add: finite_image_iff o_def)
	+ ultimately have "infinite (deg_pm ` Keys P)" by (rule infinite_super)
	+ hence "infinite (Keys P)" by blast
	+ thus False using \<open>finite (Keys P)\<close> ..
	+qed
	+
	+private definition N where "N = normal_form F ` P[X]"
	+
	+private definition qs where "qs = (SOME qs'. valid_decomp X qs' \<and> standard_decomp 0 qs' \<and>
	+ monomial_decomp qs' \<and> cone_decomp N qs' \<and> exact_decomp X 0 qs' \<and>
	+ (\<forall>g\<in>punit.reduced_GB F. poly_deg g \<le> \<b> qs' 0))"
	+
	+private definition "aa \<equiv> \<b> ps"
	+private definition "bb \<equiv> \<b> qs"
	+private abbreviation (input) "cc \<equiv> (\<lambda>i. aa i + bb i)"
	+
	+lemma
	+ shows valid_qs: "valid_decomp X qs" (is ?thesis1)
	+ and std_qs: "standard_decomp 0 qs" (is ?thesis2)
	+ and mon_qs: "monomial_decomp qs" (is ?thesis3)
	+ and hom_qs: "hom_decomp qs" (is ?thesis6)
	+ and cn_qs: "cone_decomp N qs" (is ?thesis4)
	+ and ext_qs: "exact_decomp X 0 qs" (is ?thesis5)
	+ and deg_RGB: "g \<in> punit.reduced_GB F \<Longrightarrow> poly_deg g \<le> bb 0"
	+proof -
	+ from fin_X F_sub obtain qs' where 1: "valid_decomp X qs'" and 2: "standard_decomp 0 qs'"
	+ and 3: "monomial_decomp qs'" and 4: "cone_decomp (normal_form F ` P[X]) qs'"
	+ and 5: "exact_decomp X 0 qs'"
	+ and 60: "\<And>g. (\<And>f. f \<in> F \<Longrightarrow> homogeneous f) \<Longrightarrow> g \<in> punit.reduced_GB F \<Longrightarrow> poly_deg g \<le> \<b> qs' 0"
	+ by (rule normal_form_exact_decompE) blast
	+ from hom_F have "\<And>g. g \<in> punit.reduced_GB F \<Longrightarrow> poly_deg g \<le> \<b> qs' 0" by (rule 60)
	+ with 1 2 3 4 5 have "valid_decomp X qs' \<and> standard_decomp 0 qs' \<and>
	+ monomial_decomp qs' \<and> cone_decomp N qs' \<and> exact_decomp X 0 qs' \<and>
	+ (\<forall>g\<in>punit.reduced_GB F. poly_deg g \<le> \<b> qs' 0)" by (simp add: N_def)
	+ hence "?thesis1 \<and> ?thesis2 \<and> ?thesis3 \<and> ?thesis4 \<and> ?thesis5 \<and> (\<forall>g\<in>punit.reduced_GB F. poly_deg g \<le> bb 0)"
	+ unfolding qs_def bb_def by (rule someI)
	+ thus ?thesis1 and ?thesis2 and ?thesis3 and ?thesis4 and ?thesis5
	+ and "g \<in> punit.reduced_GB F \<Longrightarrow> poly_deg g \<le> bb 0" by simp_all
	+ from \<open>?thesis3\<close> show ?thesis6 by (rule monomial_decomp_imp_hom_decomp)
	+qed
	+
	+lemma N_sub: "N \<subseteq> P[X]"
	+ using valid_qs cn_qs by (rule valid_cone_decomp_subset_Polys)
	+
	+lemma decomp_Polys: "direct_decomp P[X] [ideal {f} \<inter> P[X], P, N]"
	+proof -
	+ from fin_X F_sub have "direct_decomp P[X] [ideal F \<inter> P[X], N]" unfolding N_def
	+ by (rule direct_decomp_ideal_normal_form)
	+ hence "direct_decomp P[X] ([N] @ [ideal {f} \<inter> P[X], P])" using decomp_F
	+ by (rule direct_decomp_direct_decomp)
	+ hence "direct_decomp P[X] ([ideal {f} \<inter> P[X], P] @ [N])" using perm_append_swap
	+ by (rule direct_decomp_perm)
	+ thus ?thesis by simp
	+qed
	+
	+lemma aa_Suc_n [simp]: "aa (Suc n) = d"
	+proof -
	+ from fin_X ext_ps le_refl have "aa (Suc n) = \<a> ps" unfolding aa_def by (rule \<b>_card_X)
	+ also from fin_X valid_ps std_ps ps_not_Nil have "\<dots> = d" by (rule \<a>_nonempty_unique)
	+ finally show ?thesis .
	+qed
	+
	+lemma bb_Suc_n [simp]: "bb (Suc n) = 0"
	+proof -
	+ from fin_X ext_qs le_refl have "bb (Suc n) = \<a> qs" unfolding bb_def by (rule \<b>_card_X)
	+ also from std_qs have "\<dots> = 0" unfolding \<a>_def[OF fin_X] by (rule Least_eq_0)
	+ finally show ?thesis .
	+qed
	+
	+lemma Hilbert_fun_X:
	+ assumes "d \<le> z"
	+ shows "Hilbert_fun (P[X]::(_ \<Rightarrow>\<^sub>0 'a) set) z =
	+ ((z - d) + (n - 1)) choose (n - 1) + Hilbert_fun P z + Hilbert_fun N z"
	+proof -
	+ define ss where "ss = [ideal {f} \<inter> P[X], P, N]"
	+ have "homogeneous_set A \<and> phull.subspace A" if "A \<in> set ss" for A
	+ proof -
	+ from that have "A = ideal {f} \<inter> P[X] \<or> A = P \<or> A = N" by (simp add: ss_def)
	+ thus ?thesis
	+ proof (elim disjE)
	+ assume A: "A = ideal {f} \<inter> P[X]"
	+ show ?thesis unfolding A
	+ by (intro conjI homogeneous_set_IntI phull.subspace_inter homogeneous_set_homogeneous_ideal
	+ homogeneous_set_Polys subspace_ideal subspace_Polys) (simp add: hom_f)
	+ next
	+ assume A: "A = P"
	+ from cn_ps hom_ps show ?thesis unfolding A
	+ by (intro conjI homogeneous_set_cone_decomp subspace_cone_decomp)
	+ next
	+ assume A: "A = N"
	+ from cn_qs hom_qs show ?thesis unfolding A
	+ by (intro conjI homogeneous_set_cone_decomp subspace_cone_decomp)
	+ qed
	+ qed
	+ hence 1: "\<And>A. A \<in> set ss \<Longrightarrow> homogeneous_set A" and 2: "\<And>A. A \<in> set ss \<Longrightarrow> phull.subspace A"
	+ by simp_all
	+ have "Hilbert_fun (P[X]::(_ \<Rightarrow>\<^sub>0 'a) set) z = (\<Sum>p\<in>set ss. Hilbert_fun p z)"
	+ using fin_X subset_refl decomp_Polys unfolding ss_def
	+ proof (rule Hilbert_fun_direct_decomp)
	+ fix A
	+ assume "A \<in> set [ideal {f} \<inter> P[X], P, N]"
	+ hence "A \<in> set ss" by (simp only: ss_def)
	+ thus "homogeneous_set A" and "phull.subspace A" by (rule 1, rule 2)
	+ qed
	+ also have "\<dots> = (\<Sum>p\<in>set ss. count_list ss p * Hilbert_fun p z)"
	+ using refl
	+ proof (rule sum.cong)
	+ fix p
	+ assume "p \<in> set ss"
	+ hence "count_list ss p \<noteq> 0" by (simp only: count_list_eq_0_iff not_not)
	+ hence "count_list ss p = 1 \<or> 1 < count_list ss p" by auto
	+ thus "Hilbert_fun p z = count_list ss p * Hilbert_fun p z"
	+ proof
	+ assume "1 < count_list ss p"
	+ with decomp_Polys have "p = {0}" unfolding ss_def[symmetric] using phull.subspace_0
	+ by (rule direct_decomp_repeated_eq_zero) (rule 2)
	+ thus ?thesis by simp
	+ qed simp
	+ qed
	+ also have "\<dots> = sum_list (map (\<lambda>p. Hilbert_fun p z) ss)"
	+ by (rule sym) (rule sum_list_map_eq_sum_count)
	+ also have "\<dots> = Hilbert_fun (cone (f, X)) z + Hilbert_fun P z + Hilbert_fun N z"
	+ by (simp add: ss_def ideal_Int_Polys_eq_cone)
	+ also have "Hilbert_fun (cone (f, X)) z = (z - d + (n - 1)) choose (n - 1)"
	+ using f_not_0 f_in_Polys fin_X hom_f X_not_empty by (simp add: Hilbert_fun_cone_nonempty assms)
	+ finally show ?thesis .
	+qed
	+
	+lemma dube_eq_0:
	+ "(\<lambda>z::int. (z + int n - 1) gchoose (n - 1)) =
	+ (\<lambda>z::int. ((z - d + n - 1) gchoose (n - 1)) + Hilbert_poly aa z + Hilbert_poly bb z)"
	+ (is "?f = ?g")
	+proof (rule poly_fun_eqI_ge)
	+ fix z::int
	+ let ?z = "nat z"
	+ assume "max (aa 0) (bb 0) \<le> z"
	+ hence "aa 0 \<le> nat z" and "bb 0 \<le> nat z" and "0 \<le> z" by simp_all
	+ from this(3) have int_z: "int ?z = z" by simp
	+ have "d \<le> aa 0" unfolding aa_Suc_n[symmetric] using fin_X le0 unfolding aa_def by (rule \<b>_decreasing)
	+ hence "d \<le> ?z" using \<open>aa 0 \<le> nat z\<close> by (rule le_trans)
	+ hence int_zd: "int (?z - d) = z - int d" using int_z by linarith
	+ from \<open>d \<le> ?z\<close> have "Hilbert_fun (P[X]::(_ \<Rightarrow>\<^sub>0 'a) set) ?z =
	+ ((?z - d) + (n - 1)) choose (n - 1) + Hilbert_fun P ?z + Hilbert_fun N ?z"
	+ by (rule Hilbert_fun_X)
	+ also have "int \<dots> = (z - d + (n - 1)) gchoose (n - 1) + Hilbert_poly aa z + Hilbert_poly bb z"
	+ using X_not_empty valid_ps hom_ps cn_ps std_ps ext_ps \<open>aa 0 \<le> nat z\<close>
	+ valid_qs hom_qs cn_qs std_qs ext_qs \<open>bb 0 \<le> nat z\<close> \<open>0 \<le> z\<close>
	+ by (simp add: Hilbert_fun_eq_Hilbert_poly int_z aa_def bb_def int_binomial int_zd)
	+ finally show "?f z = ?g z" using fin_X X_not_empty \<open>0 \<le> z\<close>
	+ by (simp add: Hilbert_fun_Polys int_binomial) smt
	+qed (simp_all add: poly_fun_Hilbert_poly)
	+
	+corollary dube_eq_1:
	+ "(\<lambda>z::int. (z + int n - 1) gchoose (n - 1)) =
	+ (\<lambda>z::int. ((z - d + n - 1) gchoose (n - 1)) + ((z - d + n) gchoose n) + ((z + n) gchoose n) - 2 -
	+ (\<Sum>i=1..n. ((z - aa i + i - 1) gchoose i) + ((z - bb i + i - 1) gchoose i)))"
	+ by (simp only: dube_eq_0) (auto simp: Hilbert_poly_def Let_def sum.distrib)
	+
	+lemma dube_eq_2:
	+ assumes "j < n"
	+ shows "(\<lambda>z::int. (z + int n - int j - 1) gchoose (n - j - 1)) =
	+ (\<lambda>z::int. ((z - d + n - int j - 1) gchoose (n - j - 1)) + ((z - d + n - j) gchoose (n - j)) +
	+ ((z + n - j) gchoose (n - j)) - 2 -
	+ (\<Sum>i=Suc j..n. ((z - aa i + i - j - 1) gchoose (i - j)) + ((z - bb i + i - j - 1) gchoose (i - j))))"
	+ (is "?f = ?g")
	+proof -
	+ let ?h = "\<lambda>z i. ((z + (int i - aa i - 1)) gchoose i) + ((z + (int i - bb i - 1)) gchoose i)"
	+ let ?hj = "\<lambda>z i. ((z + (int i - aa i - 1) - j) gchoose (i - j)) + ((z + (int i - bb i - 1) - j) gchoose (i - j))"
	+ from assms have 1: "j \<le> n - Suc 0" and 2: "j \<le> n" by simp_all
	+
	+ have eq1: "(bw_diff ^^ j) (\<lambda>z. \<Sum>i=1..j. ?h z i) = (\<lambda>_. if j = 0 then 0 else 2)"
	+ proof (cases j)
	+ case 0
	+ thus ?thesis by simp
	+ next
	+ case (Suc j0)
	+ hence "j \<noteq> 0" by simp
	+ have "(\<lambda>z::int. \<Sum>i = 1..j. ?h z i) = (\<lambda>z::int. (\<Sum>i = 1..j0. ?h z i) + ?h z j)"
	+ by (simp add: \<open>j = Suc j0\<close>)
	+ moreover have "(bw_diff ^^ j) \<dots> = (\<lambda>z::int. (\<Sum>i = 1..j0. (bw_diff ^^ j) (\<lambda>z. ?h z i) z) + 2)"
	+ by (simp add: bw_diff_gbinomial_pow)
	+ moreover have "(\<Sum>i = 1..j0. (bw_diff ^^ j) (\<lambda>z. ?h z i) z) = (\<Sum>i = 1..j0. 0)" for z::int
	+ using refl
	+ proof (rule sum.cong)
	+ fix i
	+ assume "i \<in> {1..j0}"
	+ hence "\<not> j \<le> i" by (simp add: \<open>j = Suc j0\<close>)
	+ thus "(bw_diff ^^ j) (\<lambda>z. ?h z i) z = 0" by (simp add: bw_diff_gbinomial_pow)
	+ qed
	+ ultimately show ?thesis by (simp add: \<open>j \<noteq> 0\<close>)
	+ qed
	+
	+ have eq2: "(bw_diff ^^ j) (\<lambda>z. \<Sum>i=Suc j..n. ?h z i) = (\<lambda>z. (\<Sum>i=Suc j..n. ?hj z i))"
	+ proof -
	+ have "(bw_diff ^^ j) (\<lambda>z. \<Sum>i=Suc j..n. ?h z i) = (\<lambda>z. \<Sum>i=Suc j..n. (bw_diff ^^ j) (\<lambda>z. ?h z i) z)"
	+ by simp
	+ also have "\<dots> = (\<lambda>z. (\<Sum>i=Suc j..n. ?hj z i))"
	+ proof (intro ext sum.cong)
	+ fix z i
	+ assume "i \<in> {Suc j..n}"
	+ hence "j \<le> i" by simp
	+ thus "(bw_diff ^^ j) (\<lambda>z. ?h z i) z = ?hj z i" by (simp add: bw_diff_gbinomial_pow)
	+ qed (fact refl)
	+ finally show ?thesis .
	+ qed
	+
	+ from 1 have "?f = (bw_diff ^^ j) (\<lambda>z::int. (z + (int n - 1)) gchoose (n - 1))"
	+ by (simp add: bw_diff_gbinomial_pow) (simp only: algebra_simps)
	+ also have "\<dots> = (bw_diff ^^ j) (\<lambda>z::int. (z + int n - 1) gchoose (n - 1))"
	+ by (simp only: algebra_simps)
	+ also have "\<dots> = (bw_diff ^^ j)
	+ (\<lambda>z::int. ((z - d + n - 1) gchoose (n - 1)) + ((z - d + n) gchoose n) + ((z + n) gchoose n) - 2 -
	+ (\<Sum>i=1..n. ((z - aa i + i - 1) gchoose i) + ((z - bb i + i - 1) gchoose i)))"
	+ by (simp only: dube_eq_1)
	+ also have "\<dots> = (bw_diff ^^ j)
	+ (\<lambda>z::int. ((z + (int n - d - 1)) gchoose (n - 1)) + ((z + (int n - d)) gchoose n) +
	+ ((z + n) gchoose n) - 2 - (\<Sum>i=1..n. ?h z i))"
	+ by (simp only: algebra_simps)
	+ also have "\<dots> = (\<lambda>z::int. ((z + (int n - d - 1) - j) gchoose (n - 1 - j)) +
	+ ((z + (int n - d) - j) gchoose (n - j)) + ((z + n - j) gchoose (n - j)) - (if j = 0 then 2 else 0) -
	+ (bw_diff ^^ j) (\<lambda>z. \<Sum>i=1..n. ?h z i) z)"
	+ using 1 2 by (simp add: bw_diff_const_pow bw_diff_gbinomial_pow del: bw_diff_sum_pow)
	+ also from \<open>j \<le> n\<close> have "(\<lambda>z. \<Sum>i=1..n. ?h z i) = (\<lambda>z. (\<Sum>i=1..j. ?h z i) + (\<Sum>i=Suc j..n. ?h z i))"
	+ by (simp add: sum_split_nat_ivl)
	+ also have "(bw_diff ^^ j) \<dots> = (\<lambda>z. (bw_diff ^^ j) (\<lambda>z. \<Sum>i=1..j. ?h z i) z + (bw_diff ^^ j) (\<lambda>z. \<Sum>i=Suc j..n. ?h z i) z)"
	+ by (simp only: bw_diff_plus_pow)
	+ also have "\<dots> = (\<lambda>z. (if j = 0 then 0 else 2) + (\<Sum>i=Suc j..n. ?hj z i))"
	+ by (simp only: eq1 eq2)
	+ finally show ?thesis by (simp add: algebra_simps)
	+qed
	+
	+lemma dube_eq_3:
	+ assumes "j < n"
	+ shows "(1::int) = (- 1)^(n - Suc j) * ((int d - 1) gchoose (n - Suc j)) +
	+ (- 1)^(n - j) * ((int d - 1) gchoose (n - j)) - 1 -
	+ (\<Sum>i=Suc j..n. (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))))"
	+proof -
	+ from assms have 1: "int (n - Suc j) = int n - j - 1" and 2: "int (n - j) = int n - j" by simp_all
	+ from assms have "int n - int j - 1 = int (n - j - 1)" by simp
	+ hence eq1: "int n - int j - 1 gchoose (n - Suc j) = 1" by simp
	+ from assms have "int n - int j = int (n - j)" by simp
	+ hence eq2: "int n - int j gchoose (n - j) = 1" by simp
	+ have eq3: "int n - d - j - 1 gchoose (n - Suc j) = (- 1)^(n - Suc j) * (int d - 1 gchoose (n - Suc j))"
	+ by (simp add: gbinomial_int_negated_upper[of "int n - d - j - 1"] 1)
	+ have eq4: "int n - d - j gchoose (n - j) = (- 1)^(n - j) * (int d - 1 gchoose (n - j))"
	+ by (simp add: gbinomial_int_negated_upper[of "int n - d - j"] 2)
	+ have eq5: "(\<Sum>i = Suc j..n. int i - aa i - j - 1 gchoose (i - j) + (int i - bb i - j - 1 gchoose (i - j))) =
	+ (\<Sum>i=Suc j..n. (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))))"
	+ using refl
	+ proof (rule sum.cong)
	+ fix i
	+ assume "i \<in> {Suc j..n}"
	+ hence "j \<le> i" by simp
	+ hence 3: "int (i - j) = int i - j" by simp
	+ show "int i - aa i - j - 1 gchoose (i - j) + (int i - bb i - j - 1 gchoose (i - j)) =
	+ (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j)))"
	+ by (simp add: gbinomial_int_negated_upper[of "int i - aa i - j - 1"]
	+ gbinomial_int_negated_upper[of "int i - bb i - j - 1"] 3 distrib_left)
	+ qed
	+ from fun_cong[OF dube_eq_2, OF assms, of 0] show ?thesis by (simp add: eq1 eq2 eq3 eq4 eq5)
	+qed
	+
	+lemma dube_aux_1:
	+ assumes "(h, {}) \<in> set ps \<union> set qs"
	+ shows "poly_deg h < max (aa 1) (bb 1)"
	+proof (rule ccontr)
	+ define z where "z = poly_deg h"
	+ assume "\<not> z < max (aa 1) (bb 1)"
	+
	+ let ?S = "\<lambda>A. {h. (h, {}) \<in> A \<and> poly_deg h = z}"
	+ have fin: "finite (?S A)" if "finite A" for A::"((('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<times> 'x set) set"
	+ proof -
	+ have "(\<lambda>t. (t, {})) ` ?S A \<subseteq> A" by blast
	+ hence "finite ((\<lambda>t. (t, {}::'x set)) ` ?S A)" using that by (rule finite_subset)
	+ moreover have "inj_on (\<lambda>t. (t, {}::'x set)) (?S A)" by (rule inj_onI) simp
	+ ultimately show ?thesis by (rule finite_imageD)
	+ qed
	+ from finite_set have 1: "finite (?S (set ps))" by (rule fin)
	+ from finite_set have 2: "finite (?S (set qs))" by (rule fin)
	+
	+ from \<open>\<not> z < max (aa 1) (bb 1)\<close> have "aa 1 \<le> z" and "bb 1 \<le> z" by simp_all
	+ have "d \<le> aa 1" unfolding aa_Suc_n[symmetric] aa_def using fin_X by (rule \<b>_decreasing) simp
	+ hence "d \<le> z" using \<open>aa 1 \<le> z\<close> by (rule le_trans)
	+ hence eq: "int (z - d) = int z - int d" by simp
	+ from \<open>d \<le> z\<close> have "Hilbert_fun (P[X]::(_ \<Rightarrow>\<^sub>0 'a) set) z =
	+ ((z - d) + (n - 1)) choose (n - 1) + Hilbert_fun P z + Hilbert_fun N z"
	+ by (rule Hilbert_fun_X)
	+ also have "int \<dots> = ((int z - d + (n - 1)) gchoose (n - 1) + Hilbert_poly aa z + Hilbert_poly bb z) +
	+ (int (card (?S (set ps))) + int (card (?S (set qs))))"
	+ using X_not_empty valid_ps hom_ps cn_ps std_ps ext_ps \<open>aa 1 \<le> z\<close>
	+ valid_qs hom_qs cn_qs std_qs ext_qs \<open>bb 1 \<le> z\<close>
	+ by (simp add: Hilbert_fun_eq_Hilbert_poly_plus_card aa_def bb_def int_binomial eq)
	+ finally have "((int z - d + n - 1) gchoose (n - 1) + Hilbert_poly aa z + Hilbert_poly bb z) +
	+ (int (card (?S (set ps))) + int (card (?S (set qs)))) = int z + n - 1 gchoose (n - 1)"
	+ using fin_X X_not_empty by (simp add: Hilbert_fun_Polys int_binomial algebra_simps)
	+ also have "\<dots> = (int z - d + n - 1) gchoose (n - 1) + Hilbert_poly aa z + Hilbert_poly bb z"
	+ by (fact dube_eq_0[THEN fun_cong])
	+ finally have "int (card (?S (set ps))) + int (card (?S (set qs))) = 0" by simp
	+ hence "card (?S (set ps)) = 0" and "card (?S (set qs)) = 0" by simp_all
	+ with 1 2 have "?S (set ps \<union> set qs) = {}" by auto
	+ moreover from assms have "h \<in> ?S (set ps \<union> set qs)" by (simp add: z_def)
	+ ultimately have "h \<in> {}" by (rule subst)
	+ thus False by simp
	+qed
	+
	+lemma
	+ shows aa_n: "aa n = d" and bb_n: "bb n = 0" and bb_0: "bb 0 \<le> max (aa 1) (bb 1)"
	+proof -
	+ let ?j = "n - Suc 0"
	+ from n_gr_0 have "?j < n" and eq1: "Suc ?j = n" and eq2: "n - ?j = 1" by simp_all
	+ from this(1) have "(1::int) = (- 1)^(n - Suc ?j) * ((int d - 1) gchoose (n - Suc ?j)) +
	+ (- 1)^(n - ?j) * ((int d - 1) gchoose (n - ?j)) - 1 -
	+ (\<Sum>i=Suc ?j..n. (- 1)^(i - ?j) * ((int (aa i) gchoose (i - ?j)) + (int (bb i) gchoose (i - ?j))))"
	+ by (rule dube_eq_3)
	+ hence eq: "aa n + bb n = d" by (simp add: eq1 eq2)
	+ hence "aa n \<le> d" by simp
	+ moreover have "d \<le> aa n" unfolding aa_Suc_n[symmetric] aa_def using fin_X by (rule \<b>_decreasing) simp
	+ ultimately show "aa n = d" by (rule antisym)
	+ with eq show "bb n = 0" by simp
	+
	+ have "bb 0 = \<b> qs 0" by (simp only: bb_def)
	+ also from fin_X have "\<dots> \<le> max (aa 1) (bb 1)" (is "_ \<le> ?m")
	+ proof (rule \<b>_le)
	+ from fin_X ext_qs have "\<a> qs = bb (Suc n)" by (simp add: \<b>_card_X bb_def)
	+ also have "\<dots> \<le> bb 1" unfolding bb_def using fin_X by (rule \<b>_decreasing) simp
	+ also have "\<dots> \<le> ?m" by (rule max.cobounded2)
	+ finally show "\<a> qs \<le> ?m" .
	+ next
	+ fix h U
	+ assume "(h, U) \<in> set qs"
	+ show "poly_deg h < ?m"
	+ proof (cases "card U = 0")
	+ case True
	+ from fin_X valid_qs \<open>(h, U) \<in> set qs\<close> have "finite U" by (rule valid_decompD_finite)
	+ with True have "U = {}" by simp
	+ with \<open>(h, U) \<in> set qs\<close> have "(h, {}) \<in> set ps \<union> set qs" by simp
	+ thus ?thesis by (rule dube_aux_1)
	+ next
	+ case False
	+ hence "1 \<le> card U" by simp
	+ with fin_X \<open>(h, U) \<in> set qs\<close> have "poly_deg h < bb 1" unfolding bb_def by (rule \<b>)
	+ also have "\<dots> \<le> ?m" by (rule max.cobounded2)
	+ finally show ?thesis .
	+ qed
	+ qed
	+ finally show "bb 0 \<le> ?m" .
	+qed
	+
	+lemma dube_eq_4:
	+ assumes "j < n"
	+ shows "(1::int) = 2 * (- 1)^(n - Suc j) * ((int d - 1) gchoose (n - Suc j)) - 1 -
	+ (\<Sum>i=Suc j..n-1. (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))))"
	+proof -
	+ from assms have "Suc j \<le> n" and "0 < n" and 1: "Suc (n - Suc j) = n - j" by simp_all
	+ have 2: "(- 1) ^ (n - Suc j) = - ((- (1::int)) ^ (n - j))" by (simp flip: 1)
	+ from assms have "(1::int) = (- 1)^(n - Suc j) * ((int d - 1) gchoose (n - Suc j)) +
	+ (- 1)^(n - j) * ((int d - 1) gchoose (n - j)) - 1 -
	+ (\<Sum>i=Suc j..n. (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))))"
	+ by (rule dube_eq_3)
	+ also have "\<dots> = (- 1)^(n - Suc j) * ((int d - 1) gchoose (n - Suc j)) +
	+ (- 1)^(n - j) * ((int d - 1) gchoose (n - j)) - 1 -
	+ (- 1)^(n - j) * ((int (aa n) gchoose (n - j)) + (int (bb n) gchoose (n - j))) -
	+ (\<Sum>i=Suc j..n-1. (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))))"
	+ using \<open>0 < n\<close> \<open>Suc j \<le> n\<close> by (simp only: sum_tail_nat)
	+ also have "\<dots> = (- 1)^(n - Suc j) * ((int d - 1) gchoose (n - Suc j)) +
	+ (- 1)^(n - j) * (((int d - 1) gchoose (n - j)) - (int d gchoose (n - j))) - 1 -
	+ (\<Sum>i=Suc j..n-1. (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))))"
	+ using assms by (simp add: aa_n bb_n gbinomial_0_left right_diff_distrib)
	+ also have "(- 1)^(n - j) * (((int d - 1) gchoose (n - j)) - (int d gchoose (n - j))) =
	+ (- 1)^(n - Suc j) * (((int d - 1 + 1) gchoose (Suc (n - Suc j))) - ((int d - 1) gchoose (Suc (n - Suc j))))"
	+ by (simp add: 1 2 flip: mult_minus_right)
	+ also have "\<dots> = (- 1)^(n - Suc j) * ((int d - 1) gchoose (n - Suc j))"
	+ by (simp only: gbinomial_int_Suc_Suc, simp)
	+ finally show ?thesis by simp
	+qed
	+
	+lemma cc_Suc:
	+ assumes "j < n - 1"
	+ shows "int (cc (Suc j)) = 2 + 2 * (- 1)^(n - j) * ((int d - 1) gchoose (n - Suc j)) +
	+ (\<Sum>i=j+2..n-1. (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))))"
	+proof -
	+ from assms have "j < n" and "Suc j \<le> n - 1" by simp_all
	+ hence "n - j = Suc (n - Suc j)" by simp
	+ hence eq: "(- 1) ^ (n - Suc j) = - ((- (1::int)) ^ (n - j))" by simp
	+ from \<open>j < n\<close> have "(1::int) = 2 * (- 1)^(n - Suc j) * ((int d - 1) gchoose (n - Suc j)) - 1 -
	+ (\<Sum>i=Suc j..n-1. (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))))"
	+ by (rule dube_eq_4)
	+ also have "\<dots> = cc (Suc j) - 2 * (- 1)^(n - j) * ((int d - 1) gchoose (n - Suc j)) - 1 -
	+ (\<Sum>i=j+2..n-1. (- 1)^(i - j) * ((int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))))"
	+ using \<open>Suc j \<le> n - 1\<close> by (simp add: sum.atLeast_Suc_atMost eq)
	+ finally show ?thesis by simp
	+qed
	+
	+lemma cc_n_minus_1: "cc (n - 1) = 2 * d"
	+proof -
	+ let ?j = "n - 2"
	+ from n_gr_1 have 1: "Suc ?j = n - 1" and "?j < n - 1" and 2: "Suc (n - 1) = n"
	+ and 3: "n - (n - Suc 0) = Suc 0" and 4: "n - ?j = 2"
	+ by simp_all
	+ have "int (cc (n - 1)) = int (cc (Suc ?j))" by (simp only: 1)
	+ also from \<open>?j < n - 1\<close> have "\<dots> = 2 + 2 * (- 1) ^ (n - ?j) * (int d - 1 gchoose (n - Suc ?j)) +
	+ (\<Sum>i = ?j+2..n-1. (- 1) ^ (i - ?j) * (int (aa i) gchoose (i - ?j) + (int (bb i) gchoose (i - ?j))))"
	+ by (rule cc_Suc)
	+ also have "\<dots> = int (2 * d)" by (simp add: 1 2 3 4)
	+ finally show ?thesis by (simp only: int_int_eq)
	+qed
	+
	+text \<open>Since the case @{prop "n = 2"} is settled, we can concentrate on @{prop "2 < n"} now.\<close>
	+
	+context
	+ assumes n_gr_2: "2 < n"
	+begin
	+
	+lemma cc_n_minus_2: "cc (n - 2) \<le> d\<^sup>2 + 2 * d"
	+proof -
	+ let ?j = "n - 3"
	+ from n_gr_2 have 1: "Suc ?j = n - 2" and "?j < n - 1" and 2: "Suc (n - 2) = n - Suc 0"
	+ and 3: "n - (n - 2) = 2" and 4: "n - ?j = 3"
	+ by simp_all
	+ have "int (cc (n - 2)) = int (cc (Suc ?j))" by (simp only: 1)
	+ also from \<open>?j < n - 1\<close> have "\<dots> = 2 + 2 * (- 1) ^ (n - ?j) * (int d - 1 gchoose (n - Suc ?j)) +
	+ (\<Sum>i = ?j+2..n-1. (- 1) ^ (i - ?j) * (int (aa i) gchoose (i - ?j) + (int (bb i) gchoose (i - ?j))))"
	+ by (rule cc_Suc)
	+ also have "\<dots> = (2 - 2 * (int d - 1 gchoose 2)) + ((int (aa (n - 1)) gchoose 2) + (int (bb (n - 1)) gchoose 2))"
	+ by (simp add: 1 2 3 4)
	+ also have "\<dots> \<le> (2 - 2 * (int d - 1 gchoose 2)) + (2 * int d gchoose 2)"
	+ proof (rule add_left_mono)
	+ have "int (aa (n - 1)) gchoose 2 + (int (bb (n - 1)) gchoose 2) \<le> int (aa (n - 1)) + int (bb (n - 1)) gchoose 2"
	+ by (rule gbinomial_int_plus_le) simp_all
	+ also have "\<dots> = int (2 * d) gchoose 2" by (simp flip: cc_n_minus_1)
	+ also have "\<dots> = 2 * int d gchoose 2" by (simp add: int_ops(7))
	+ finally show "int (aa (n - 1)) gchoose 2 + (int (bb (n - 1)) gchoose 2) \<le> 2 * int d gchoose 2" .
	+ qed
	+ also have "\<dots> = 2 - fact 2 * (int d - 1 gchoose 2) + (2 * int d gchoose 2)" by (simp only: fact_2)
	+ also have "\<dots> = 2 - (int d - 1) * (int d - 2) + (2 * int d gchoose 2)"
	+ by (simp only: gbinomial_int_mult_fact) (simp add: numeral_2_eq_2 prod.atLeast0_lessThan_Suc)
	+ also have "\<dots> = 2 - (int d - 1) * (int d - 2) + int d * (2 * int d - 1)"
	+ by (simp add: gbinomial_prod_rev numeral_2_eq_2 prod.atLeast0_lessThan_Suc)
	+ also have "\<dots> = int (d\<^sup>2 + 2 * d)" by (simp add: power2_eq_square) (simp only: algebra_simps)
	+ finally show ?thesis by (simp only: int_int_eq)
	+qed
	+
	+lemma cc_Suc_le:
	+ assumes "j < n - 3"
	+ shows "int (cc (Suc j)) \<le> 2 + (int (cc (j + 2)) gchoose 2) + (\<Sum>i=j+4..n-1. int (cc i) gchoose (i - j))"
	+ \<comment>\<open>Could be proved without coercing to @{typ int}, because everything is non-negative.\<close>
	+proof -
	+ let ?f = "\<lambda>i j. (int (aa i) gchoose (i - j)) + (int (bb i) gchoose (i - j))"
	+ let ?S = "\<lambda>x y. (\<Sum>i=j+x..n-y. (- 1)^(i - j) * ?f i j)"
	+ let ?S3 = "\<lambda>x y. (\<Sum>i=j+x..n-y. (int (cc i) gchoose (i - j)))"
	+ have ie1: "int (aa i) gchoose k + (int (bb i) gchoose k) \<le> int (cc i) gchoose k" if "0 < k" for i k
	+ proof -
	+ from that have "int (aa i) gchoose k + (int (bb i) gchoose k) \<le> int (aa i) + int (bb i) gchoose k"
	+ by (rule gbinomial_int_plus_le) simp_all
	+ also have "\<dots> = int (cc i) gchoose k" by simp
	+ finally show ?thesis .
	+ qed
	+ from d_gr_0 have "0 \<le> int d - 1" by simp
	+ from assms have "0 < n - Suc j" by simp
	+ have f_nonneg: "0 \<le> ?f i j" for i by (simp add: gbinomial_int_nonneg)
	+
	+ show ?thesis
	+ proof (cases "n = j + 4")
	+ case True
	+ hence j: "j = n - 4" by simp
	+ have 1: "n - Suc j = 3" and "j < n - 1" and 2: "Suc (n - 3) = Suc (Suc j)" and 3: "n - (n - 3) = 3"
	+ and 4: "n - j = 4" and 5: "n - Suc 0 = Suc (Suc (Suc j))" and 6: "n - 2 = Suc (Suc j)"
	+ by (simp_all add: True)
	+ from \<open>j < n - 1\<close> have "int (cc (Suc j)) = 2 + 2 * (- 1) ^ (n - j) * (int d - 1 gchoose (n - Suc j)) +
	+ (\<Sum>i = j+2..n-1. (- 1) ^ (i - j) * (int (aa i) gchoose (i - j) + (int (bb i) gchoose (i - j))))"
	+ by (rule cc_Suc)
	+ also have "\<dots> = (2 + ((int (aa (n - 2)) gchoose 2) + (int (bb (n - 2)) gchoose 2))) +
	+ (2 * (int d - 1 gchoose 3) - ((int (aa (n - 1)) gchoose 3) + (int (bb (n - 1)) gchoose 3)))"
	+ by (simp add: 1 2 3 4 5 6)
	+ also have "\<dots> \<le> (2 + ((int (aa (n - 2)) gchoose 2) + (int (bb (n - 2)) gchoose 2))) + 0"
	+ proof (rule add_left_mono)
	+ from cc_n_minus_1 have eq1: "int (aa (n - 1)) + int (bb (n - 1)) = 2 * int d" by simp
	+ hence ie2: "int (aa (n - 1)) \<le> 2 * int d" by simp
	+ from \<open>0 \<le> int d - 1\<close> have "int d - 1 gchoose 3 \<le> int d gchoose 3" by (rule gbinomial_int_mono) simp
	+ hence "2 * (int d - 1 gchoose 3) \<le> 2 * (int d gchoose 3)" by simp
	+ also from _ ie2 have "\<dots> \<le> int (aa (n - 1)) gchoose 3 + (2 * int d - int (aa (n - 1)) gchoose 3)"
	+ by (rule binomial_int_ineq_3) simp
	+ also have "\<dots> = int (aa (n - 1)) gchoose 3 + (int (bb (n - 1)) gchoose 3)" by (simp flip: eq1)
	+ finally show "2 * (int d - 1 gchoose 3) - (int (aa (n - 1)) gchoose 3 + (int (bb (n - 1)) gchoose 3)) \<le> 0"
	+ by simp
	+ qed
	+ also have "\<dots> = 2 + ((int (aa (n - 2)) gchoose 2) + (int (bb (n - 2)) gchoose 2))" by simp
	+ also from ie1 have "\<dots> \<le> 2 + (int (cc (n - 2)) gchoose 2)" by (rule add_left_mono) simp
	+ also have "\<dots> = 2 + (int (cc (j + 2)) gchoose 2) + ?S3 4 1" by (simp add: True)
	+ finally show ?thesis .
	+ next
	+ case False
	+ with assms have "j + 4 \<le> n - 1" by simp
	+ from n_gr_1 have "0 < n - 1" by simp
	+ from assms have "j + 2 \<le> n - 1" and "j + 2 \<le> n - 2" by simp_all
	+ hence "n - j = Suc (n - Suc j)" by simp
	+ hence 1: "(- 1) ^ (n - Suc j) = - ((- (1::int)) ^ (n - j))" by simp
	+ from assms have "j < n - 1" by simp
	+ hence "int (cc (Suc j)) = 2 + 2 * (- 1)^(n - j) * ((int d - 1) gchoose (n - Suc j)) + ?S 2 1"
	+ by (rule cc_Suc)
	+ also have "\<dots> = 2 * (- 1)^(n - j) * ((int d - 1) gchoose (n - Suc j)) +
	+ (- 1)^(n - Suc j) * ((int (aa (n - 1)) gchoose (n - Suc j)) + (int (bb (n - 1)) gchoose (n - Suc j))) +
	+ (2 + ?S 2 2)"
	+ using \<open>0 < n - 1\<close> \<open>j + 2 \<le> n - 1\<close> by (simp only: sum_tail_nat) (simp flip: numeral_2_eq_2)
	+ also have "\<dots> \<le> (int (cc (n - 1)) gchoose (n - Suc j)) + (2 + ?S 2 2)"
	+ proof (rule add_right_mono)
	+ have rl: "x - y \<le> x" if "0 \<le> y" for x y :: int using that by simp
	+ have "2 * (- 1)^(n - j) * ((int d - 1) gchoose (n - Suc j)) +
	+ (- 1)^(n - Suc j) * ((int (aa (n - 1)) gchoose (n - Suc j)) + (int (bb (n - 1)) gchoose (n - Suc j))) =
	+ (-1)^(n - j) * (2 * ((int d - 1) gchoose (n - Suc j)) -
	+ (int (aa (n - 1)) gchoose (n - Suc j)) - (int (bb (n - 1)) gchoose (n - Suc j)))"
	+ by (simp only: 1 algebra_simps)
	+ also have "\<dots> \<le> (int (cc (n - 1))) gchoose (n - Suc j)"
	+ proof (cases "even (n - j)")
	+ case True
	+ hence "(- 1) ^ (n - j) * (2 * (int d - 1 gchoose (n - Suc j)) - (int (aa (n - 1)) gchoose (n - Suc j)) -
	+ (int (bb (n - 1)) gchoose (n - Suc j))) =
	+ 2 * (int d - 1 gchoose (n - Suc j)) - ((int (aa (n - 1)) gchoose (n - Suc j)) +
	+ (int (bb (n - 1)) gchoose (n - Suc j)))"
	+ by simp
	+ also have "\<dots> \<le> 2 * (int d - 1 gchoose (n - Suc j))" by (rule rl) (simp add: gbinomial_int_nonneg)
	+ also have "\<dots> = (int d - 1 gchoose (n - Suc j)) + (int d - 1 gchoose (n - Suc j))" by simp
	+ also have "\<dots> \<le> (int d - 1) + (int d - 1) gchoose (n - Suc j)"
	+ using \<open>0 < n - Suc j\<close> \<open>0 \<le> int d - 1\<close> \<open>0 \<le> int d - 1\<close> by (rule gbinomial_int_plus_le)
	+ also have "\<dots> \<le> 2 * int d gchoose (n - Suc j)"
	+ proof (rule gbinomial_int_mono)
	+ from \<open>0 \<le> int d - 1\<close> show "0 \<le> int d - 1 + (int d - 1)" by simp
	+ qed simp
	+ also have "\<dots> = int (cc (n - 1)) gchoose (n - Suc j)" by (simp only: cc_n_minus_1) simp
	+ finally show ?thesis .
	+ next
	+ case False
	+ hence "(- 1) ^ (n - j) * (2 * (int d - 1 gchoose (n - Suc j)) - (int (aa (n - 1)) gchoose (n - Suc j)) -
	+ (int (bb (n - 1)) gchoose (n - Suc j))) =
	+ ((int (aa (n - 1)) gchoose (n - Suc j)) + (int (bb (n - 1)) gchoose (n - Suc j))) -
	+ 2 * (int d - 1 gchoose (n - Suc j))"
	+ by simp
	+ also have "\<dots> \<le> (int (aa (n - 1)) gchoose (n - Suc j)) + (int (bb (n - 1)) gchoose (n - Suc j))"
	+ by (rule rl) (simp add: gbinomial_int_nonneg d_gr_0)
	+ also from \<open>0 < n - Suc j\<close> have "\<dots> \<le> int (cc (n - 1)) gchoose (n - Suc j)" by (rule ie1)
	+ finally show ?thesis .
	+ qed
	+ finally show "2 * (- 1)^(n - j) * ((int d - 1) gchoose (n - Suc j)) +
	+ (- 1)^(n - Suc j) * ((int (aa (n - 1)) gchoose (n - Suc j)) + (int (bb (n - 1)) gchoose (n - Suc j))) \<le>
	+ (int (cc (n - 1))) gchoose (n - Suc j)" .
	+ qed
	+ also have "\<dots> = 2 + (int (cc (n - 1)) gchoose ((n - 1) - j)) + ((int (aa (j + 2)) gchoose 2) +
	+ (int (bb (j + 2)) gchoose 2)) + ?S 3 2"
	+ using \<open>j + 2 \<le> n - 2\<close> by (simp add: sum.atLeast_Suc_atMost numeral_3_eq_3)
	+ also have "\<dots> \<le> 2 + (int (cc (n - 1)) gchoose ((n - 1) - j)) + ((int (aa (j + 2)) gchoose 2) +
	+ (int (bb (j + 2)) gchoose 2)) + ?S3 4 2"
	+ proof (rule add_left_mono)
	+ from \<open>j + 4 \<le> n - 1\<close> have "j + 3 \<le> n - 2" by simp
	+ hence "?S 3 2 = ?S 4 2 - ?f (j + 3) j" by (simp add: sum.atLeast_Suc_atMost add.commute)
	+ hence "?S 3 2 \<le> ?S 4 2" using f_nonneg[of "j + 3"] by simp
	+ also have "\<dots> \<le> ?S3 4 2"
	+ proof (rule sum_mono)
	+ fix i
	+ assume "i \<in> {j + 4..n - 2}"
	+ hence "0 < i - j" by simp
	+ from f_nonneg[of i] have "(- 1)^(i - j) * ?f i j \<le> ?f i j"
	+ by (smt minus_one_mult_self mult_cancel_right1 pos_zmult_eq_1_iff_lemma zero_less_mult_iff)
	+ also from \<open>0 < i - j\<close> have "\<dots> \<le> int (cc i) gchoose (i - j)" by (rule ie1)
	+ finally show "(- 1)^(i - j) * ?f i j \<le> int (cc i) gchoose (i - j)" .
	+ qed
	+ finally show "?S 3 2 \<le> ?S3 4 2" .
	+ qed
	+ also have "\<dots> = ((int (aa (j + 2)) gchoose 2) + (int (bb (j + 2)) gchoose 2)) + (2 + ?S3 4 1)"
	+ using \<open>0 < n - 1\<close> \<open>j + 4 \<le> n - 1\<close> by (simp only: sum_tail_nat) (simp flip: numeral_2_eq_2)
	+ also from ie1 have "\<dots> \<le> int (cc (j + 2)) gchoose 2 + (2 + ?S3 4 1)"
	+ by (rule add_right_mono) simp
	+ also have "\<dots> = 2 + (int (cc (j + 2)) gchoose 2) + ?S3 4 1" by (simp only: ac_simps)
	+ finally show ?thesis .
	+ qed
	+qed
	+
	+corollary cc_le:
	+ assumes "0 < j" and "j < n - 2"
	+ shows "cc j \<le> 2 + (cc (j + 1) choose 2) + (\<Sum>i=j+3..n-1. cc i choose (Suc (i - j)))"
	+proof -
	+ define j0 where "j0 = j - 1"
	+ with assms have j: "j = Suc j0" and "j0 < n - 3" by simp_all
	+ have "int (cc j) = int (cc (Suc j0))" by (simp only: j)
	+ also have "\<dots> \<le> 2 + (int (cc (j0 + 2)) gchoose 2) + (\<Sum>i=j0+4..n-1. int (cc i) gchoose (i - j0))"
	+ using \<open>j0 < n - 3\<close> by (rule cc_Suc_le)
	+ also have "\<dots> = 2 + (int (cc (j + 1)) gchoose 2) + (\<Sum>i=j0+4..n-1. int (cc i) gchoose (i - j0))"
	+ by (simp add: j)
	+ also have "(\<Sum>i=j0+4..n-1. int (cc i) gchoose (i - j0)) = int (\<Sum>i=j+3..n-1. cc i choose (Suc (i - j)))"
	+ unfolding int_sum
	+ proof (rule sum.cong)
	+ fix i
	+ assume "i \<in> {j + 3..n - 1}"
	+ hence "Suc j0 < i" by (simp add: j)
	+ hence "i - j0 = Suc (i - j)" by (simp add: j)
	+ thus "int (cc i) gchoose (i - j0) = int (cc i choose (Suc (i - j)))" by (simp add: int_binomial)
	+ qed (simp add: j)
	+ finally have "int (cc j) \<le> int (2 + (cc (j + 1) choose 2) + (\<Sum>i = j + 3..n - 1. cc i choose (Suc (i - j))))"
	+ by (simp only: int_plus int_binomial)
	+ thus ?thesis by (simp only: zle_int)
	+qed
	+
	+corollary cc_le_Dube_aux: "0 < j \<Longrightarrow> j + 1 \<le> n \<Longrightarrow> cc j \<le> Dube_aux n d j"
	+proof (induct j rule: Dube_aux.induct[where n=n])
	+ case step: (1 j)
	+ from step.prems(2) have "j + 2 < n \<or> j + 2 = n \<or> j + 1 = n" by auto
	+ thus ?case
	+ proof (elim disjE)
	+ assume *: "j + 2 < n"
	+ moreover have "0 < j + 1" by simp
	+ moreover from * have "j + 1 + 1 \<le> n" by simp
	+ ultimately have "cc (j + 1) \<le> Dube_aux n d (j + 1)" by (rule step.hyps)
	+ hence 1: "cc (j + 1) choose 2 \<le> Dube_aux n d (j + 1) choose 2"
	+ by (rule Binomial_Int.binomial_mono)
	+ have 2: "(\<Sum>i = j + 3..n - 1. cc i choose Suc (i - j)) \<le>
	+ (\<Sum>i = j + 3..n - 1. Dube_aux n d i choose Suc (i - j))"
	+ proof (rule sum_mono)
	+ fix i::nat
	+ note *
	+ moreover assume "i \<in> {j + 3..n - 1}"
	+ moreover from this \<open>2 < n\<close> have "0 < i" and "i + 1 \<le> n" by auto
	+ ultimately have "cc i \<le> Dube_aux n d i" by (rule step.hyps)
	+ thus "cc i choose Suc (i - j) \<le> Dube_aux n d i choose Suc (i - j)"
	+ by (rule Binomial_Int.binomial_mono)
	+ qed
	+ from * have "j < n - 2" by simp
	+ with step.prems(1) have "cc j \<le> 2 + (cc (j + 1) choose 2) + (\<Sum>i = j + 3..n - 1. cc i choose Suc (i - j))"
	+ by (rule cc_le)
	+ also from * 1 2 have "\<dots> \<le> Dube_aux n d j" by simp
	+ finally show ?thesis .
	+ next
	+ assume "j + 2 = n"
	+ hence "j = n - 2" and "Dube_aux n d j = d\<^sup>2 + 2 * d" by simp_all
	+ thus ?thesis by (simp only: cc_n_minus_2)
	+ next
	+ assume "j + 1 = n"
	+ hence "j = n - 1" and "Dube_aux n d j = 2 * d" by simp_all
	+ thus ?thesis by (simp only: cc_n_minus_1)
	+ qed
	+qed
	+
	+end
	+
	+lemma Dube_aux:
	+ assumes "g \<in> punit.reduced_GB F"
	+ shows "poly_deg g \<le> Dube_aux n d 1"
	+proof (cases "n = 2")
	+ case True
	+ from assms have "poly_deg g \<le> bb 0" by (rule deg_RGB)
	+ also have "\<dots> \<le> max (aa 1) (bb 1)" by (fact bb_0)
	+ also have "\<dots> \<le> cc (n - 1)" by (simp add: True)
	+ also have "\<dots> = 2 * d" by (fact cc_n_minus_1)
	+ also have "\<dots> = Dube_aux n d 1" by (simp add: True)
	+ finally show ?thesis .
	+next
	+ case False
	+ with \<open>1 < n\<close> have "2 < n" and "1 + 1 \<le> n" by simp_all
	+ from assms have "poly_deg g \<le> bb 0" by (rule deg_RGB)
	+ also have "\<dots> \<le> max (aa 1) (bb 1)" by (fact bb_0)
	+ also have "\<dots> \<le> cc 1" by simp
	+ also from \<open>2 < n\<close> _ \<open>1 + 1 \<le> n\<close> have "\<dots> \<le> Dube_aux n d 1" by (rule cc_le_Dube_aux) simp
	+ finally show ?thesis .
	+qed
	+
	+end
	+
	+theorem Dube:
	+ assumes "finite F" and "F \<subseteq> P[X]" and "\<And>f. f \<in> F \<Longrightarrow> homogeneous f" and "g \<in> punit.reduced_GB F"
	+ shows "poly_deg g \<le> Dube (card X) (maxdeg F)"
	+proof (cases "F \<subseteq> {0}")
	+ case True
	+ hence "F = {} \<or> F = {0}" by blast
	+ with assms(4) show ?thesis by (auto simp: punit.reduced_GB_empty punit.reduced_GB_singleton)
	+next
	+ case False
	+ hence "F - {0} \<noteq> {}" by simp
	+ hence "F \<noteq> {}" by blast
	+ hence "poly_deg ` F \<noteq> {}" by simp
	+ from assms(1) have fin1: "finite (poly_deg ` F)" by (rule finite_imageI)
	+ from assms(1) have "finite (F - {0})" by simp
	+ hence fin: "finite (poly_deg ` (F - {0}))" by (rule finite_imageI)
	+ moreover from \<open>F - {0} \<noteq> {}\<close> have *: "poly_deg ` (F - {0}) \<noteq> {}" by simp
	+ ultimately have "maxdeg (F - {0}) \<in> poly_deg ` (F - {0})" unfolding maxdeg_def by (rule Max_in)
	+ then obtain f where "f \<in> F - {0}" and md1: "maxdeg (F - {0}) = poly_deg f" ..
	+ note this(2)
	+ moreover have "maxdeg (F - {0}) \<le> maxdeg F"
	+ unfolding maxdeg_def using image_mono * fin1 by (rule Max_mono) blast
	+ ultimately have "poly_deg f \<le> maxdeg F" by simp
	+ from \<open>f \<in> F - {0}\<close> have "f \<in> F" and "f \<noteq> 0" by simp_all
	+ from this(1) assms(2) have "f \<in> P[X]" ..
	+ have f_max: "poly_deg f' \<le> poly_deg f" if "f' \<in> F" for f'
	+ proof (cases "f' = 0")
	+ case True
	+ thus ?thesis by simp
	+ next
	+ case False
	+ with that have "f' \<in> F - {0}" by simp
	+ hence "poly_deg f' \<in> poly_deg ` (F - {0})" by (rule imageI)
	+ with fin show "poly_deg f' \<le> poly_deg f" unfolding md1[symmetric] maxdeg_def by (rule Max_ge)
	+ qed
	+ have "maxdeg F \<le> poly_deg f" unfolding maxdeg_def using fin1 \<open>poly_deg ` F \<noteq> {}\<close>
	+ proof (rule Max.boundedI)
	+ fix d
	+ assume "d \<in> poly_deg ` F"
	+ then obtain f' where "f' \<in> F" and "d = poly_deg f'" ..
	+ note this(2)
	+ also from \<open>f' \<in> F\<close> have "poly_deg f' \<le> poly_deg f" by (rule f_max)
	+ finally show "d \<le> poly_deg f" .
	+ qed
	+ with \<open>poly_deg f \<le> maxdeg F\<close> have md: "poly_deg f = maxdeg F" by (rule antisym)
	+ show ?thesis
	+ proof (cases "ideal {f} = ideal F")
	+ case True
	+ note assms(4)
	+ also have "punit.reduced_GB F = punit.reduced_GB {f}"
	+ using punit.finite_reduced_GB_finite punit.reduced_GB_is_reduced_GB_finite
	+ by (rule punit.reduced_GB_unique) (simp_all add: punit.reduced_GB_pmdl_finite[simplified] True)
	+ also have "\<dots> \<subseteq> {punit.monic f}" by (simp add: punit.reduced_GB_singleton)
	+ finally have "g \<in> {punit.monic f}" .
	+ hence "poly_deg g = poly_deg (punit.monic f)" by simp
	+ also from poly_deg_monom_mult_le[where c="1 / lcf f" and t=0 and p=f] have "\<dots> \<le> poly_deg f"
	+ by (simp add: punit.monic_def)
	+ also have "\<dots> = maxdeg F" by (fact md)
	+ also have "\<dots> \<le> Dube (card X) (maxdeg F)" by (fact Dube_ge_d)
	+ finally show ?thesis .
	+ next
	+ case False
	+ show ?thesis
	+ proof (cases "poly_deg f = 0")
	+ case True
	+ hence "monomial (lookup f 0) 0 = f" by (rule poly_deg_zero_imp_monomial)
	+ moreover define c where "c = lookup f 0"
	+ ultimately have f: "f = monomial c 0" by simp
	+ with \<open>f \<noteq> 0\<close> have "c \<noteq> 0" by (simp add: monomial_0_iff)
	+ from \<open>f \<in> F\<close> have "f \<in> ideal F" by (rule ideal.span_base)
	+ hence "punit.monom_mult (1 / c) 0 f \<in> ideal F" by (rule punit.pmdl_closed_monom_mult[simplified])
	+ with \<open>c \<noteq> 0\<close> have "ideal F = UNIV"
	+ by (simp add: f punit.monom_mult_monomial ideal_eq_UNIV_iff_contains_one)
	+ with assms(1) have "punit.reduced_GB F = {1}"
	+ by (simp only: ideal_eq_UNIV_iff_reduced_GB_eq_one_finite)
	+ with assms(4) show ?thesis by simp
	+ next
	+ case False
	+ hence "0 < poly_deg f" by simp
	+ have "card X \<le> 1 \<or> 1 < card X" by auto
	+ thus ?thesis
	+ proof
	+ note fin_X
	+ moreover assume "card X \<le> 1"
	+ moreover note assms(2)
	+ moreover from \<open>f \<in> F\<close> have "f \<in> ideal F" by (rule ideal.span_base)
	+ ultimately have "poly_deg g \<le> poly_deg f"
	+ using \<open>f \<noteq> 0\<close> assms(4) by (rule deg_reduced_GB_univariate_le)
	+ also have "\<dots> \<le> Dube (card X) (maxdeg F)" unfolding md by (fact Dube_ge_d)
	+ finally show ?thesis .
	+ next
	+ assume "1 < card X"
	+ hence "poly_deg g \<le> Dube_aux (card X) (poly_deg f) 1"
	+ using assms(1, 2) \<open>f \<in> F\<close> assms(3) f_max \<open>0 < poly_deg f\<close> \<open>ideal {f} \<noteq> ideal F\<close> assms(4)
	+ by (rule Dube_aux)
	+ also from \<open>1 < card X\<close> \<open>0 < poly_deg f\<close> have "\<dots> = Dube (card X) (maxdeg F)"
	+ by (simp add: Dube_def md)
	+ finally show ?thesis .
	+ qed
	+ qed
	+ qed
	+qed
	+
	+corollary Dube_is_hom_GB_bound:
	+ "finite F \<Longrightarrow> F \<subseteq> P[X] \<Longrightarrow> is_hom_GB_bound F (Dube (card X) (maxdeg F))"
	+ by (intro is_hom_GB_boundI Dube)
	+
	+end
	+
	+corollary Dube_indets:
	+ assumes "finite F" and "\<And>f. f \<in> F \<Longrightarrow> homogeneous f" and "g \<in> punit.reduced_GB F"
	+ shows "poly_deg g \<le> Dube (card (UNION F indets)) (maxdeg F)"
	+ using _ assms(1) _ assms(2, 3)
	+proof (rule Dube)
	+ from assms show "finite (UNION F indets)" by (simp add: finite_indets)
	+next
	+ show "F \<subseteq> P[UNION F indets]" by (auto simp: Polys_alt)
	+qed
	+
	+corollary Dube_is_hom_GB_bound_indets:
	+ "finite F \<Longrightarrow> is_hom_GB_bound F (Dube (card (UNION F indets)) (maxdeg F))"
	+ by (intro is_hom_GB_boundI Dube_indets)
	+
	+end (* pm_powerprod *)
	+
	+hide_const (open) pm_powerprod.\<a> pm_powerprod.\<b>
	+
	+context extended_ord_pm_powerprod
	+begin
	+
	+lemma Dube_is_GB_cofactor_bound:
	+ assumes "finite X" and "finite F" and "F \<subseteq> P[X]"
	+ shows "is_GB_cofactor_bound F (Dube (Suc (card X)) (maxdeg F))"
	+ using assms(1, 3)
	+proof (rule hom_GB_bound_is_GB_cofactor_bound)
	+ let ?F = "homogenize None ` extend_indets ` F"
	+ let ?X = "insert None (Some ` X)"
	+ from assms(1) have "finite ?X" by simp
	+ moreover from assms(2) have "finite ?F" by (intro finite_imageI)
	+ moreover have "?F \<subseteq> P[?X]"
	+ proof
	+ fix f'
	+ assume "f' \<in> ?F"
	+ then obtain f where "f \<in> F" and f': "f' = homogenize None (extend_indets f)" by blast
	+ from this(1) assms(3) have "f \<in> P[X]" ..
	+ hence "extend_indets f \<in> P[Some ` X]" by (auto simp: Polys_alt indets_extend_indets)
	+ thus "f' \<in> P[?X]" unfolding f' by (rule homogenize_in_Polys)
	+ qed
	+ ultimately have "extended_ord.is_hom_GB_bound ?F (Dube (card ?X) (maxdeg ?F))"
	+ by (rule extended_ord.Dube_is_hom_GB_bound)
	+ moreover have "maxdeg ?F = maxdeg F"
	+ proof -
	+ have "maxdeg ?F = maxdeg (extend_indets ` F)"
	+ by (auto simp: indets_extend_indets intro: maxdeg_homogenize)
	+ also have "\<dots> = maxdeg F" by (simp add: maxdeg_def image_image)
	+ finally show "maxdeg ?F = maxdeg F" .
	+ qed
	+ moreover from assms(1) have "card ?X = card X + 1" by (simp add: card_image)
	+ ultimately show "extended_ord.is_hom_GB_bound ?F (Dube (Suc (card X)) (maxdeg F))" by simp
	+qed
	+
	+lemma Dube_is_GB_cofactor_bound_explicit:
	+ assumes "finite X" and "finite F" and "F \<subseteq> P[X]"
	+ obtains G where "punit.is_Groebner_basis G" and "ideal G = ideal F" and "G \<subseteq> P[X]"
	+ and "\<And>g. g \<in> G \<Longrightarrow> \<exists>q. g = (\<Sum>f\<in>F. q f * f) \<and>
	+ (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> Dube (Suc (card X)) (maxdeg F) \<and>
	+ (f \<notin> F \<longrightarrow> q f = 0))"
	+proof -
	+ from assms have "is_GB_cofactor_bound F (Dube (Suc (card X)) (maxdeg F))"
	+ (is "is_GB_cofactor_bound _ ?b") by (rule Dube_is_GB_cofactor_bound)
	+ moreover note assms(3)
	+ ultimately obtain G where "punit.is_Groebner_basis G" and "ideal G = ideal F" and "G \<subseteq> P[X]"
	+ and 1: "\<And>g. g \<in> G \<Longrightarrow> \<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> ?b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+ by (rule is_GB_cofactor_boundE_Polys) blast
	+ from this(1-3) show ?thesis
	+ proof
	+ fix g
	+ assume "g \<in> G"
	+ hence "\<exists>F' q. finite F' \<and> F' \<subseteq> F \<and> g = (\<Sum>f\<in>F'. q f * f) \<and>
	+ (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> ?b \<and> (f \<notin> F' \<longrightarrow> q f = 0))"
	+ by (rule 1)
	+ then obtain F' q where "F' \<subseteq> F" and g: "g = (\<Sum>f\<in>F'. q f * f)" and "\<And>f. q f \<in> P[X]"
	+ and "\<And>f. poly_deg (q f * f) \<le> ?b" and 2: "\<And>f. f \<notin> F' \<Longrightarrow> q f = 0" by blast
	+ show "\<exists>q. g = (\<Sum>f\<in>F. q f * f) \<and> (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> ?b \<and> (f \<notin> F \<longrightarrow> q f = 0))"
	+ proof (intro exI allI conjI impI)
	+ from assms(2) \<open>F' \<subseteq> F\<close> have "(\<Sum>f\<in>F'. q f * f) = (\<Sum>f\<in>F. q f * f)"
	+ proof (intro sum.mono_neutral_left ballI)
	+ fix f
	+ assume "f \<in> F - F'"
	+ hence "f \<notin> F'" by simp
	+ hence "q f = 0" by (rule 2)
	+ thus "q f * f = 0" by simp
	+ qed
	+ thus "g = (\<Sum>f\<in>F. q f * f)" by (simp only: g)
	+ next
	+ fix f
	+ assume "f \<notin> F"
	+ with \<open>F' \<subseteq> F\<close> have "f \<notin> F'" by blast
	+ thus "q f = 0" by (rule 2)
	+ qed fact+
	+ qed
	+qed
	+
	+corollary Dube_is_GB_cofactor_bound_indets:
	+ assumes "finite F"
	+ shows "is_GB_cofactor_bound F (Dube (Suc (card (UNION F indets))) (maxdeg F))"
	+ using _ assms _
	+proof (rule Dube_is_GB_cofactor_bound)
	+ from assms show "finite (UNION F indets)" by (simp add: finite_indets)
	+next
	+ show "F \<subseteq> P[UNION F indets]" by (auto simp: Polys_alt)
	+qed
	+
	+end (* extended_ord_pm_powerprod *)
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Dube_Prelims.thy b/thys/Groebner_Macaulay/Dube_Prelims.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Dube_Prelims.thy
	@@ -0,0 +1,391 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Preliminaries\<close>
	+
	+theory Dube_Prelims
	+ imports Groebner_Bases.General
	+begin
	+
	+subsection \<open>Sets\<close>
	+
	+lemma card_geq_ex_subset:
	+ assumes "card A \<ge> n"
	+ obtains B where "card B = n" and "B \<subseteq> A"
	+ using assms
	+proof (induct n arbitrary: thesis)
	+ case base: 0
	+ show ?case
	+ proof (rule base(1))
	+ show "card {} = 0" by simp
	+ next
	+ show "{} \<subseteq> A" ..
	+ qed
	+next
	+ case ind: (Suc n)
	+ from ind(3) have "n < card A" by simp
	+ obtain B where card: "card B = n" and "B \<subseteq> A"
	+ proof (rule ind(1))
	+ from \<open>n < card A\<close> show "n \<le> card A" by simp
	+ qed
	+ from \<open>n < card A\<close> have "card A \<noteq> 0" by simp
	+ with card_infinite[of A] have "finite A" by blast
	+ let ?C = "A - B"
	+ have "?C \<noteq> {}"
	+ proof
	+ assume "A - B = {}"
	+ hence "A \<subseteq> B" by simp
	+ from this \<open>B \<subseteq> A\<close> have "A = B" ..
	+ from \<open>n < card A\<close> show False unfolding \<open>A = B\<close> card by simp
	+ qed
	+ then obtain c where "c \<in> ?C" by auto
	+ hence "c \<notin> B" by simp
	+ hence "B - {c} = B" by simp
	+ show ?case
	+ proof (rule ind(2))
	+ thm card_insert
	+ have "card (B \<union> {c}) = card (insert c B)" by simp
	+ also have "... = Suc (card (B - {c}))"
	+ by (rule card_insert, rule finite_subset, fact \<open>B \<subseteq> A\<close>, fact)
	+ finally show "card (B \<union> {c}) = Suc n" unfolding \<open>B - {c} = B\<close> card .
	+ next
	+ show "B \<union> {c} \<subseteq> A" unfolding Un_subset_iff
	+ proof (intro conjI, fact)
	+ from \<open>c \<in> ?C\<close> show "{c} \<subseteq> A" by auto
	+ qed
	+ qed
	+qed
	+
	+lemma card_2_E_1:
	+ assumes "card A = 2" and "x \<in> A"
	+ obtains y where "x \<noteq> y" and "A = {x, y}"
	+proof -
	+ have "A - {x} \<noteq> {}"
	+ proof
	+ assume "A - {x} = {}"
	+ with assms(2) have "A = {x}" by auto
	+ hence "card A = 1" by simp
	+ with assms show False by simp
	+ qed
	+ then obtain y where "y \<in> A - {x}" by auto
	+ hence "y \<in> A" and "x \<noteq> y" by auto
	+ show ?thesis
	+ proof
	+ show "A = {x, y}"
	+ proof (rule sym, rule card_seteq)
	+ from assms(1) show "finite A" using card_infinite by fastforce
	+ next
	+ from \<open>x \<in> A\<close> \<open>y \<in> A\<close> show "{x, y} \<subseteq> A" by simp
	+ next
	+ from \<open>x \<noteq> y\<close> show "card A \<le> card {x, y}" by (simp add: assms(1))
	+ qed
	+ qed fact
	+qed
	+
	+lemma card_2_E:
	+ assumes "card A = 2"
	+ obtains x y where "x \<noteq> y" and "A = {x, y}"
	+proof -
	+ from assms have "A \<noteq> {}" by auto
	+ then obtain x where "x \<in> A" by blast
	+ with assms obtain y where "x \<noteq> y" and "A = {x, y}" by (rule card_2_E_1)
	+ thus ?thesis ..
	+qed
	+
	+subsection \<open>Sums\<close>
	+
	+lemma sum_tail_nat: "0 < b \<Longrightarrow> a \<le> (b::nat) \<Longrightarrow> sum f {a..b} = f b + sum f {a..b - 1}"
	+ by (metis One_nat_def Suc_pred add.commute not_le sum.cl_ivl_Suc)
	+
	+lemma sum_atLeast_Suc_shift: "0 < b \<Longrightarrow> a \<le> b \<Longrightarrow> sum f {Suc a..b} = (\<Sum>i=a..b - 1. f (Suc i))"
	+ by (metis Suc_pred' sum.shift_bounds_cl_Suc_ivl)
	+
	+lemma sum_split_nat_ivl:
	+ "a \<le> Suc j \<Longrightarrow> j \<le> b \<Longrightarrow> sum f {a..j} + sum f {Suc j..b} = sum f {a..b}"
	+ by (metis Suc_eq_plus1 le_Suc_ex sum.ub_add_nat)
	+
	+subsection \<open>@{const count_list}\<close>
	+
	+lemma count_list_eq_0_iff: "count_list xs x = 0 \<longleftrightarrow> x \<notin> set xs"
	+ by (induct xs) simp_all
	+
	+lemma count_list_append: "count_list (xs @ ys) x = count_list xs x + count_list ys x"
	+ by (induct xs) simp_all
	+
	+lemma count_list_map_ge: "count_list xs x \<le> count_list (map f xs) (f x)"
	+ by (induct xs) simp_all
	+
	+lemma count_list_gr_1_E:
	+ assumes "1 < count_list xs x"
	+ obtains i j where "i < j" and "j < length xs" and "xs ! i = x" and "xs ! j = x"
	+proof -
	+ from assms have "count_list xs x \<noteq> 0" by simp
	+ hence "x \<in> set xs" by (simp only: count_list_eq_0_iff not_not)
	+ then obtain ys zs where xs: "xs = ys @ x # zs" and "x \<notin> set ys" by (meson split_list_first)
	+ hence "count_list xs x = Suc (count_list zs x)" by (simp add: count_list_append)
	+ with assms have "count_list zs x \<noteq> 0" by simp
	+ hence "x \<in> set zs" by (simp only: count_list_eq_0_iff not_not)
	+ then obtain j where "j < length zs" and "x = zs ! j" by (metis in_set_conv_nth)
	+ show ?thesis
	+ proof
	+ show "length ys < length ys + Suc j" by simp
	+ next
	+ from \<open>j < length zs\<close> show "length ys + Suc j < length xs" by (simp add: xs)
	+ next
	+ show "xs ! length ys = x" by (simp add: xs)
	+ next
	+ show "xs ! (length ys + Suc j) = x"
	+ by (simp only: xs \<open>x = zs ! j\<close> nth_append_length_plus nth_Cons_Suc)
	+ qed
	+qed
	+
	+subsection \<open>@{const listset}\<close>
	+
	+lemma listset_Cons: "listset (x # xs) = (\<Union>y\<in>x. (#) y ` listset xs)"
	+ by (auto simp: set_Cons_def)
	+
	+lemma listset_ConsI: "y \<in> x \<Longrightarrow> ys' \<in> listset xs \<Longrightarrow> ys = y # ys' \<Longrightarrow> ys \<in> listset (x # xs)"
	+ by (simp add: set_Cons_def)
	+
	+lemma listset_ConsE:
	+ assumes "ys \<in> listset (x# xs)"
	+ obtains y ys' where "y \<in> x" and "ys' \<in> listset xs" and "ys = y # ys'"
	+ using assms by (auto simp: set_Cons_def)
	+
	+lemma listsetI:
	+ "length ys = length xs \<Longrightarrow> (\<And>i. i < length xs \<Longrightarrow> ys ! i \<in> xs ! i) \<Longrightarrow> ys \<in> listset xs"
	+ by (induct ys xs rule: list_induct2)
	+ (simp_all, smt Suc_mono list.sel(3) mem_Collect_eq nth_Cons_0 nth_tl set_Cons_def zero_less_Suc)
	+
	+lemma listsetD:
	+ assumes "ys \<in> listset xs"
	+ shows "length ys = length xs" and "\<And>i. i < length xs \<Longrightarrow> ys ! i \<in> xs ! i"
	+proof -
	+ from assms have "length ys = length xs \<and> (\<forall>i<length xs. ys ! i \<in> xs ! i)"
	+ proof (induct xs arbitrary: ys)
	+ case Nil
	+ thus ?case by simp
	+ next
	+ case (Cons x xs)
	+ from Cons.prems obtain y ys' where "y \<in> x" and "ys' \<in> listset xs" and ys: "ys = y # ys'"
	+ by (rule listset_ConsE)
	+ from this(2) have "length ys' = length xs \<and> (\<forall>i<length xs. ys' ! i \<in> xs ! i)" by (rule Cons.hyps)
	+ hence 1: "length ys' = length xs" and 2: "\<And>i. i < length xs \<Longrightarrow> ys' ! i \<in> xs ! i" by simp_all
	+ show ?case
	+ proof (intro conjI allI impI)
	+ fix i
	+ assume "i < length (x # xs)"
	+ show "ys ! i \<in> (x # xs) ! i"
	+ proof (cases i)
	+ case 0
	+ with \<open>y \<in> x\<close> show ?thesis by (simp add: ys)
	+ next
	+ case (Suc j)
	+ with \<open>i < length (x # xs)\<close> have "j < length xs" by simp
	+ hence "ys' ! j \<in> xs ! j" by (rule 2)
	+ thus ?thesis by (simp add: ys \<open>i = Suc j\<close>)
	+ qed
	+ qed (simp add: ys 1)
	+ qed
	+ thus "length ys = length xs" and "\<And>i. i < length xs \<Longrightarrow> ys ! i \<in> xs ! i" by simp_all
	+qed
	+
	+lemma listset_singletonI: "a \<in> A \<Longrightarrow> ys = [a] \<Longrightarrow> ys \<in> listset [A]"
	+ by simp
	+
	+lemma listset_singletonE:
	+ assumes "ys \<in> listset [A]"
	+ obtains a where "a \<in> A" and "ys = [a]"
	+ using assms by auto
	+
	+lemma listset_doubletonI: "a \<in> A \<Longrightarrow> b \<in> B \<Longrightarrow> ys = [a, b] \<Longrightarrow> ys \<in> listset [A, B]"
	+ by (simp add: set_Cons_def)
	+
	+lemma listset_doubletonE:
	+ assumes "ys \<in> listset [A, B]"
	+ obtains a b where "a \<in> A" and "b \<in> B" and "ys = [a, b]"
	+ using assms by (auto simp: set_Cons_def)
	+
	+lemma listset_appendI:
	+ "ys1 \<in> listset xs1 \<Longrightarrow> ys2 \<in> listset xs2 \<Longrightarrow> ys = ys1 @ ys2 \<Longrightarrow> ys \<in> listset (xs1 @ xs2)"
	+ by (induct xs1 arbitrary: ys ys1 ys2)
	+ (simp, auto simp del: listset.simps elim!: listset_ConsE intro!: listset_ConsI)
	+
	+lemma listset_appendE:
	+ assumes "ys \<in> listset (xs1 @ xs2)"
	+ obtains ys1 ys2 where "ys1 \<in> listset xs1" and "ys2 \<in> listset xs2" and "ys = ys1 @ ys2"
	+ using assms
	+proof (induct xs1 arbitrary: thesis ys)
	+ case Nil
	+ have "[] \<in> listset []" by simp
	+ moreover from Nil(2) have "ys \<in> listset xs2" by simp
	+ ultimately show ?case by (rule Nil) simp
	+next
	+ case (Cons x xs1)
	+ from Cons.prems(2) have "ys \<in> listset (x # (xs1 @ xs2))" by simp
	+ then obtain y ys' where "y \<in> x" and "ys' \<in> listset (xs1 @ xs2)" and ys: "ys = y # ys'"
	+ by (rule listset_ConsE)
	+ from _ this(2) obtain ys1 ys2 where ys1: "ys1 \<in> listset xs1" and "ys2 \<in> listset xs2"
	+ and ys': "ys' = ys1 @ ys2" by (rule Cons.hyps)
	+ show ?case
	+ proof (rule Cons.prems)
	+ from \<open>y \<in> x\<close> ys1 refl show "y # ys1 \<in> listset (x # xs1)" by (rule listset_ConsI)
	+ next
	+ show "ys = (y # ys1) @ ys2" by (simp add: ys ys')
	+ qed fact
	+qed
	+
	+lemma listset_map_imageI: "ys' \<in> listset xs \<Longrightarrow> ys = map f ys' \<Longrightarrow> ys \<in> listset (map ((`) f) xs)"
	+ by (induct xs arbitrary: ys ys')
	+ (simp, auto simp del: listset.simps elim!: listset_ConsE intro!: listset_ConsI)
	+
	+lemma listset_map_imageE:
	+ assumes "ys \<in> listset (map ((`) f) xs)"
	+ obtains ys' where "ys' \<in> listset xs" and "ys = map f ys'"
	+ using assms
	+proof (induct xs arbitrary: thesis ys)
	+ case Nil
	+ from Nil(2) have "ys = map f []" by simp
	+ with _ show ?case by (rule Nil) simp
	+next
	+ case (Cons x xs)
	+ from Cons.prems(2) have "ys \<in> listset (f ` x # map ((`) f) xs)" by simp
	+ then obtain y ys' where "y \<in> f ` x" and "ys' \<in> listset (map ((`) f) xs)" and ys: "ys = y # ys'"
	+ by (rule listset_ConsE)
	+ from _ this(2) obtain ys1 where ys1: "ys1 \<in> listset xs" and ys': "ys' = map f ys1" by (rule Cons.hyps)
	+ from \<open>y \<in> f ` x\<close> obtain y1 where "y1 \<in> x" and y: "y = f y1" ..
	+ show ?case
	+ proof (rule Cons.prems)
	+ from \<open>y1 \<in> x\<close> ys1 refl show "y1 # ys1 \<in> listset (x # xs)" by (rule listset_ConsI)
	+ qed (simp add: ys ys' y)
	+qed
	+
	+lemma listset_permE:
	+ assumes "ys \<in> listset xs" and "bij_betw f {..<length xs} {..<length xs'}"
	+ and "\<And>i. i < length xs \<Longrightarrow> xs' ! i = xs ! f i"
	+ obtains ys' where "ys' \<in> listset xs'" and "length ys' = length ys"
	+ and "\<And>i. i < length ys \<Longrightarrow> ys' ! i = ys ! f i"
	+proof -
	+ from assms(1) have len_ys: "length ys = length xs" by (rule listsetD)
	+ from assms(2) have "card {..<length xs} = card {..<length xs'}" by (rule bij_betw_same_card)
	+ hence len_xs: "length xs = length xs'" by simp
	+ define ys' where "ys' = map (\<lambda>i. ys ! (f i)) [0..<length ys]"
	+ have 1: "ys' ! i = ys ! f i" if "i < length ys" for i using that by (simp add: ys'_def)
	+ show ?thesis
	+ proof
	+ show "ys' \<in> listset xs'"
	+ proof (rule listsetI)
	+ show "length ys' = length xs'" by (simp add: ys'_def len_ys len_xs)
	+
	+ fix i
	+ assume "i < length xs'"
	+ hence "i < length xs" by (simp only: len_xs)
	+ hence "i < length ys" by (simp only: len_ys)
	+ hence "ys' ! i = ys ! (f i)" by (rule 1)
	+ also from assms(1) have "\<dots> \<in> xs ! (f i)"
	+ proof (rule listsetD)
	+ from \<open>i < length xs\<close> have "i \<in> {..<length xs}" by simp
	+ hence "f i \<in> f ` {..<length xs}" by (rule imageI)
	+ also from assms(2) have "\<dots> = {..<length xs'}" by (simp add: bij_betw_def)
	+ finally show "f i < length xs" by (simp add: len_xs)
	+ qed
	+ also have "\<dots> = xs' ! i" by (rule sym) (rule assms(3), fact)
	+ finally show "ys' ! i \<in> xs' ! i" .
	+ qed
	+ next
	+ show "length ys' = length ys" by (simp add: ys'_def)
	+ qed (rule 1)
	+qed
	+
	+lemma listset_closed_map:
	+ assumes "ys \<in> listset xs" and "\<And>x y. x \<in> set xs \<Longrightarrow> y \<in> x \<Longrightarrow> f y \<in> x"
	+ shows "map f ys \<in> listset xs"
	+ using assms
	+proof (induct xs arbitrary: ys)
	+ case Nil
	+ from Nil(1) show ?case by simp
	+next
	+ case (Cons x xs)
	+ from Cons.prems(1) obtain y ys' where "y \<in> x" and "ys' \<in> listset xs" and ys: "ys = y # ys'"
	+ by (rule listset_ConsE)
	+ show ?case
	+ proof (rule listset_ConsI)
	+ from _ \<open>y \<in> x\<close> show "f y \<in> x" by (rule Cons.prems) simp
	+ next
	+ show "map f ys' \<in> listset xs"
	+ proof (rule Cons.hyps)
	+ fix x0 y0
	+ assume "x0 \<in> set xs"
	+ hence "x0 \<in> set (x # xs)" by simp
	+ moreover assume "y0 \<in> x0"
	+ ultimately show "f y0 \<in> x0" by (rule Cons.prems)
	+ qed fact
	+ qed (simp add: ys)
	+qed
	+
	+lemma listset_closed_map2:
	+ assumes "ys1 \<in> listset xs" and "ys2 \<in> listset xs"
	+ and "\<And>x y1 y2. x \<in> set xs \<Longrightarrow> y1 \<in> x \<Longrightarrow> y2 \<in> x \<Longrightarrow> f y1 y2 \<in> x"
	+ shows "map2 f ys1 ys2 \<in> listset xs"
	+ using assms
	+proof (induct xs arbitrary: ys1 ys2)
	+ case Nil
	+ from Nil(1) show ?case by simp
	+next
	+ case (Cons x xs)
	+ from Cons.prems(1) obtain y1 ys1' where "y1 \<in> x" and "ys1' \<in> listset xs" and ys1: "ys1 = y1 # ys1'"
	+ by (rule listset_ConsE)
	+ from Cons.prems(2) obtain y2 ys2' where "y2 \<in> x" and "ys2' \<in> listset xs" and ys2: "ys2 = y2 # ys2'"
	+ by (rule listset_ConsE)
	+ show ?case
	+ proof (rule listset_ConsI)
	+ from _ \<open>y1 \<in> x\<close> \<open>y2 \<in> x\<close> show "f y1 y2 \<in> x" by (rule Cons.prems) simp
	+ next
	+ show "map2 f ys1' ys2' \<in> listset xs"
	+ proof (rule Cons.hyps)
	+ fix x' y1' y2'
	+ assume "x' \<in> set xs"
	+ hence "x' \<in> set (x # xs)" by simp
	+ moreover assume "y1' \<in> x'" and "y2' \<in> x'"
	+ ultimately show "f y1' y2' \<in> x'" by (rule Cons.prems)
	+ qed fact+
	+ qed (simp add: ys1 ys2)
	+qed
	+
	+lemma listset_empty_iff: "listset xs = {} \<longleftrightarrow> {} \<in> set xs"
	+ by (induct xs) (auto simp: listset_Cons simp del: listset.simps(2))
	+
	+lemma listset_mono:
	+ assumes "length xs = length ys" and "\<And>i. i < length ys \<Longrightarrow> xs ! i \<subseteq> ys ! i"
	+ shows "listset xs \<subseteq> listset ys"
	+ using assms
	+proof (induct xs ys rule: list_induct2)
	+ case Nil
	+ show ?case by simp
	+next
	+ case (Cons x xs y ys)
	+ show ?case
	+ proof
	+ fix zs'
	+ assume "zs' \<in> listset (x # xs)"
	+ then obtain z zs where "z \<in> x" and zs: "zs \<in> listset xs" and zs': "zs' = z # zs"
	+ by (rule listset_ConsE)
	+ have "0 < length (y # ys)" by simp
	+ hence "(x # xs) ! 0 \<subseteq> (y # ys) ! 0" by (rule Cons.prems)
	+ hence "x \<subseteq> y" by simp
	+ with \<open>z \<in> x\<close> have "z \<in> y" ..
	+ moreover from zs have "zs \<in> listset ys"
	+ proof
	+ show "listset xs \<subseteq> listset ys"
	+ proof (rule Cons.hyps)
	+ fix i
	+ assume "i < length ys"
	+ hence "Suc i < length (y # ys)" by simp
	+ hence "(x # xs) ! Suc i \<subseteq> (y # ys) ! Suc i" by (rule Cons.prems)
	+ thus "xs ! i \<subseteq> ys ! i" by simp
	+ qed
	+ qed
	+ ultimately show "zs' \<in> listset (y # ys)" using zs' by (rule listset_ConsI)
	+ qed
	+qed
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Groebner_Macaulay.thy b/thys/Groebner_Macaulay/Groebner_Macaulay.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Groebner_Macaulay.thy
	@@ -0,0 +1,212 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Computing Gr\"obner Bases by Triangularizing Macaulay Matrices\<close>
	+
	+theory Groebner_Macaulay
	+ imports Groebner_Bases.Macaulay_Matrix Groebner_Bases.Groebner_PM Degree_Section Degree_Bound_Utils
	+begin
	+
	+text \<open>Relationship between Gr\"obner bases and Macaulay matrices, following
	+ @{cite "Wiesinger-Widi2015"}.\<close>
	+
	+subsection \<open>Gr\"obner Bases\<close>
	+
	+lemma (in gd_term) Macaulay_list_is_GB:
	+ assumes "is_Groebner_basis G" and "pmdl (set ps) = pmdl G" and "G \<subseteq> phull (set ps)"
	+ shows "is_Groebner_basis (set (Macaulay_list ps))"
	+proof (simp only: GB_alt_3_finite[OF finite_set] pmdl_Macaulay_list, intro ballI impI)
	+ fix f
	+ assume "f \<in> pmdl (set ps)"
	+ also from assms(2) have "\<dots> = pmdl G" .
	+ finally have "f \<in> pmdl G" .
	+ assume "f \<noteq> 0"
	+ with assms(1) \<open>f \<in> pmdl G\<close> obtain g where "g \<in> G" and "g \<noteq> 0" and "lt g adds\<^sub>t lt f"
	+ by (rule GB_adds_lt)
	+ from assms(3) \<open>g \<in> G\<close> have "g \<in> phull (set ps)" ..
	+ from this \<open>g \<noteq> 0\<close> obtain g' where "g' \<in> set (Macaulay_list ps)" and "g' \<noteq> 0" and "lt g = lt g'"
	+ by (rule Macaulay_list_lt)
	+ show "\<exists>g\<in>set (Macaulay_list ps). g \<noteq> 0 \<and> lt g adds\<^sub>t lt f"
	+ proof (rule, rule)
	+ from \<open>lt g adds\<^sub>t lt f\<close> show "lt g' adds\<^sub>t lt f" by (simp only: \<open>lt g = lt g'\<close>)
	+ qed fact+
	+qed
	+
	+subsection \<open>Bounds\<close>
	+
	+context pm_powerprod
	+begin
	+
	+context
	+ fixes X :: "'x set"
	+ assumes fin_X: "finite X"
	+begin
	+
	+definition deg_shifts :: "nat \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'b) list \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'b::semiring_1) list"
	+ where "deg_shifts d fs = concat (map (\<lambda>f. (map (\<lambda>t. punit.monom_mult 1 t f)
	+ (punit.pps_to_list (deg_le_sect X (d - poly_deg f))))) fs)"
	+
	+lemma set_deg_shifts:
	+ "set (deg_shifts d fs) = (\<Union>f\<in>set fs. (\<lambda>t. punit.monom_mult 1 t f) ` (deg_le_sect X (d - poly_deg f)))"
	+proof -
	+ from fin_X have "finite (deg_le_sect X d0)" for d0 by (rule finite_deg_le_sect)
	+ thus ?thesis by (simp add: deg_shifts_def punit.set_pps_to_list)
	+qed
	+
	+corollary set_deg_shifts_singleton:
	+ "set (deg_shifts d [f]) = (\<lambda>t. punit.monom_mult 1 t f) ` (deg_le_sect X (d - poly_deg f))"
	+ by (simp add: set_deg_shifts)
	+
	+lemma deg_shifts_superset: "set fs \<subseteq> set (deg_shifts d fs)"
	+proof -
	+ have "set fs = (\<Union>f\<in>set fs. {punit.monom_mult 1 0 f})" by simp
	+ also have "\<dots> \<subseteq> set (deg_shifts d fs)" unfolding set_deg_shifts using subset_refl
	+ proof (rule UN_mono)
	+ fix f
	+ assume "f \<in> set fs"
	+ have "punit.monom_mult 1 0 f \<in> (\<lambda>t. punit.monom_mult 1 t f) ` deg_le_sect X (d - poly_deg f)"
	+ using zero_in_deg_le_sect by (rule imageI)
	+ thus "{punit.monom_mult 1 0 f} \<subseteq> (\<lambda>t. punit.monom_mult 1 t f) ` deg_le_sect X (d - poly_deg f)"
	+ by simp
	+ qed
	+ finally show ?thesis .
	+qed
	+
	+lemma deg_shifts_mono:
	+ assumes "set fs \<subseteq> set gs"
	+ shows "set (deg_shifts d fs) \<subseteq> set (deg_shifts d gs)"
	+ using assms by (auto simp add: set_deg_shifts)
	+
	+lemma ideal_deg_shifts [simp]: "ideal (set (deg_shifts d fs)) = ideal (set fs)"
	+proof
	+ show "ideal (set (deg_shifts d fs)) \<subseteq> ideal (set fs)"
	+ by (rule ideal.span_subset_spanI, simp add: set_deg_shifts UN_subset_iff,
	+ intro ballI image_subsetI) (metis ideal.span_scale times_monomial_left ideal.span_base)
	+next
	+ from deg_shifts_superset show "ideal (set fs) \<subseteq> ideal (set (deg_shifts d fs))"
	+ by (rule ideal.span_mono)
	+qed
	+
	+lemma thm_2_3_6:
	+ assumes "set fs \<subseteq> P[X]" and "is_GB_cofactor_bound (set fs) b"
	+ shows "punit.is_Groebner_basis (set (punit.Macaulay_list (deg_shifts b fs)))"
	+proof -
	+ from assms(2) finite_set assms(1) obtain G where "punit.is_Groebner_basis G"
	+ and ideal_G: "ideal G = ideal (set fs)" and G_sub: "G \<subseteq> P[X]"
	+ and 1: "\<And>g. g \<in> G \<Longrightarrow> \<exists>q. g = (\<Sum>f\<in>set fs. q f * f) \<and> (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> b)"
	+ by (rule is_GB_cofactor_boundE_finite_Polys) blast
	+ from this(1) show ?thesis
	+ proof (rule punit.Macaulay_list_is_GB)
	+ show "G \<subseteq> phull (set (deg_shifts b fs))" (is "_ \<subseteq> ?H")
	+ proof
	+ fix g
	+ assume "g \<in> G"
	+ hence "\<exists>q. g = (\<Sum>f\<in>set fs. q f * f) \<and> (\<forall>f. q f \<in> P[X] \<and> poly_deg (q f * f) \<le> b)" by (rule 1)
	+ then obtain q where g: "g = (\<Sum>f\<in>set fs. q f * f)" and "\<And>f. q f \<in> P[X]"
	+ and "\<And>f. poly_deg (q f * f) \<le> b" by blast
	+ show "g \<in> ?H" unfolding g
	+ proof (rule phull.span_sum)
	+ fix f
	+ assume "f \<in> set fs"
	+ have "1 \<noteq> (0::'a)" by simp
	+ show "q f * f \<in> ?H"
	+ proof (cases "f = 0 \<or> q f = 0")
	+ case True
	+ thus ?thesis by (auto simp add: phull.span_zero)
	+ next
	+ case False
	+ hence "q f \<noteq> 0" and "f \<noteq> 0" by simp_all
	+ with \<open>poly_deg (q f * f) \<le> b\<close> have "poly_deg (q f) \<le> b - poly_deg f"
	+ by (simp add: poly_deg_times)
	+ with \<open>q f \<in> P[X]\<close> have "keys (q f) \<subseteq> deg_le_sect X (b - poly_deg f)"
	+ by (rule keys_subset_deg_le_sectI)
	+ with finite_deg_le_sect[OF fin_X]
	+ have "q f * f = (\<Sum>t\<in>deg_le_sect X (b - poly_deg f). punit.monom_mult (lookup (q f) t) t f)"
	+ unfolding punit.mult_scalar_sum_monomials[simplified]
	+ by (rule sum.mono_neutral_left) (simp add: in_keys_iff)
	+ also have "\<dots> = (\<Sum>t\<in>deg_le_sect X (b - poly_deg f).
	+ (lookup (q f) t) \<cdot> (punit.monom_mult 1 t f))"
	+ by (simp add: punit.monom_mult_assoc punit.map_scale_eq_monom_mult)
	+ also have "\<dots> = (\<Sum>t\<in>deg_le_sect X (b - poly_deg f).
	+ ((\<lambda>f0. (lookup (q f) (punit.lp f0 - punit.lp f)) \<cdot> f0) \<circ>
	+ (\<lambda>t. punit.monom_mult 1 t f)) t)"
	+ using refl by (rule sum.cong) (simp add: punit.lt_monom_mult[OF \<open>1 \<noteq> 0\<close> \<open>f \<noteq> 0\<close>])
	+ also have "\<dots> = (\<Sum>f0\<in>set (deg_shifts b [f]). (lookup (q f) (punit.lp f0 - punit.lp f)) \<cdot> f0)"
	+ unfolding set_deg_shifts_singleton
	+ proof (intro sum.reindex[symmetric] inj_onI)
	+ fix s t
	+ assume "punit.monom_mult 1 s f = punit.monom_mult 1 t f"
	+ thus "s = t" using \<open>1 \<noteq> 0\<close> \<open>f \<noteq> 0\<close> by (rule punit.monom_mult_inj_2)
	+ qed
	+ finally have "q f * f \<in> phull (set (deg_shifts b [f]))"
	+ by (simp add: phull.sum_in_spanI)
	+ also have "\<dots> \<subseteq> ?H" by (rule phull.span_mono, rule deg_shifts_mono, simp add: \<open>f \<in> set fs\<close>)
	+ finally show ?thesis .
	+ qed
	+ qed
	+ qed
	+ qed (simp add: ideal_G)
	+qed
	+
	+lemma thm_2_3_7:
	+ assumes "set fs \<subseteq> P[X]" and "is_GB_cofactor_bound (set fs) b"
	+ shows "1 \<in> ideal (set fs) \<longleftrightarrow> 1 \<in> set (punit.Macaulay_list (deg_shifts b fs))" (is "?L \<longleftrightarrow> ?R")
	+proof
	+ assume ?L
	+ let ?G = "set (punit.Macaulay_list (deg_shifts b fs))"
	+ from assms have "punit.is_Groebner_basis ?G" by (rule thm_2_3_6)
	+ moreover from \<open>?L\<close> have "1 \<in> ideal ?G" by (simp add: punit.pmdl_Macaulay_list[simplified])
	+ moreover have "1 \<noteq> (0::_ \<Rightarrow>\<^sub>0 'a)" by simp
	+ ultimately obtain g where "g \<in> ?G" and "g \<noteq> 0" and "punit.lt g adds punit.lt (1::_ \<Rightarrow>\<^sub>0 'a)"
	+ by (rule punit.GB_adds_lt[simplified])
	+ from this(3) have lp_g: "punit.lt g = 0" by (simp add: punit.lt_monomial adds_zero flip: single_one)
	+ from punit.Macaulay_list_is_monic_set \<open>g \<in> ?G\<close> \<open>g \<noteq> 0\<close> have lc_g: "punit.lc g = 1"
	+ by (rule punit.is_monic_setD)
	+ have "g = 1"
	+ proof (rule poly_mapping_eqI)
	+ fix t
	+ show "lookup g t = lookup 1 t"
	+ proof (cases "t = 0")
	+ case True
	+ thus ?thesis using lc_g by (simp add: lookup_one punit.lc_def lp_g)
	+ next
	+ case False
	+ with zero_min[of t] have "\<not> t \<preceq> punit.lt g" by (simp add: lp_g)
	+ with punit.lt_max_keys have "t \<notin> keys g" by blast
	+ with False show ?thesis by (simp add: lookup_one in_keys_iff)
	+ qed
	+ qed
	+ with \<open>g \<in> ?G\<close> show "1 \<in> ?G" by simp
	+next
	+ assume ?R
	+ also have "\<dots> \<subseteq> phull (set (punit.Macaulay_list (deg_shifts b fs)))"
	+ by (rule phull.span_superset)
	+ also have "\<dots> = phull (set (deg_shifts b fs))" by (fact punit.phull_Macaulay_list)
	+ also have "\<dots> \<subseteq> ideal (set (deg_shifts b fs))" using punit.phull_subset_module by force
	+ finally show ?L by simp
	+qed
	+
	+end
	+
	+lemma thm_2_3_6_indets:
	+ assumes "is_GB_cofactor_bound (set fs) b"
	+ shows "punit.is_Groebner_basis (set (punit.Macaulay_list (deg_shifts (UNION (set fs) indets) b fs)))"
	+ using _ _ assms
	+proof (rule thm_2_3_6)
	+ from finite_set show "finite (UNION (set fs) indets)" by (simp add: finite_indets)
	+next
	+ show "set fs \<subseteq> P[UNION (set fs) indets]" by (auto simp: Polys_alt)
	+qed
	+
	+lemma thm_2_3_7_indets:
	+ assumes "is_GB_cofactor_bound (set fs) b"
	+ shows "1 \<in> ideal (set fs) \<longleftrightarrow> 1 \<in> set (punit.Macaulay_list (deg_shifts (UNION (set fs) indets) b fs))"
	+ using _ _ assms
	+proof (rule thm_2_3_7)
	+ from finite_set show "finite (UNION (set fs) indets)" by (simp add: finite_indets)
	+next
	+ show "set fs \<subseteq> P[UNION (set fs) indets]" by (auto simp: Polys_alt)
	+qed
	+
	+end (* pm_powerprod *)
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Groebner_Macaulay_Examples.thy b/thys/Groebner_Macaulay/Groebner_Macaulay_Examples.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Groebner_Macaulay_Examples.thy
	@@ -0,0 +1,652 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Sample Computations of Gr\"obner Bases via Macaulay Matrices\<close>
	+
	+theory Groebner_Macaulay_Examples
	+ imports
	+ Groebner_Macaulay
	+ Dube_Bound
	+ Groebner_Bases.Benchmarks
	+ Jordan_Normal_Form.Gauss_Jordan_IArray_Impl
	+ Groebner_Bases.Code_Target_Rat
	+begin
	+
	+subsection \<open>Combining @{theory Groebner_Macaulay.Groebner_Macaulay} and
	+ @{theory Groebner_Macaulay.Dube_Bound}\<close>
	+
	+context extended_ord_pm_powerprod
	+begin
	+
	+theorem thm_2_3_6_Dube:
	+ assumes "finite X" and "set fs \<subseteq> P[X]"
	+ shows "punit.is_Groebner_basis (set (punit.Macaulay_list
	+ (deg_shifts X (Dube (Suc (card X)) (maxdeg (set fs))) fs)))"
	+ using assms Dube_is_GB_cofactor_bound by (rule thm_2_3_6) (simp_all add: assms)
	+
	+theorem thm_2_3_7_Dube:
	+ assumes "finite X" and "set fs \<subseteq> P[X]"
	+ shows "1 \<in> ideal (set fs) \<longleftrightarrow>
	+ 1 \<in> set (punit.Macaulay_list (deg_shifts X (Dube (Suc (card X)) (maxdeg (set fs))) fs))"
	+ using assms Dube_is_GB_cofactor_bound by (rule thm_2_3_7) (simp_all add: assms)
	+
	+theorem thm_2_3_6_indets_Dube:
	+ fixes fs
	+ defines "X \<equiv> UNION (set fs) indets"
	+ shows "punit.is_Groebner_basis (set (punit.Macaulay_list
	+ (deg_shifts X (Dube (Suc (card X)) (maxdeg (set fs))) fs)))"
	+ unfolding X_def using Dube_is_GB_cofactor_bound_indets by (rule thm_2_3_6_indets) (fact finite_set)
	+
	+theorem thm_2_3_7_indets_Dube:
	+ fixes fs
	+ defines "X \<equiv> UNION (set fs) indets"
	+ shows "1 \<in> ideal (set fs) \<longleftrightarrow>
	+ 1 \<in> set (punit.Macaulay_list (deg_shifts X (Dube (Suc (card X)) (maxdeg (set fs))) fs))"
	+ unfolding X_def using Dube_is_GB_cofactor_bound_indets by (rule thm_2_3_7_indets) (fact finite_set)
	+
	+end (* extended_ord_pm_powerprod *)
	+
	+subsection \<open>Preparations\<close>
	+
	+(* This is exactly the same as in "Groebner_Bases.F4_Examples". Pull out into common ancestor? *)
	+
	+primrec remdups_wrt_rev :: "('a \<Rightarrow> 'b) \<Rightarrow> 'a list \<Rightarrow> 'b list \<Rightarrow> 'a list" where
	+ "remdups_wrt_rev f [] vs = []" \|
	+ "remdups_wrt_rev f (x # xs) vs =
	+ (let fx = f x in if List.member vs fx then remdups_wrt_rev f xs vs else x # (remdups_wrt_rev f xs (fx # vs)))"
	+
	+lemma remdups_wrt_rev_notin: "v \<in> set vs \<Longrightarrow> v \<notin> f ` set (remdups_wrt_rev f xs vs)"
	+proof (induct xs arbitrary: vs)
	+ case Nil
	+ show ?case by simp
	+next
	+ case (Cons x xs)
	+ from Cons(2) have 1: "v \<notin> f ` set (remdups_wrt_rev f xs vs)" by (rule Cons(1))
	+ from Cons(2) have "v \<in> set (f x # vs)" by simp
	+ hence 2: "v \<notin> f ` set (remdups_wrt_rev f xs (f x # vs))" by (rule Cons(1))
	+ from Cons(2) show ?case by (auto simp: Let_def 1 2 List.member_def)
	+qed
	+
	+lemma distinct_remdups_wrt_rev: "distinct (map f (remdups_wrt_rev f xs vs))"
	+proof (induct xs arbitrary: vs)
	+ case Nil
	+ show ?case by simp
	+next
	+ case (Cons x xs)
	+ show ?case by (simp add: Let_def Cons(1) remdups_wrt_rev_notin)
	+qed
	+
	+lemma map_of_remdups_wrt_rev':
	+ "map_of (remdups_wrt_rev fst xs vs) k = map_of (filter (\<lambda>x. fst x \<notin> set vs) xs) k"
	+proof (induct xs arbitrary: vs)
	+ case Nil
	+ show ?case by simp
	+next
	+ case (Cons x xs)
	+ show ?case
	+ proof (simp add: Let_def List.member_def Cons, intro impI)
	+ assume "k \<noteq> fst x"
	+ have "map_of (filter (\<lambda>y. fst y \<noteq> fst x \<and> fst y \<notin> set vs) xs) =
	+ map_of (filter (\<lambda>y. fst y \<noteq> fst x) (filter (\<lambda>y. fst y \<notin> set vs) xs))"
	+ by (simp only: filter_filter conj_commute)
	+ also have "... = map_of (filter (\<lambda>y. fst y \<notin> set vs) xs) \|` {y. y \<noteq> fst x}" by (rule map_of_filter)
	+ finally show "map_of (filter (\<lambda>y. fst y \<noteq> fst x \<and> fst y \<notin> set vs) xs) k =
	+ map_of (filter (\<lambda>y. fst y \<notin> set vs) xs) k"
	+ by (simp add: restrict_map_def \<open>k \<noteq> fst x\<close>)
	+ qed
	+qed
	+
	+corollary map_of_remdups_wrt_rev: "map_of (remdups_wrt_rev fst xs []) = map_of xs"
	+ by (rule ext, simp add: map_of_remdups_wrt_rev')
	+
	+lemma (in term_powerprod) compute_list_to_poly [code]:
	+ "list_to_poly ts cs = distr\<^sub>0 DRLEX (remdups_wrt_rev fst (zip ts cs) [])"
	+ by (rule poly_mapping_eqI,
	+ simp add: lookup_list_to_poly list_to_fun_def distr\<^sub>0_def oalist_of_list_ntm_def
	+ oa_ntm.lookup_oalist_of_list distinct_remdups_wrt_rev lookup_dflt_def map_of_remdups_wrt_rev)
	+
	+lemma (in ordered_term) compute_Macaulay_list [code]:
	+ "Macaulay_list ps =
	+ (let ts = Keys_to_list ps in
	+ filter (\<lambda>p. p \<noteq> 0) (mat_to_polys ts (row_echelon (polys_to_mat ts ps)))
	+ )"
	+ by (simp add: Macaulay_list_def Macaulay_mat_def Let_def)
	+
	+declare conversep_iff [code]
	+
	+derive (eq) ceq poly_mapping
	+derive (no) ccompare poly_mapping
	+derive (dlist) set_impl poly_mapping
	+derive (no) cenum poly_mapping
	+
	+derive (eq) ceq rat
	+derive (no) ccompare rat
	+derive (dlist) set_impl rat
	+derive (no) cenum rat
	+
	+subsubsection \<open>Connection between @{typ "('x \<Rightarrow>\<^sub>0 'a) \<Rightarrow>\<^sub>0 'b"} and @{typ "('x, 'a) pp \<Rightarrow>\<^sub>0 'b"}\<close>
	+
	+(* Move into "Polynomials.PP_Type"? *)
	+
	+definition keys_pp_to_list :: "('x::linorder, 'a::zero) pp \<Rightarrow> 'x list"
	+ where "keys_pp_to_list t = sorted_list_of_set (keys_pp t)"
	+
	+lemma inj_PP: "inj PP"
	+ by (simp add: PP_inject inj_def)
	+
	+lemma inj_mapping_of: "inj mapping_of"
	+ by (simp add: mapping_of_inject inj_def)
	+
	+lemma mapping_of_comp_PP [simp]:
	+ "mapping_of \<circ> PP = (\<lambda>x. x)"
	+ "PP \<circ> mapping_of = (\<lambda>x. x)"
	+ by (simp_all add: comp_def PP_inverse mapping_of_inverse)
	+
	+lemma map_key_PP_mapping_of [simp]: "Poly_Mapping.map_key PP (Poly_Mapping.map_key mapping_of p) = p"
	+ by (simp add: map_key_compose[OF inj_PP inj_mapping_of] comp_def PP_inverse map_key_id)
	+
	+lemma map_key_mapping_of_PP [simp]: "Poly_Mapping.map_key mapping_of (Poly_Mapping.map_key PP p) = p"
	+ by (simp add: map_key_compose[OF inj_mapping_of inj_PP] comp_def mapping_of_inverse map_key_id)
	+
	+lemmas map_key_PP_plus = map_key_plus[OF inj_PP]
	+lemmas map_key_PP_zero [simp] = map_key_zero[OF inj_PP]
	+
	+lemma lookup_map_key_PP: "lookup (Poly_Mapping.map_key PP p) t = lookup p (PP t)"
	+ by (simp add: map_key.rep_eq inj_PP)
	+
	+lemma keys_map_key_PP: "keys (Poly_Mapping.map_key PP p) = mapping_of ` keys p"
	+ by (simp add: keys_map_key inj_PP)
	+ (smt Collect_cong PP_inverse UNIV_I image_def pp.mapping_of_inverse vimage_def)
	+
	+lemma map_key_PP_zero_iff [iff]: "Poly_Mapping.map_key PP p = 0 \<longleftrightarrow> p = 0"
	+ by (metis map_key_PP_zero map_key_mapping_of_PP)
	+
	+lemma map_key_PP_uminus [simp]: "Poly_Mapping.map_key PP (- p) = - Poly_Mapping.map_key PP p"
	+ by (rule poly_mapping_eqI) (simp add: lookup_map_key_PP)
	+
	+lemma map_key_PP_minus:
	+ "Poly_Mapping.map_key PP (p - q) = Poly_Mapping.map_key PP p - Poly_Mapping.map_key PP q"
	+ by (rule poly_mapping_eqI) (simp add: lookup_map_key_PP lookup_minus)
	+
	+lemma map_key_PP_monomial [simp]: "Poly_Mapping.map_key PP (monomial c t) = monomial c (mapping_of t)"
	+proof -
	+ have "Poly_Mapping.map_key PP (monomial c t) = Poly_Mapping.map_key PP (monomial c (PP (mapping_of t)))"
	+ by (simp only: mapping_of_inverse)
	+ also from inj_PP have "\<dots> = monomial c (mapping_of t)" by (fact map_key_single)
	+ finally show ?thesis .
	+qed
	+
	+lemma map_key_PP_one [simp]: "Poly_Mapping.map_key PP 1 = 1"
	+ by (simp add: zero_pp.rep_eq flip: single_one)
	+
	+lemma map_key_PP_monom_mult_punit:
	+ "Poly_Mapping.map_key PP (monom_mult_punit c t p) =
	+ monom_mult_punit c (mapping_of t) (Poly_Mapping.map_key PP p)"
	+ by (rule poly_mapping_eqI)
	+ (simp add: punit.lookup_monom_mult monom_mult_punit_def adds_pp_iff PP_inverse lookup_map_key_PP
	+ mapping_of_inverse flip: minus_pp.abs_eq)
	+
	+lemma map_key_PP_times:
	+ "Poly_Mapping.map_key PP (p * q) =
	+ Poly_Mapping.map_key PP p * Poly_Mapping.map_key PP (q::(_, _::add_linorder) pp \<Rightarrow>\<^sub>0 _)"
	+ by (induct p rule: poly_mapping_plus_induct)
	+ (simp_all add: distrib_right map_key_PP_plus times_monomial_left map_key_PP_monom_mult_punit
	+ flip: monom_mult_punit_def)
	+
	+lemma map_key_PP_sum: "Poly_Mapping.map_key PP (sum f A) = (\<Sum>a\<in>A. Poly_Mapping.map_key PP (f a))"
	+ by (induct A rule: infinite_finite_induct) (simp_all add: map_key_PP_plus)
	+
	+lemma map_key_PP_ideal:
	+ "Poly_Mapping.map_key PP ` ideal F = ideal (Poly_Mapping.map_key PP ` (F::((_, _::add_linorder) pp \<Rightarrow>\<^sub>0 _) set))"
	+proof -
	+ from map_key_PP_mapping_of have "surj (Poly_Mapping.map_key PP)" by (rule surjI)
	+ with map_key_PP_plus map_key_PP_times show ?thesis by (rule image_ideal_eq_surj)
	+qed
	+
	+subsubsection \<open>Locale \<open>pp_powerprod\<close>\<close>
	+
	+text \<open>We have to introduce a new locale analogous to @{locale pm_powerprod}, but this time for
	+ power-products represented by @{type pp} rather than @{type poly_mapping}. This apparently leads
	+ to some (more-or-less) duplicate definitions and lemmas, but seems to be the only feasible way to
	+ get both
	+ \<^item> the convenient representation by @{type poly_mapping} for theory development, and
	+ \<^item> the executable representation by @{type pp} for code generation.\<close>
	+
	+locale pp_powerprod =
	+ ordered_powerprod ord ord_strict
	+ for ord::"('x::{countable,linorder}, nat) pp \<Rightarrow> ('x, nat) pp \<Rightarrow> bool"
	+ and ord_strict
	+begin
	+
	+sublocale gd_powerprod ..
	+
	+sublocale pp_pm: extended_ord_pm_powerprod "\<lambda>s t. ord (PP s) (PP t)" "\<lambda>s t. ord_strict (PP s) (PP t)"
	+ by standard (auto simp: zero_min plus_monotone simp flip: zero_pp_def plus_pp.abs_eq PP_inject)
	+
	+definition poly_deg_pp :: "(('x, nat) pp \<Rightarrow>\<^sub>0 'a::zero) \<Rightarrow> nat"
	+ where "poly_deg_pp p = (if p = 0 then 0 else max_list (map deg_pp (punit.keys_to_list p)))"
	+
	+primrec deg_le_sect_pp_aux :: "'x list \<Rightarrow> nat \<Rightarrow> ('x, nat) pp \<Rightarrow>\<^sub>0 nat" where
	+ "deg_le_sect_pp_aux xs 0 = 1" \|
	+ "deg_le_sect_pp_aux xs (Suc n) =
	+ (let p = deg_le_sect_pp_aux xs n in p + foldr (\<lambda>x. (+) (monom_mult_punit 1 (single_pp x 1) p)) xs 0)"
	+
	+definition deg_le_sect_pp :: "'x list \<Rightarrow> nat \<Rightarrow> ('x, nat) pp list"
	+ where "deg_le_sect_pp xs d = punit.keys_to_list (deg_le_sect_pp_aux xs d)"
	+
	+definition deg_shifts_pp :: "'x list \<Rightarrow> nat \<Rightarrow>
	+ (('x, nat) pp \<Rightarrow>\<^sub>0 'b) list \<Rightarrow> (('x, nat) pp \<Rightarrow>\<^sub>0 'b::semiring_1) list"
	+ where "deg_shifts_pp xs d fs = concat (map (\<lambda>f. (map (\<lambda>t. monom_mult_punit 1 t f)
	+ (deg_le_sect_pp xs (d - poly_deg_pp f)))) fs)"
	+
	+definition indets_pp :: "(('x, nat) pp \<Rightarrow>\<^sub>0 'b::zero) \<Rightarrow> 'x list"
	+ where "indets_pp p = remdups (concat (map keys_pp_to_list (punit.keys_to_list p)))"
	+
	+definition Indets_pp :: "(('x, nat) pp \<Rightarrow>\<^sub>0 'b::zero) list \<Rightarrow> 'x list"
	+ where "Indets_pp ps = remdups (concat (map indets_pp ps))"
	+
	+lemma map_PP_insort:
	+ "map PP (pp_pm.ordered_powerprod_lin.insort x xs) = ordered_powerprod_lin.insort (PP x) (map PP xs)"
	+ by (induct xs) simp_all
	+
	+lemma map_PP_sorted_list_of_set:
	+ "map PP (pp_pm.ordered_powerprod_lin.sorted_list_of_set T) =
	+ ordered_powerprod_lin.sorted_list_of_set (PP ` T)"
	+proof (induct T rule: infinite_finite_induct)
	+ case (infinite T)
	+ moreover from inj_PP subset_UNIV have "inj_on PP T" by (rule inj_on_subset)
	+ ultimately show ?case by (simp add: inj_PP finite_image_iff)
	+next
	+ case empty
	+ show ?case by simp
	+next
	+ case (insert t T)
	+ moreover from insert(2) have "PP t \<notin> PP ` T" by (simp add: PP_inject image_iff)
	+ ultimately show ?case by (simp add: map_PP_insort)
	+qed
	+
	+lemma map_PP_pps_to_list: "map PP (pp_pm.punit.pps_to_list T) = punit.pps_to_list (PP ` T)"
	+ by (simp add: pp_pm.punit.pps_to_list_def punit.pps_to_list_def map_PP_sorted_list_of_set flip: rev_map)
	+
	+lemma map_mapping_of_pps_to_list:
	+ "map mapping_of (punit.pps_to_list T) = pp_pm.punit.pps_to_list (mapping_of ` T)"
	+proof -
	+ have "map mapping_of (punit.pps_to_list T) = map mapping_of (punit.pps_to_list (PP ` mapping_of ` T))"
	+ by (simp add: image_comp)
	+ also have "\<dots> = map mapping_of (map PP (pp_pm.punit.pps_to_list (mapping_of ` T)))"
	+ by (simp only: map_PP_pps_to_list)
	+ also have "\<dots> = pp_pm.punit.pps_to_list (mapping_of ` T)" by simp
	+ finally show ?thesis .
	+qed
	+
	+lemma keys_to_list_map_key_PP:
	+ "pp_pm.punit.keys_to_list (Poly_Mapping.map_key PP p) = map mapping_of (punit.keys_to_list p)"
	+ by (simp add: pp_pm.punit.keys_to_list_def punit.keys_to_list_def keys_map_key_PP map_mapping_of_pps_to_list)
	+
	+lemma Keys_to_list_map_key_PP:
	+ "pp_pm.punit.Keys_to_list (map (Poly_Mapping.map_key PP) fs) = map mapping_of (punit.Keys_to_list fs)"
	+ by (simp add: punit.Keys_to_list_eq_pps_to_list pp_pm.punit.Keys_to_list_eq_pps_to_list
	+ map_mapping_of_pps_to_list Keys_def image_UN keys_map_key_PP)
	+
	+lemma poly_deg_map_key_PP: "poly_deg (Poly_Mapping.map_key PP p) = poly_deg_pp p"
	+proof -
	+ {
	+ assume "p \<noteq> 0"
	+ hence "map deg_pp (punit.keys_to_list p) \<noteq> []"
	+ by (simp add: punit.keys_to_list_def punit.pps_to_list_def)
	+ hence "Max (deg_pp ` keys p) = max_list (map deg_pp (punit.keys_to_list p))"
	+ by (simp add: max_list_Max punit.set_keys_to_list)
	+ }
	+ thus ?thesis
	+ by (simp add: poly_deg_def poly_deg_pp_def keys_map_key_PP image_image flip: deg_pp.rep_eq)
	+qed
	+
	+lemma deg_le_sect_pp_aux_1:
	+ assumes "t \<in> keys (deg_le_sect_pp_aux xs n)"
	+ shows "deg_pp t \<le> n" and "keys_pp t \<subseteq> set xs"
	+proof -
	+ from assms have "deg_pp t \<le> n \<and> keys_pp t \<subseteq> set xs"
	+ proof (induct n arbitrary: t)
	+ case 0
	+ thus ?case by (simp_all add: keys_pp.rep_eq zero_pp.rep_eq)
	+ next
	+ case (Suc n)
	+ define X where "X = set xs"
	+ define q where "q = deg_le_sect_pp_aux xs n"
	+ have 1: "s \<in> keys q \<Longrightarrow> deg_pp s \<le> n \<and> keys_pp s \<subseteq> X" for s unfolding q_def X_def by (fact Suc.hyps)
	+ note Suc.prems
	+ also have "keys (deg_le_sect_pp_aux xs (Suc n)) \<subseteq> keys q \<union>
	+ keys (foldr (\<lambda>x. (+) (monom_mult_punit 1 (single_pp x 1) q)) xs 0)"
	+ (is "_ \<subseteq> _ \<union> keys (foldr ?r xs 0)") by (simp add: Let_def Poly_Mapping.keys_add flip: q_def)
	+ finally show ?case
	+ proof
	+ assume "t \<in> keys q"
	+ hence "deg_pp t \<le> n \<and> keys_pp t \<subseteq> set xs" unfolding q_def by (rule Suc.hyps)
	+ thus ?thesis by simp
	+ next
	+ assume "t \<in> keys (foldr ?r xs 0)"
	+ moreover have "set xs \<subseteq> X" by (simp add: X_def)
	+ ultimately have "deg_pp t \<le> Suc n \<and> keys_pp t \<subseteq> X"
	+ proof (induct xs arbitrary: t)
	+ case Nil
	+ thus ?case by simp
	+ next
	+ case (Cons x xs)
	+ from Cons.prems(2) have "x \<in> X" and "set xs \<subseteq> X" by simp_all
	+ note Cons.prems(1)
	+ also have "keys (foldr ?r (x # xs) 0) \<subseteq> keys (?r x 0) \<union> keys (foldr ?r xs 0)"
	+ by (simp add: Poly_Mapping.keys_add)
	+ finally show ?case
	+ proof
	+ assume "t \<in> keys (?r x 0)"
	+ also have "\<dots> = (+) (single_pp x 1) ` keys q"
	+ by (simp add: monom_mult_punit_def punit.keys_monom_mult)
	+ finally obtain s where "s \<in> keys q" and t: "t = single_pp x 1 + s" ..
	+ from this(1) have "deg_pp s \<le> n \<and> keys_pp s \<subseteq> X" by (rule 1)
	+ with \<open>x \<in> X\<close> show ?thesis
	+ by (simp add: t deg_pp_plus deg_pp_single keys_pp.rep_eq plus_pp.rep_eq
	+ keys_plus_ninv_comm_monoid_add single_pp.rep_eq)
	+ next
	+ assume "t \<in> keys (foldr ?r xs 0)"
	+ thus "deg_pp t \<le> Suc n \<and> keys_pp t \<subseteq> X" using \<open>set xs \<subseteq> X\<close> by (rule Cons.hyps)
	+ qed
	+ qed
	+ thus ?thesis by (simp only: X_def)
	+ qed
	+ qed
	+ thus "deg_pp t \<le> n" and "keys_pp t \<subseteq> set xs" by simp_all
	+qed
	+
	+lemma deg_le_sect_pp_aux_2:
	+ assumes "deg_pp t \<le> n" and "keys_pp t \<subseteq> set xs"
	+ shows "t \<in> keys (deg_le_sect_pp_aux xs n)"
	+ using assms
	+proof (induct n arbitrary: t)
	+ case 0
	+ thus ?case by simp
	+next
	+ case (Suc n)
	+ have foldr: "foldr (\<lambda>x. (+) (f x)) ys 0 + y = foldr (\<lambda>x. (+) (f x)) ys y"
	+ for f ys and y::"'z::monoid_add" by (induct ys) (simp_all add: ac_simps)
	+ define q where "q = deg_le_sect_pp_aux xs n"
	+ from Suc.prems(1) have "deg_pp t \<le> n \<or> deg_pp t = Suc n" by auto
	+ thus ?case
	+ proof
	+ assume "deg_pp t \<le> n"
	+ hence "t \<in> keys q" unfolding q_def using Suc.prems(2) by (rule Suc.hyps)
	+ hence "0 < lookup q t" by (simp add: in_keys_iff)
	+ also have "\<dots> \<le> lookup (deg_le_sect_pp_aux xs (Suc n)) t"
	+ by (simp add: Let_def lookup_add flip: q_def)
	+ finally show ?thesis by (simp add: in_keys_iff)
	+ next
	+ assume eq: "deg_pp t = Suc n"
	+ hence "keys_pp t \<noteq> {}" by (auto simp: keys_pp.rep_eq deg_pp.rep_eq)
	+ then obtain x where "x \<in> keys_pp t" by blast
	+ with Suc.prems(2) have "x \<in> set xs" ..
	+ then obtain xs1 xs2 where xs: "xs = xs1 @ x # xs2" by (meson split_list)
	+ define s where "s = t - single_pp x 1"
	+ from \<open>x \<in> keys_pp t\<close> have "single_pp x 1 adds t"
	+ by (simp add: adds_pp_iff single_pp.rep_eq keys_pp.rep_eq adds_poly_mapping le_fun_def
	+ lookup_single when_def in_keys_iff)
	+ hence "s + single_pp x 1 = (t + single_pp x 1) - single_pp x 1"
	+ unfolding s_def by (rule minus_plus)
	+ hence t: "t = single_pp x 1 + s" by (simp add: add.commute)
	+ with eq have "deg_pp s \<le> n" by (simp add: deg_pp_plus deg_pp_single)
	+ moreover have "keys_pp s \<subseteq> set xs"
	+ proof (rule subset_trans)
	+ from Suc.prems(2) \<open>x \<in> set xs\<close> show "keys_pp t \<union> keys_pp (single_pp x (Suc 0)) \<subseteq> set xs"
	+ by (simp add: keys_pp.rep_eq single_pp.rep_eq)
	+ qed (simp add: s_def keys_pp.rep_eq minus_pp.rep_eq keys_diff)
	+ ultimately have "s \<in> keys q" unfolding q_def by (rule Suc.hyps)
	+ hence "t \<in> keys (monom_mult_punit 1 (single_pp x 1) q)"
	+ by (simp add: monom_mult_punit_def punit.keys_monom_mult t)
	+ hence "0 < lookup (monom_mult_punit 1 (single_pp x 1) q) t" by (simp add: in_keys_iff)
	+ also have "\<dots> \<le> lookup (q + (foldr (\<lambda>x. (+) (monom_mult_punit 1 (single_pp x 1) q)) xs1 0 +
	+ (monom_mult_punit 1 (single_pp x 1) q +
	+ foldr (\<lambda>x. (+) (monom_mult_punit 1 (single_pp x 1) q)) xs2 0))) t"
	+ by (simp add: lookup_add)
	+ also have "\<dots> = lookup (deg_le_sect_pp_aux xs (Suc n)) t"
	+ by (simp add: Let_def foldr flip: q_def, simp add: xs)
	+ finally show ?thesis by (simp add: in_keys_iff)
	+ qed
	+qed
	+
	+lemma keys_deg_le_sect_pp_aux:
	+ "keys (deg_le_sect_pp_aux xs n) = {t. deg_pp t \<le> n \<and> keys_pp t \<subseteq> set xs}"
	+ by (auto dest: deg_le_sect_pp_aux_1 deg_le_sect_pp_aux_2)
	+
	+lemma deg_le_sect_deg_le_sect_pp:
	+ "map PP (pp_pm.punit.pps_to_list (deg_le_sect (set xs) d)) = deg_le_sect_pp xs d"
	+proof -
	+ have "PP ` {t. deg_pm t \<le> d \<and> keys t \<subseteq> set xs} = PP ` {t. deg_pp (PP t) \<le> d \<and> keys_pp (PP t) \<subseteq> set xs}"
	+ by (simp only: keys_pp.abs_eq deg_pp.abs_eq)
	+ also have "\<dots> = {t. deg_pp t \<le> d \<and> keys_pp t \<subseteq> set xs}"
	+ proof (intro subset_antisym subsetI)
	+ fix t
	+ assume "t \<in> {t. deg_pp t \<le> d \<and> keys_pp t \<subseteq> set xs}"
	+ moreover have "t = PP (mapping_of t)" by (simp only: mapping_of_inverse)
	+ ultimately show "t \<in> PP ` {t. deg_pp (PP t) \<le> d \<and> keys_pp (PP t) \<subseteq> set xs}" by auto
	+ qed auto
	+ finally show ?thesis
	+ by (simp add: deg_le_sect_pp_def punit.keys_to_list_def keys_deg_le_sect_pp_aux deg_le_sect_alt
	+ PPs_def conj_commute map_PP_pps_to_list flip: Collect_conj_eq)
	+qed
	+
	+lemma deg_shifts_deg_shifts_pp:
	+ "pp_pm.deg_shifts (set xs) d (map (Poly_Mapping.map_key PP) fs) =
	+ map (Poly_Mapping.map_key PP) (deg_shifts_pp xs d fs)"
	+ by (simp add: pp_pm.deg_shifts_def deg_shifts_pp_def map_concat comp_def poly_deg_map_key_PP
	+ map_key_PP_monom_mult_punit PP_inverse flip: deg_le_sect_deg_le_sect_pp monom_mult_punit_def)
	+
	+lemma ideal_deg_shifts_pp: "ideal (set (deg_shifts_pp xs d fs)) = ideal (set fs)"
	+proof -
	+ have "ideal (set (deg_shifts_pp xs d fs)) =
	+ Poly_Mapping.map_key mapping_of ` Poly_Mapping.map_key PP ` ideal (set (deg_shifts_pp xs d fs))"
	+ by (simp add: image_comp)
	+ also have "\<dots> = Poly_Mapping.map_key mapping_of ` ideal
	+ (set (map (Poly_Mapping.map_key PP) (deg_shifts_pp xs d fs)))"
	+ by (simp add: map_key_PP_ideal)
	+ also have "\<dots> = Poly_Mapping.map_key mapping_of ` ideal (Poly_Mapping.map_key PP ` set fs)"
	+ by (simp flip: deg_shifts_deg_shifts_pp)
	+ also have "\<dots> = Poly_Mapping.map_key mapping_of ` Poly_Mapping.map_key PP ` ideal (set fs)"
	+ by (simp only: map_key_PP_ideal)
	+ also have "\<dots> = ideal (set fs)" by (simp add: image_comp)
	+ finally show ?thesis .
	+qed
	+
	+lemma set_indets_pp: "set (indets_pp p) = indets (Poly_Mapping.map_key PP p)"
	+ by (simp add: indets_pp_def indets_def keys_pp_to_list_def keys_pp.rep_eq punit.set_keys_to_list
	+ keys_map_key_PP)
	+
	+lemma poly_to_row_map_key_PP:
	+ "poly_to_row (map pp.mapping_of xs) (Poly_Mapping.map_key PP p) = poly_to_row xs p"
	+ by (simp add: poly_to_row_def comp_def lookup_map_key_PP mapping_of_inverse)
	+
	+lemma Macaulay_mat_map_key_PP:
	+ "pp_pm.punit.Macaulay_mat (map (Poly_Mapping.map_key PP) fs) = punit.Macaulay_mat fs"
	+ by (simp add: punit.Macaulay_mat_def pp_pm.punit.Macaulay_mat_def Keys_to_list_map_key_PP
	+ polys_to_mat_def comp_def poly_to_row_map_key_PP)
	+
	+lemma row_to_poly_mapping_of:
	+ assumes "distinct ts" and "dim_vec r = length ts"
	+ shows "row_to_poly (map pp.mapping_of ts) r = Poly_Mapping.map_key PP (row_to_poly ts r)"
	+proof (rule poly_mapping_eqI, simp only: lookup_map_key_PP)
	+ fix t
	+ let ?ts = "map mapping_of ts"
	+ from inj_mapping_of subset_UNIV have "inj_on mapping_of (set ts)" by (rule inj_on_subset)
	+ with assms(1) have 1: "distinct ?ts" by (simp add: distinct_map)
	+ from assms(2) have 2: "dim_vec r = length ?ts" by simp
	+ show "lookup (row_to_poly ?ts r) t = lookup (row_to_poly ts r) (PP t)"
	+ proof (cases "t \<in> set ?ts")
	+ case True
	+ then obtain i where i1: "i < length ?ts" and t1: "t = ?ts ! i" by (metis in_set_conv_nth)
	+ hence i2: "i < length ts" and t2: "PP t = ts ! i" by (simp_all add: mapping_of_inverse)
	+ have "lookup (row_to_poly ?ts r) t = r $ i"
	+ unfolding t1 using 1 2 i1 by (rule punit.lookup_row_to_poly)
	+ moreover have "lookup (row_to_poly ts r) (PP t) = r $ i"
	+ unfolding t2 using assms i2 by (rule punit.lookup_row_to_poly)
	+ ultimately show ?thesis by simp
	+ next
	+ case False
	+ have "PP t \<notin> set ts"
	+ proof
	+ assume "PP t \<in> set ts"
	+ hence "mapping_of (PP t) \<in> mapping_of ` set ts" by (rule imageI)
	+ with False show False by (simp add: PP_inverse)
	+ qed
	+ with punit.keys_row_to_poly have "lookup (row_to_poly ts r) (PP t) = 0"
	+ by (metis in_keys_iff in_mono)
	+ moreover from False punit.keys_row_to_poly have "lookup (row_to_poly ?ts r) t = 0"
	+ by (metis in_keys_iff in_mono)
	+ ultimately show ?thesis by simp
	+ qed
	+qed
	+
	+lemma mat_to_polys_mapping_of:
	+ assumes "distinct ts" and "dim_col m = length ts"
	+ shows "mat_to_polys (map pp.mapping_of ts) m = map (Poly_Mapping.map_key PP) (mat_to_polys ts m)"
	+proof -
	+ {
	+ fix r
	+ assume "r \<in> set (rows m)"
	+ then obtain i where "r = row m i" by (auto simp: rows_def)
	+ hence "dim_vec r = length ts" by (simp add: assms(2))
	+ with assms(1) have "row_to_poly (map pp.mapping_of ts) r = Poly_Mapping.map_key PP (row_to_poly ts r)"
	+ by (rule row_to_poly_mapping_of)
	+ }
	+ thus ?thesis using assms by (simp add: mat_to_polys_def)
	+qed
	+
	+lemma map_key_PP_Macaulay_list:
	+ "map (Poly_Mapping.map_key PP) (punit.Macaulay_list fs) =
	+ pp_pm.punit.Macaulay_list (map (Poly_Mapping.map_key PP) fs)"
	+ by (simp add: punit.Macaulay_list_def pp_pm.punit.Macaulay_list_def Macaulay_mat_map_key_PP
	+ Keys_to_list_map_key_PP mat_to_polys_mapping_of filter_map comp_def
	+ punit.distinct_Keys_to_list punit.length_Keys_to_list)
	+
	+lemma lpp_map_key_PP: "pp_pm.lpp (Poly_Mapping.map_key PP p) = mapping_of (lpp p)"
	+proof (cases "p = 0")
	+ case True
	+ thus ?thesis by (simp add: zero_pp.rep_eq)
	+next
	+ case False
	+ show ?thesis
	+ proof (rule pp_pm.punit.lt_eqI_keys)
	+ show "pp.mapping_of (lpp p) \<in> keys (Poly_Mapping.map_key PP p)" unfolding keys_map_key_PP
	+ by (intro imageI punit.lt_in_keys False)
	+ next
	+ fix s
	+ assume "s \<in> keys (Poly_Mapping.map_key PP p)"
	+ then obtain t where "t \<in> keys p" and s: "s = mapping_of t" unfolding keys_map_key_PP ..
	+ thus "ord (PP s) (PP (pp.mapping_of (lpp p)))" by (simp add: mapping_of_inverse punit.lt_max_keys)
	+ qed
	+qed
	+
	+lemma is_GB_map_key_PP:
	+ "finite G \<Longrightarrow> pp_pm.punit.is_Groebner_basis (Poly_Mapping.map_key PP ` G) \<longleftrightarrow> punit.is_Groebner_basis G"
	+ by (simp add: punit.GB_alt_3_finite pp_pm.punit.GB_alt_3_finite lpp_map_key_PP adds_pp_iff
	+ flip: map_key_PP_ideal)
	+
	+lemma thm_2_3_6_pp:
	+ assumes "pp_pm.is_GB_cofactor_bound (Poly_Mapping.map_key PP ` set fs) b"
	+ shows "punit.is_Groebner_basis (set (punit.Macaulay_list (deg_shifts_pp (Indets_pp fs) b fs)))"
	+proof -
	+ let ?fs = "map (Poly_Mapping.map_key PP) fs"
	+ from assms have "pp_pm.is_GB_cofactor_bound (set ?fs) b" by simp
	+ hence "pp_pm.punit.is_Groebner_basis
	+ (set (pp_pm.punit.Macaulay_list (pp_pm.deg_shifts (\<Union> (indets ` set ?fs)) b ?fs)))"
	+ by (rule pp_pm.thm_2_3_6_indets)
	+ also have "(\<Union> (indets ` set ?fs)) = set (Indets_pp fs)" by (simp add: Indets_pp_def set_indets_pp)
	+ finally show ?thesis
	+ by (simp add: deg_shifts_deg_shifts_pp map_key_PP_Macaulay_list flip: set_map is_GB_map_key_PP)
	+qed
	+
	+lemma Dube_is_GB_cofactor_bound_pp:
	+ "pp_pm.is_GB_cofactor_bound (Poly_Mapping.map_key PP ` set fs)
	+ (Dube (Suc (length (Indets_pp fs))) (max_list (map poly_deg_pp fs)))"
	+proof (cases "fs = []")
	+ case True
	+ show ?thesis by (rule pp_pm.is_GB_cofactor_boundI_subset_zero) (simp add: True)
	+next
	+ case False
	+ let ?F = "Poly_Mapping.map_key PP ` set fs"
	+ have "pp_pm.is_GB_cofactor_bound ?F (Dube (Suc (card (\<Union> (indets ` ?F)))) (maxdeg ?F))"
	+ by (intro pp_pm.Dube_is_GB_cofactor_bound_indets finite_imageI finite_set)
	+ moreover have "card (\<Union> (indets ` ?F)) = length (Indets_pp fs)"
	+ by (simp add: Indets_pp_def length_remdups_card_conv set_indets_pp)
	+ moreover from False have "maxdeg ?F = max_list (map poly_deg_pp fs)"
	+ by (simp add: max_list_Max maxdeg_def image_image poly_deg_map_key_PP)
	+ ultimately show ?thesis by simp
	+qed
	+
	+definition GB_Macaulay_Dube :: "(('x, nat) pp \<Rightarrow>\<^sub>0 'a) list \<Rightarrow> (('x, nat) pp \<Rightarrow>\<^sub>0 'a::field) list"
	+ where "GB_Macaulay_Dube fs = punit.Macaulay_list (deg_shifts_pp (Indets_pp fs)
	+ (Dube (Suc (length (Indets_pp fs))) (max_list (map poly_deg_pp fs))) fs)"
	+
	+lemma GB_Macaulay_Dube_is_GB: "punit.is_Groebner_basis (set (GB_Macaulay_Dube fs))"
	+ unfolding GB_Macaulay_Dube_def using Dube_is_GB_cofactor_bound_pp by (rule thm_2_3_6_pp)
	+
	+lemma ideal_GB_Macaulay_Dube: "ideal (set (GB_Macaulay_Dube fs)) = ideal (set fs)"
	+ by (simp add: GB_Macaulay_Dube_def punit.pmdl_Macaulay_list[simplified] ideal_deg_shifts_pp)
	+
	+end
	+
	+global_interpretation punit': pp_powerprod "ord_pp_punit cmp_term" "ord_pp_strict_punit cmp_term"
	+ rewrites "punit.adds_term = (adds)"
	+ and "punit.pp_of_term = (\<lambda>x. x)"
	+ and "punit.component_of_term = (\<lambda>_. ())"
	+ and "punit.monom_mult = monom_mult_punit"
	+ and "punit.mult_scalar = mult_scalar_punit"
	+ and "punit'.punit.min_term = min_term_punit"
	+ and "punit'.punit.lt = lt_punit cmp_term"
	+ and "punit'.punit.lc = lc_punit cmp_term"
	+ and "punit'.punit.tail = tail_punit cmp_term"
	+ and "punit'.punit.ord_p = ord_p_punit cmp_term"
	+ and "punit'.punit.keys_to_list = keys_to_list_punit cmp_term"
	+ for cmp_term :: "('a::nat, nat) pp nat_term_order"
	+
	+ defines max_punit = punit'.ordered_powerprod_lin.max
	+ and max_list_punit = punit'.ordered_powerprod_lin.max_list
	+ and Keys_to_list_punit = punit'.punit.Keys_to_list
	+ and Macaulay_mat_punit = punit'.punit.Macaulay_mat
	+ and Macaulay_list_punit = punit'.punit.Macaulay_list
	+ and poly_deg_pp_punit = punit'.poly_deg_pp
	+ and deg_le_sect_pp_aux_punit = punit'.deg_le_sect_pp_aux
	+ and deg_le_sect_pp_punit = punit'.deg_le_sect_pp
	+ and deg_shifts_pp_punit = punit'.deg_shifts_pp
	+ and indets_pp_punit = punit'.indets_pp
	+ and Indets_pp_punit = punit'.Indets_pp
	+ and GB_Macaulay_Dube_punit = punit'.GB_Macaulay_Dube
	+
	+ (* Only needed for auto-reduction: *)
	+ and find_adds_punit = punit'.punit.find_adds
	+ and trd_aux_punit = punit'.punit.trd_aux
	+ and trd_punit = punit'.punit.trd
	+ and comp_min_basis_punit = punit'.punit.comp_min_basis
	+ and comp_red_basis_aux_punit = punit'.punit.comp_red_basis_aux
	+ and comp_red_basis_punit = punit'.punit.comp_red_basis
	+ subgoal unfolding punit0.ord_pp_def punit0.ord_pp_strict_def ..
	+ subgoal by (fact punit_adds_term)
	+ subgoal by (simp add: id_def)
	+ subgoal by (fact punit_component_of_term)
	+ subgoal by (simp only: monom_mult_punit_def)
	+ subgoal by (simp only: mult_scalar_punit_def)
	+ subgoal using min_term_punit_def by fastforce
	+ subgoal by (simp only: lt_punit_def ord_pp_punit_alt)
	+ subgoal by (simp only: lc_punit_def ord_pp_punit_alt)
	+ subgoal by (simp only: tail_punit_def ord_pp_punit_alt)
	+ subgoal by (simp only: ord_p_punit_def ord_pp_strict_punit_alt)
	+ subgoal by (simp only: keys_to_list_punit_def ord_pp_punit_alt)
	+ done
	+
	+subsection \<open>Computations\<close>
	+
	+experiment begin interpretation trivariate\<^sub>0_rat .
	+
	+lemma
	+ "comp_red_basis_punit DRLEX (GB_Macaulay_Dube_punit DRLEX [X * Y\<^sup>2 + 3 * X\<^sup>2 * Y, Y ^ 3 - X ^ 3]) =
	+ [X ^ 5, X ^ 3 * Y - C\<^sub>0 (1 / 9) * X ^ 4, Y ^ 3 - X ^ 3, X * Y\<^sup>2 + 3 * X\<^sup>2 * Y]"
	+ by eval
	+
	+end
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Hilbert_Function.thy b/thys/Groebner_Macaulay/Hilbert_Function.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Hilbert_Function.thy
	@@ -0,0 +1,1404 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Direct Decompositions and Hilbert Functions\<close>
	+
	+theory Hilbert_Function
	+ imports Dube_Prelims Degree_Section "HOL-Library.Permutation"
	+begin
	+
	+subsection \<open>Direct Decompositions\<close>
	+
	+text \<open>The main reason for defining \<open>direct_decomp\<close> in terms of lists rather than sets is that
	+ lemma \<open>direct_decomp_direct_decomp\<close> can be proved easier. At some point one could invest the time
	+ to re-define \<open>direct_decomp\<close> in terms of sets (possibly adding a couple of further assumptions to
	+ \<open>direct_decomp_direct_decomp\<close>).\<close>
	+
	+definition direct_decomp :: "'a set \<Rightarrow> 'a::comm_monoid_add set list \<Rightarrow> bool"
	+ where "direct_decomp A ss \<longleftrightarrow> bij_betw sum_list (listset ss) A"
	+
	+lemma direct_decompI:
	+ "inj_on sum_list (listset ss) \<Longrightarrow> sum_list ` listset ss = A \<Longrightarrow> direct_decomp A ss"
	+ by (simp add: direct_decomp_def bij_betw_def)
	+
	+lemma direct_decompI_alt:
	+ "(\<And>qs. qs \<in> listset ss \<Longrightarrow> sum_list qs \<in> A) \<Longrightarrow> (\<And>a. a \<in> A \<Longrightarrow> \<exists>!qs\<in>listset ss. a = sum_list qs) \<Longrightarrow>
	+ direct_decomp A ss"
	+ by (auto simp: direct_decomp_def intro!: bij_betwI') blast
	+
	+lemma direct_decompD:
	+ assumes "direct_decomp A ss"
	+ shows "qs \<in> listset ss \<Longrightarrow> sum_list qs \<in> A" and "inj_on sum_list (listset ss)"
	+ and "sum_list ` listset ss = A"
	+ using assms by (auto simp: direct_decomp_def bij_betw_def)
	+
	+lemma direct_decompE:
	+ assumes "direct_decomp A ss" and "a \<in> A"
	+ obtains qs where "qs \<in> listset ss" and "a = sum_list qs"
	+ using assms by (auto simp: direct_decomp_def bij_betw_def)
	+
	+lemma direct_decomp_unique:
	+ "direct_decomp A ss \<Longrightarrow> qs \<in> listset ss \<Longrightarrow> qs' \<in> listset ss \<Longrightarrow> sum_list qs = sum_list qs' \<Longrightarrow>
	+ qs = qs'"
	+ by (auto dest: direct_decompD simp: inj_on_def)
	+
	+lemma direct_decomp_singleton: "direct_decomp A [A]"
	+proof (rule direct_decompI_alt)
	+ fix qs
	+ assume "qs \<in> listset [A]"
	+ then obtain q where "q \<in> A" and "qs = [q]" by (rule listset_singletonE)
	+ thus "sum_list qs \<in> A" by simp
	+next
	+ fix a
	+ assume "a \<in> A"
	+ show "\<exists>!qs\<in>listset [A]. a = sum_list qs"
	+ proof (intro ex1I conjI allI impI)
	+ from \<open>a \<in> A\<close> refl show "[a] \<in> listset [A]" by (rule listset_singletonI)
	+ next
	+ fix qs
	+ assume "qs \<in> listset [A] \<and> a = sum_list qs"
	+ hence a: "a = sum_list qs" and "qs \<in> listset [A]" by simp_all
	+ from this(2) obtain b where qs: "qs = [b]" by (rule listset_singletonE)
	+ with a show "qs = [a]" by simp
	+ qed simp_all
	+qed
	+
	+(* TODO: Move. *)
	+lemma mset_bij:
	+ assumes "bij_betw f {..<length xs} {..<length ys}" and "\<And>i. i < length xs \<Longrightarrow> xs ! i = ys ! f i"
	+ shows "mset xs = mset ys"
	+proof -
	+ from assms(1) have 1: "inj_on f {0..<length xs}" and 2: "f ` {0..<length xs} = {0..<length ys}"
	+ by (simp_all add: bij_betw_def lessThan_atLeast0)
	+ let ?f = "(!) ys \<circ> f"
	+ have "xs = map ?f [0..<length xs]" unfolding list_eq_iff_nth_eq
	+ proof (intro conjI allI impI)
	+ fix i
	+ assume "i < length xs"
	+ hence "xs ! i = ys ! f i" by (rule assms(2))
	+ also from \<open>i < length xs\<close> have "\<dots> = map ((!) ys \<circ> f) [0..<length xs] ! i" by simp
	+ finally show "xs ! i = map ((!) ys \<circ> f) [0..<length xs] ! i" .
	+ qed simp
	+ hence "mset xs = mset (map ?f [0..<length xs])" by (rule arg_cong)
	+ also have "\<dots> = image_mset ((!) ys) (image_mset f (mset_set {0..<length xs}))"
	+ by (simp flip: image_mset.comp)
	+ also from 1 have "\<dots> = image_mset ((!) ys) (mset_set {0..<length ys})"
	+ by (simp add: image_mset_mset_set 2)
	+ also have "\<dots> = mset (map ((!) ys) [0..<length ys])" by simp
	+ finally show "mset xs = mset ys" by (simp only: map_nth)
	+qed
	+
	+lemma direct_decomp_perm:
	+ assumes "direct_decomp A ss1" and "perm ss1 ss2"
	+ shows "direct_decomp A ss2"
	+proof -
	+ from assms(2) have len_ss1: "length ss1 = length ss2" by (rule perm_length)
	+ from assms(2) have "\<exists>f. bij_betw f {..<length ss1} {..<length ss2} \<and> (\<forall>i<length ss1. ss1 ! i = ss2 ! f i)"
	+ by (rule permutation_Ex_bij)
	+ then obtain f where f_bij: "bij_betw f {..<length ss2} {..<length ss1}"
	+ and f: "\<And>i. i < length ss2 \<Longrightarrow> ss1 ! i = ss2 ! f i" unfolding len_ss1 by blast
	+ define g where "g = inv_into {..<length ss2} f"
	+ from f_bij have g_bij: "bij_betw g {..<length ss1} {..<length ss2}"
	+ unfolding g_def len_ss1 by (rule bij_betw_inv_into)
	+ have f_g: "f (g i) = i" if "i < length ss1" for i
	+ proof -
	+ from that f_bij have "i \<in> f ` {..<length ss2}" by (simp add: bij_betw_def len_ss1)
	+ thus ?thesis by (simp only: f_inv_into_f g_def)
	+ qed
	+ have g_f: "g (f i) = i" if "i < length ss2" for i
	+ proof -
	+ from f_bij have "inj_on f {..<length ss2}" by (simp only: bij_betw_def)
	+ moreover from that have "i \<in> {..<length ss2}" by simp
	+ ultimately show ?thesis by (simp add: g_def)
	+ qed
	+ have g: "ss2 ! i = ss1 ! g i" if "i < length ss1" for i
	+ proof -
	+ from that have "i \<in> {..<length ss2}" by (simp add: len_ss1)
	+ hence "g i \<in> g ` {..<length ss2}" by (rule imageI)
	+ also from g_bij have "\<dots> = {..<length ss2}" by (simp only: len_ss1 bij_betw_def)
	+ finally have "g i < length ss2" by simp
	+ hence "ss1 ! g i = ss2 ! f (g i)" by (rule f)
	+ with that show ?thesis by (simp only: f_g)
	+ qed
	+ show ?thesis
	+ proof (rule direct_decompI_alt)
	+ fix qs2
	+ assume "qs2 \<in> listset ss2"
	+ then obtain qs1 where qs1_in: "qs1 \<in> listset ss1" and len_qs1: "length qs1 = length qs2"
	+ and *: "\<And>i. i < length qs2 \<Longrightarrow> qs1 ! i = qs2 ! f i" using f_bij f by (rule listset_permE) blast+
	+ from \<open>qs2 \<in> listset ss2\<close> have "length qs2 = length ss2" by (rule listsetD)
	+ with f_bij have "bij_betw f {..<length qs1} {..<length qs2}" by (simp only: len_qs1 len_ss1)
	+ hence "mset qs1 = mset qs2" using * by (rule mset_bij) (simp only: len_qs1)
	+ hence "sum_list qs2 = sum_list qs1" by (simp flip: sum_mset_sum_list)
	+ also from assms(1) qs1_in have "\<dots> \<in> A" by (rule direct_decompD)
	+ finally show "sum_list qs2 \<in> A" .
	+ next
	+ fix a
	+ assume "a \<in> A"
	+ with assms(1) obtain qs where a: "a = sum_list qs" and qs_in: "qs \<in> listset ss1"
	+ by (rule direct_decompE)
	+ from qs_in obtain qs2 where qs2_in: "qs2 \<in> listset ss2" and len_qs2: "length qs2 = length qs"
	+ and 1: "\<And>i. i < length qs \<Longrightarrow> qs2 ! i = qs ! g i" using g_bij g by (rule listset_permE) blast+
	+ show "\<exists>!qs\<in>listset ss2. a = sum_list qs"
	+ proof (intro ex1I conjI allI impI)
	+ from qs_in have len_qs: "length qs = length ss1" by (rule listsetD)
	+ with g_bij have g_bij2: "bij_betw g {..<length qs2} {..<length qs}" by (simp only: len_qs2 len_ss1)
	+ hence "mset qs2 = mset qs" using 1 by (rule mset_bij) (simp only: len_qs2)
	+ thus a2: "a = sum_list qs2" by (simp only: a flip: sum_mset_sum_list)
	+
	+ fix qs'
	+ assume "qs' \<in> listset ss2 \<and> a = sum_list qs'"
	+ hence qs'_in: "qs' \<in> listset ss2" and a': "a = sum_list qs'" by simp_all
	+ from this(1) obtain qs1 where qs1_in: "qs1 \<in> listset ss1" and len_qs1: "length qs1 = length qs'"
	+ and 2: "\<And>i. i < length qs' \<Longrightarrow> qs1 ! i = qs' ! f i" using f_bij f by (rule listset_permE) blast+
	+ from \<open>qs' \<in> listset ss2\<close> have "length qs' = length ss2" by (rule listsetD)
	+ with f_bij have "bij_betw f {..<length qs1} {..<length qs'}" by (simp only: len_qs1 len_ss1)
	+ hence "mset qs1 = mset qs'" using 2 by (rule mset_bij) (simp only: len_qs1)
	+ hence "sum_list qs1 = sum_list qs'" by (simp flip: sum_mset_sum_list)
	+ hence "sum_list qs1 = sum_list qs" by (simp only: a flip: a')
	+ with assms(1) qs1_in qs_in have "qs1 = qs" by (rule direct_decomp_unique)
	+ show "qs' = qs2" unfolding list_eq_iff_nth_eq
	+ proof (intro conjI allI impI)
	+ from qs'_in have "length qs' = length ss2" by (rule listsetD)
	+ thus eq: "length qs' = length qs2" by (simp only: len_qs2 len_qs len_ss1)
	+
	+ fix i
	+ assume "i < length qs'"
	+ hence "i < length qs2" by (simp only: eq)
	+ hence "i \<in> {..<length qs2}" and "i < length qs" and "i < length ss1"
	+ by (simp_all add: len_qs2 len_qs)
	+ from this(1) have "g i \<in> g ` {..<length qs2}" by (rule imageI)
	+ also from g_bij2 have "\<dots> = {..<length qs}" by (simp only: bij_betw_def)
	+ finally have "g i < length qs'" by (simp add: eq len_qs2)
	+ from \<open>i < length qs\<close> have "qs2 ! i = qs ! g i" by (rule 1)
	+ also have "\<dots> = qs1 ! g i" by (simp only: \<open>qs1 = qs\<close>)
	+ also from \<open>g i < length qs'\<close> have "\<dots> = qs' ! f (g i)" by (rule 2)
	+ also from \<open>i < length ss1\<close> have "\<dots> = qs' ! i" by (simp only: f_g)
	+ finally show "qs' ! i = qs2 ! i" by (rule sym)
	+ qed
	+ qed fact
	+ qed
	+qed
	+
	+lemma direct_decomp_split_map:
	+ "direct_decomp A (map f ss) \<Longrightarrow> direct_decomp A (map f (filter P ss) @ map f (filter (- P) ss))"
	+proof (rule direct_decomp_perm)
	+ show "perm (map f ss) (map f (filter P ss) @ map f (filter (- P) ss))"
	+ proof (induct ss)
	+ case Nil
	+ show ?case by simp
	+ next
	+ case (Cons s ss)
	+ show ?case
	+ proof (cases "P s")
	+ case True
	+ with Cons show ?thesis by simp
	+ next
	+ case False
	+ have "map f (s # ss) = f s # map f ss" by simp
	+ also from Cons have "perm (f s # map f ss) (f s # map f (filter P ss) @ map f (filter (- P) ss))"
	+ by (rule perm.intros)
	+ also have "perm \<dots> (map f (filter P ss) @ map f (s # filter (- P) ss))"
	+ by (simp add: perm_append_Cons)
	+ also(trans) from False have "\<dots> = map f (filter P (s # ss)) @ map f (filter (- P) (s # ss))"
	+ by simp
	+ finally show ?thesis .
	+ qed
	+ qed
	+qed
	+
	+lemmas direct_decomp_split = direct_decomp_split_map[where f=id, simplified]
	+
	+lemma direct_decomp_direct_decomp:
	+ assumes "direct_decomp A (s # ss)" and "direct_decomp s rs"
	+ shows "direct_decomp A (ss @ rs)" (is "direct_decomp A ?ss")
	+proof (rule direct_decompI_alt)
	+ fix qs
	+ assume "qs \<in> listset ?ss"
	+ then obtain qs1 qs2 where qs1: "qs1 \<in> listset ss" and qs2: "qs2 \<in> listset rs" and qs: "qs = qs1 @ qs2"
	+ by (rule listset_appendE)
	+ have "sum_list qs = sum_list ((sum_list qs2) # qs1)" by (simp add: qs add.commute)
	+ also from assms(1) have "\<dots> \<in> A"
	+ proof (rule direct_decompD)
	+ from assms(2) qs2 have "sum_list qs2 \<in> s" by (rule direct_decompD)
	+ thus "sum_list qs2 # qs1 \<in> listset (s # ss)" using qs1 refl by (rule listset_ConsI)
	+ qed
	+ finally show "sum_list qs \<in> A" .
	+next
	+ fix a
	+ assume "a \<in> A"
	+ with assms(1) obtain qs1 where qs1_in: "qs1 \<in> listset (s # ss)" and a: "a = sum_list qs1"
	+ by (rule direct_decompE)
	+ from qs1_in obtain qs11 qs12 where "qs11 \<in> s" and qs12_in: "qs12 \<in> listset ss"
	+ and qs1: "qs1 = qs11 # qs12" by (rule listset_ConsE)
	+ from assms(2) this(1) obtain qs2 where qs2_in: "qs2 \<in> listset rs" and qs11: "qs11 = sum_list qs2"
	+ by (rule direct_decompE)
	+ let ?qs = "qs12 @ qs2"
	+ show "\<exists>!qs\<in>listset ?ss. a = sum_list qs"
	+ proof (intro ex1I conjI allI impI)
	+ from qs12_in qs2_in refl show "?qs \<in> listset ?ss" by (rule listset_appendI)
	+
	+ show "a = sum_list ?qs" by (simp add: a qs1 qs11 add.commute)
	+
	+ fix qs0
	+ assume "qs0 \<in> listset ?ss \<and> a = sum_list qs0"
	+ hence qs0_in: "qs0 \<in> listset ?ss" and a2: "a = sum_list qs0" by simp_all
	+ from this(1) obtain qs01 qs02 where qs01_in: "qs01 \<in> listset ss" and qs02_in: "qs02 \<in> listset rs"
	+ and qs0: "qs0 = qs01 @ qs02" by (rule listset_appendE)
	+ note assms(1)
	+ moreover from _ qs01_in refl have "(sum_list qs02) # qs01 \<in> listset (s # ss)" (is "?qs' \<in> _")
	+ proof (rule listset_ConsI)
	+ from assms(2) qs02_in show "sum_list qs02 \<in> s" by (rule direct_decompD)
	+ qed
	+ moreover note qs1_in
	+ moreover from a2 have "sum_list ?qs' = sum_list qs1" by (simp add: qs0 a add.commute)
	+ ultimately have "?qs' = qs11 # qs12" unfolding qs1 by (rule direct_decomp_unique)
	+ hence "qs11 = sum_list qs02" and 1: "qs01 = qs12" by simp_all
	+ from this(1) have "sum_list qs02 = sum_list qs2" by (simp only: qs11)
	+ with assms(2) qs02_in qs2_in have "qs02 = qs2" by (rule direct_decomp_unique)
	+ thus "qs0 = qs12 @ qs2" by (simp only: 1 qs0)
	+ qed
	+qed
	+
	+lemma sum_list_map_times: "sum_list (map (() x) xs) = (x::'a::semiring_0) sum_list xs"
	+ by (induct xs) (simp_all add: algebra_simps)
	+
	+lemma direct_decomp_image_times:
	+ assumes "direct_decomp (A::'a::semiring_0 set) ss" and "\<And>a b. x * a = x * b \<Longrightarrow> x \<noteq> 0 \<Longrightarrow> a = b"
	+ shows "direct_decomp (() x ` A) (map ((`) (() x)) ss)" (is "direct_decomp ?A ?ss")
	+proof (rule direct_decompI_alt)
	+ fix qs
	+ assume "qs \<in> listset ?ss"
	+ then obtain qs0 where qs0_in: "qs0 \<in> listset ss" and qs: "qs = map ((*) x) qs0"
	+ by (rule listset_map_imageE)
	+ have "sum_list qs = x * sum_list qs0" by (simp only: qs sum_list_map_times)
	+ moreover from assms(1) qs0_in have "sum_list qs0 \<in> A" by (rule direct_decompD)
	+ ultimately show "sum_list qs \<in> (*) x ` A" by (rule image_eqI)
	+next
	+ fix a
	+ assume "a \<in> ?A"
	+ then obtain a' where "a' \<in> A" and a: "a = x * a'" ..
	+ from assms(1) this(1) obtain qs' where qs'_in: "qs' \<in> listset ss" and a': "a' = sum_list qs'"
	+ by (rule direct_decompE)
	+ define qs where "qs = map ((*) x) qs'"
	+ show "\<exists>!qs\<in>listset ?ss. a = sum_list qs"
	+ proof (intro ex1I conjI allI impI)
	+ from qs'_in qs_def show "qs \<in> listset ?ss" by (rule listset_map_imageI)
	+
	+ fix qs0
	+ assume "qs0 \<in> listset ?ss \<and> a = sum_list qs0"
	+ hence "qs0 \<in> listset ?ss" and a0: "a = sum_list qs0" by simp_all
	+ from this(1) obtain qs1 where qs1_in: "qs1 \<in> listset ss" and qs0: "qs0 = map ((*) x) qs1"
	+ by (rule listset_map_imageE)
	+ show "qs0 = qs"
	+ proof (cases "x = 0")
	+ case True
	+ from qs1_in have "length qs1 = length ss" by (rule listsetD)
	+ moreover from qs'_in have "length qs' = length ss" by (rule listsetD)
	+ ultimately show ?thesis by (simp add: qs_def qs0 list_eq_iff_nth_eq True)
	+ next
	+ case False
	+ have "x * sum_list qs1 = a" by (simp only: a0 qs0 sum_list_map_times)
	+ also have "\<dots> = x * sum_list qs'" by (simp only: a' a)
	+ finally have "sum_list qs1 = sum_list qs'" using False by (rule assms(2))
	+ with assms(1) qs1_in qs'_in have "qs1 = qs'" by (rule direct_decomp_unique)
	+ thus ?thesis by (simp only: qs0 qs_def)
	+ qed
	+ qed (simp only: a a' qs_def sum_list_map_times)
	+qed
	+
	+lemma direct_decomp_appendD:
	+ assumes "direct_decomp A (ss1 @ ss2)"
	+ shows "{} \<notin> set ss2 \<Longrightarrow> direct_decomp (sum_list ` listset ss1) ss1" (is "_ \<Longrightarrow> ?thesis1")
	+ and "{} \<notin> set ss1 \<Longrightarrow> direct_decomp (sum_list ` listset ss2) ss2" (is "_ \<Longrightarrow> ?thesis2")
	+ and "direct_decomp A [sum_list ` listset ss1, sum_list ` listset ss2]" (is "direct_decomp _ ?ss")
	+proof -
	+ have rl: "direct_decomp (sum_list ` listset ts1) ts1"
	+ if "direct_decomp A (ts1 @ ts2)" and "{} \<notin> set ts2" for ts1 ts2
	+ proof (intro direct_decompI inj_onI refl)
	+ fix qs1 qs2
	+ assume qs1: "qs1 \<in> listset ts1" and qs2: "qs2 \<in> listset ts1"
	+ assume eq: "sum_list qs1 = sum_list qs2"
	+ from that(2) have "listset ts2 \<noteq> {}" by (simp add: listset_empty_iff)
	+ then obtain qs3 where qs3: "qs3 \<in> listset ts2" by blast
	+ note that(1)
	+ moreover from qs1 qs3 refl have "qs1 @ qs3 \<in> listset (ts1 @ ts2)" by (rule listset_appendI)
	+ moreover from qs2 qs3 refl have "qs2 @ qs3 \<in> listset (ts1 @ ts2)" by (rule listset_appendI)
	+ moreover have "sum_list (qs1 @ qs3) = sum_list (qs2 @ qs3)" by (simp add: eq)
	+ ultimately have "qs1 @ qs3 = qs2 @ qs3" by (rule direct_decomp_unique)
	+ thus "qs1 = qs2" by simp
	+ qed
	+
	+ {
	+ assume "{} \<notin> set ss2"
	+ with assms show ?thesis1 by (rule rl)
	+ }
	+
	+ {
	+ from assms perm_append_swap have "direct_decomp A (ss2 @ ss1)" by (rule direct_decomp_perm)
	+ moreover assume "{} \<notin> set ss1"
	+ ultimately show ?thesis2 by (rule rl)
	+ }
	+
	+ show "direct_decomp A ?ss"
	+ proof (rule direct_decompI_alt)
	+ fix qs
	+ assume "qs \<in> listset ?ss"
	+ then obtain q1 q2 where q1: "q1 \<in> sum_list ` listset ss1" and q2: "q2 \<in> sum_list ` listset ss2"
	+ and qs: "qs = [q1, q2]" by (rule listset_doubletonE)
	+ from q1 obtain qs1 where qs1: "qs1 \<in> listset ss1" and q1: "q1 = sum_list qs1" ..
	+ from q2 obtain qs2 where qs2: "qs2 \<in> listset ss2" and q2: "q2 = sum_list qs2" ..
	+ from qs1 qs2 refl have "qs1 @ qs2 \<in> listset (ss1 @ ss2)" by (rule listset_appendI)
	+ with assms have "sum_list (qs1 @ qs2) \<in> A" by (rule direct_decompD)
	+ thus "sum_list qs \<in> A" by (simp add: qs q1 q2)
	+ next
	+ fix a
	+ assume "a \<in> A"
	+ with assms obtain qs0 where qs0_in: "qs0 \<in> listset (ss1 @ ss2)" and a: "a = sum_list qs0"
	+ by (rule direct_decompE)
	+ from this(1) obtain qs1 qs2 where qs1: "qs1 \<in> listset ss1" and qs2: "qs2 \<in> listset ss2"
	+ and qs0: "qs0 = qs1 @ qs2" by (rule listset_appendE)
	+ from qs1 have len_qs1: "length qs1 = length ss1" by (rule listsetD)
	+ define qs where "qs = [sum_list qs1, sum_list qs2]"
	+ show "\<exists>!qs\<in>listset ?ss. a = sum_list qs"
	+ proof (intro ex1I conjI)
	+ from qs1 have "sum_list qs1 \<in> sum_list ` listset ss1" by (rule imageI)
	+ moreover from qs2 have "sum_list qs2 \<in> sum_list ` listset ss2" by (rule imageI)
	+ ultimately show "qs \<in> listset ?ss" using qs_def by (rule listset_doubletonI)
	+
	+ fix qs'
	+ assume "qs' \<in> listset ?ss \<and> a = sum_list qs'"
	+ hence "qs' \<in> listset ?ss" and a': "a = sum_list qs'" by simp_all
	+ from this(1) obtain q1 q2 where q1: "q1 \<in> sum_list ` listset ss1"
	+ and q2: "q2 \<in> sum_list ` listset ss2" and qs': "qs' = [q1, q2]" by (rule listset_doubletonE)
	+ from q1 obtain qs1' where qs1': "qs1' \<in> listset ss1" and q1: "q1 = sum_list qs1'" ..
	+ from q2 obtain qs2' where qs2': "qs2' \<in> listset ss2" and q2: "q2 = sum_list qs2'" ..
	+ from qs1' have len_qs1': "length qs1' = length ss1" by (rule listsetD)
	+ note assms
	+ moreover from qs1' qs2' refl have "qs1' @ qs2' \<in> listset (ss1 @ ss2)" by (rule listset_appendI)
	+ moreover note qs0_in
	+ moreover have "sum_list (qs1' @ qs2') = sum_list qs0" by (simp add: a' qs' flip: a q1 q2)
	+ ultimately have "qs1' @ qs2' = qs0" by (rule direct_decomp_unique)
	+ also have "\<dots> = qs1 @ qs2" by fact
	+ finally show "qs' = qs" by (simp add: qs_def qs' q1 q2 len_qs1 len_qs1')
	+ qed (simp add: qs_def a qs0)
	+ qed
	+qed
	+
	+lemma direct_decomp_Cons_zeroI:
	+ assumes "direct_decomp A ss"
	+ shows "direct_decomp A ({0} # ss)"
	+proof (rule direct_decompI_alt)
	+ fix qs
	+ assume "qs \<in> listset ({0} # ss)"
	+ then obtain q qs' where "q \<in> {0}" and "qs' \<in> listset ss" and "qs = q # qs'"
	+ by (rule listset_ConsE)
	+ from this(1, 3) have "sum_list qs = sum_list qs'" by simp
	+ also from assms \<open>qs' \<in> listset ss\<close> have "\<dots> \<in> A" by (rule direct_decompD)
	+ finally show "sum_list qs \<in> A" .
	+next
	+ fix a
	+ assume "a \<in> A"
	+ with assms obtain qs' where qs': "qs' \<in> listset ss" and a: "a = sum_list qs'"
	+ by (rule direct_decompE)
	+ define qs where "qs = 0 # qs'"
	+ show "\<exists>!qs. qs \<in> listset ({0} # ss) \<and> a = sum_list qs"
	+ proof (intro ex1I conjI)
	+ from _ qs' qs_def show "qs \<in> listset ({0} # ss)" by (rule listset_ConsI) simp
	+ next
	+ fix qs0
	+ assume "qs0 \<in> listset ({0} # ss) \<and> a = sum_list qs0"
	+ hence "qs0 \<in> listset ({0} # ss)" and a0: "a = sum_list qs0" by simp_all
	+ from this(1) obtain q0 qs0' where "q0 \<in> {0}" and qs0': "qs0' \<in> listset ss"
	+ and qs0: "qs0 = q0 # qs0'" by (rule listset_ConsE)
	+ from this(1, 3) have "sum_list qs0' = sum_list qs'" by (simp add: a0 flip: a)
	+ with assms qs0' qs' have "qs0' = qs'" by (rule direct_decomp_unique)
	+ with \<open>q0 \<in> {0}\<close> show "qs0 = qs" by (simp add: qs_def qs0)
	+ qed (simp add: qs_def a)
	+qed
	+
	+lemma direct_decomp_Cons_zeroD:
	+ assumes "direct_decomp A ({0} # ss)"
	+ shows "direct_decomp A ss"
	+proof -
	+ have "direct_decomp {0} []" by (simp add: direct_decomp_def bij_betw_def)
	+ with assms have "direct_decomp A (ss @ [])" by (rule direct_decomp_direct_decomp)
	+ thus ?thesis by simp
	+qed
	+
	+lemma direct_decomp_Cons_subsetI:
	+ assumes "direct_decomp A (s # ss)" and "\<And>s0. s0 \<in> set ss \<Longrightarrow> 0 \<in> s0"
	+ shows "s \<subseteq> A"
	+proof
	+ fix x
	+ assume "x \<in> s"
	+ moreover from assms(2) have "map (\<lambda>_. 0) ss \<in> listset ss"
	+ by (induct ss, auto simp del: listset.simps(2) intro: listset_ConsI)
	+ ultimately have "x # (map (\<lambda>_. 0) ss) \<in> listset (s # ss)" using refl by (rule listset_ConsI)
	+ with assms(1) have "sum_list (x # (map (\<lambda>_. 0) ss)) \<in> A" by (rule direct_decompD)
	+ thus "x \<in> A" by simp
	+qed
	+
	+lemma direct_decomp_Int_zero:
	+ assumes "direct_decomp A ss" and "i < j" and "j < length ss" and "\<And>s. s \<in> set ss \<Longrightarrow> 0 \<in> s"
	+ shows "ss ! i \<inter> ss ! j = {0}"
	+proof -
	+ from assms(2, 3) have "i < length ss" by (rule less_trans)
	+ hence i_in: "ss ! i \<in> set ss" by simp
	+ from assms(3) have j_in: "ss ! j \<in> set ss" by simp
	+ show ?thesis
	+ proof
	+ show "ss ! i \<inter> ss ! j \<subseteq> {0}"
	+ proof
	+ fix x
	+ assume "x \<in> ss ! i \<inter> ss ! j"
	+ hence x_i: "x \<in> ss ! i" and x_j: "x \<in> ss ! j" by simp_all
	+ have 1: "(map (\<lambda>_. 0) ss)[k := y] \<in> listset ss" if "k < length ss" and "y \<in> ss ! k" for k y
	+ using assms(4) that
	+ proof (induct ss arbitrary: k)
	+ case Nil
	+ from Nil(2) show ?case by simp
	+ next
	+ case (Cons s ss)
	+ have *: "\<And>s'. s' \<in> set ss \<Longrightarrow> 0 \<in> s'" by (rule Cons.prems) simp
	+ show ?case
	+ proof (cases k)
	+ case k: 0
	+ with Cons.prems(3) have "y \<in> s" by simp
	+ moreover from * have "map (\<lambda>_. 0) ss \<in> listset ss"
	+ by (induct ss) (auto simp del: listset.simps(2) intro: listset_ConsI)
	+ moreover have "(map (\<lambda>_. 0) (s # ss))[k := y] = y # map (\<lambda>_. 0) ss" by (simp add: k)
	+ ultimately show ?thesis by (rule listset_ConsI)
	+ next
	+ case k: (Suc k')
	+ have "0 \<in> s" by (rule Cons.prems) simp
	+ moreover from * have "(map (\<lambda>_. 0) ss)[k' := y] \<in> listset ss"
	+ proof (rule Cons.hyps)
	+ from Cons.prems(2) show "k' < length ss" by (simp add: k)
	+ next
	+ from Cons.prems(3) show "y \<in> ss ! k'" by (simp add: k)
	+ qed
	+ moreover have "(map (\<lambda>_. 0) (s # ss))[k := y] = 0 # (map (\<lambda>_. 0) ss)[k' := y]"
	+ by (simp add: k)
	+ ultimately show ?thesis by (rule listset_ConsI)
	+ qed
	+ qed
	+ have 2: "sum_list ((map (\<lambda>_. 0) ss)[k := y]) = y" if "k < length ss" for k and y::'a
	+ using that by (induct ss arbitrary: k) (auto simp: add_ac split: nat.split)
	+ define qs1 where "qs1 = (map (\<lambda>_. 0) ss)[i := x]"
	+ define qs2 where "qs2 = (map (\<lambda>_. 0) ss)[j := x]"
	+ note assms(1)
	+ moreover from \<open>i < length ss\<close> x_i have "qs1 \<in> listset ss" unfolding qs1_def by (rule 1)
	+ moreover from assms(3) x_j have "qs2 \<in> listset ss" unfolding qs2_def by (rule 1)
	+ thm sum_list_update
	+ moreover from \<open>i < length ss\<close> assms(3) have "sum_list qs1 = sum_list qs2"
	+ by (simp add: qs1_def qs2_def 2)
	+ ultimately have "qs1 = qs2" by (rule direct_decomp_unique)
	+ hence "qs1 ! i = qs2 ! i" by simp
	+ with \<open>i < length ss\<close> assms(2, 3) show "x \<in> {0}" by (simp add: qs1_def qs2_def)
	+ qed
	+ next
	+ from i_in have "0 \<in> ss ! i" by (rule assms(4))
	+ moreover from j_in have "0 \<in> ss ! j" by (rule assms(4))
	+ ultimately show "{0} \<subseteq> ss ! i \<inter> ss ! j" by simp
	+ qed
	+qed
	+
	+corollary direct_decomp_pairwise_zero:
	+ assumes "direct_decomp A ss" and "\<And>s. s \<in> set ss \<Longrightarrow> 0 \<in> s"
	+ shows "pairwise (\<lambda>s1 s2. s1 \<inter> s2 = {0}) (set ss)"
	+proof (rule pairwiseI)
	+ fix s1 s2
	+ assume "s1 \<in> set ss"
	+ then obtain i where "i < length ss" and s1: "s1 = ss ! i" by (metis in_set_conv_nth)
	+ assume "s2 \<in> set ss"
	+ then obtain j where "j < length ss" and s2: "s2 = ss ! j" by (metis in_set_conv_nth)
	+ assume "s1 \<noteq> s2"
	+ hence "i < j \<or> j < i" by (auto simp: s1 s2)
	+ thus "s1 \<inter> s2 = {0}"
	+ proof
	+ assume "i < j"
	+ with assms(1) show ?thesis unfolding s1 s2 using \<open>j < length ss\<close> assms(2)
	+ by (rule direct_decomp_Int_zero)
	+ next
	+ assume "j < i"
	+ with assms(1) have "s2 \<inter> s1 = {0}" unfolding s1 s2 using \<open>i < length ss\<close> assms(2)
	+ by (rule direct_decomp_Int_zero)
	+ thus ?thesis by (simp only: Int_commute)
	+ qed
	+qed
	+
	+corollary direct_decomp_repeated_eq_zero:
	+ assumes "direct_decomp A ss" and "1 < count_list ss X" and "\<And>s. s \<in> set ss \<Longrightarrow> 0 \<in> s"
	+ shows "X = {0}"
	+proof -
	+ from assms(2) obtain i j where "i < j" and "j < length ss" and 1: "ss ! i = X" and 2: "ss ! j = X"
	+ by (rule count_list_gr_1_E)
	+ from assms(1) this(1, 2) assms(3) have "ss ! i \<inter> ss ! j = {0}" by (rule direct_decomp_Int_zero)
	+ thus ?thesis by (simp add: 1 2)
	+qed
	+
	+corollary direct_decomp_map_Int_zero:
	+ assumes "direct_decomp A (map f ss)" and "s1 \<in> set ss" and "s2 \<in> set ss" and "s1 \<noteq> s2"
	+ and "\<And>s. s \<in> set ss \<Longrightarrow> 0 \<in> f s"
	+ shows "f s1 \<inter> f s2 = {0}"
	+proof -
	+ from assms(2) obtain i where "i < length ss" and s1: "s1 = ss ! i" by (metis in_set_conv_nth)
	+ from this(1) have i: "i < length (map f ss)" by simp
	+ from assms(3) obtain j where "j < length ss" and s2: "s2 = ss ! j" by (metis in_set_conv_nth)
	+ from this(1) have j: "j < length (map f ss)" by simp
	+ have *: "0 \<in> s" if "s \<in> set (map f ss)" for s
	+ proof -
	+ from that obtain s' where "s' \<in> set ss" and s: "s = f s'" unfolding set_map ..
	+ from this(1) show "0 \<in> s" unfolding s by (rule assms(5))
	+ qed
	+ show ?thesis
	+ proof (rule linorder_cases)
	+ assume "i < j"
	+ with assms(1) have "(map f ss) ! i \<inter> (map f ss) ! j = {0}"
	+ using j * by (rule direct_decomp_Int_zero)
	+ with i j show ?thesis by (simp add: s1 s2)
	+ next
	+ assume "j < i"
	+ with assms(1) have "(map f ss) ! j \<inter> (map f ss) ! i = {0}"
	+ using i * by (rule direct_decomp_Int_zero)
	+ with i j show ?thesis by (simp add: s1 s2 Int_commute)
	+ next
	+ assume "i = j"
	+ with assms(4) show ?thesis by (simp add: s1 s2)
	+ qed
	+qed
	+
	+subsection \<open>Direct Decompositions and Vector Spaces\<close>
	+
	+definition (in vector_space) is_basis :: "'b set \<Rightarrow> 'b set \<Rightarrow> bool"
	+ where "is_basis V B \<longleftrightarrow> (B \<subseteq> V \<and> independent B \<and> V \<subseteq> span B \<and> card B = dim V)"
	+
	+definition (in vector_space) some_basis :: "'b set \<Rightarrow> 'b set"
	+ where "some_basis V = Eps (local.is_basis V)"
	+
	+hide_const (open) real_vector.is_basis real_vector.some_basis
	+
	+context vector_space
	+begin
	+
	+lemma dim_empty [simp]: "dim {} = 0"
	+ using dim_span_eq_card_independent independent_empty by fastforce
	+
	+lemma dim_zero [simp]: "dim {0} = 0"
	+ using dim_span_eq_card_independent independent_empty by fastforce
	+
	+lemma independent_UnI:
	+ assumes "independent A" and "independent B" and "span A \<inter> span B = {0}"
	+ shows "independent (A \<union> B)"
	+proof
	+ from span_superset have "A \<inter> B \<subseteq> span A \<inter> span B" by blast
	+ hence "A \<inter> B = {}" unfolding assms(3) using assms(1, 2) dependent_zero by blast
	+ assume "dependent (A \<union> B)"
	+ then obtain T u v where "finite T" and "T \<subseteq> A \<union> B" and eq: "(\<Sum>v\<in>T. u v *s v) = 0"
	+ and "v \<in> T" and "u v \<noteq> 0" unfolding dependent_explicit by blast
	+ define TA where "TA = T \<inter> A"
	+ define TB where "TB = T \<inter> B"
	+ from \<open>T \<subseteq> A \<union> B\<close> have T: "T = TA \<union> TB" by (auto simp: TA_def TB_def)
	+ from \<open>finite T\<close> have "finite TA" and "TA \<subseteq> A" by (simp_all add: TA_def)
	+ from \<open>finite T\<close> have "finite TB" and "TB \<subseteq> B" by (simp_all add: TB_def)
	+ from \<open>A \<inter> B = {}\<close> \<open>TA \<subseteq> A\<close> this(2) have "TA \<inter> TB = {}" by blast
	+ have "0 = (\<Sum>v\<in>TA \<union> TB. u v *s v)" by (simp only: eq flip: T)
	+ also have "\<dots> = (\<Sum>v\<in>TA. u v s v) + (\<Sum>v\<in>TB. u v s v)" by (rule sum.union_disjoint) fact+
	+ finally have "(\<Sum>v\<in>TA. u v s v) = (\<Sum>v\<in>TB. (- u) v s v)" (is "?x = ?y")
	+ by (simp add: sum_negf eq_neg_iff_add_eq_0)
	+ from \<open>finite TB\<close> \<open>TB \<subseteq> B\<close> have "?y \<in> span B" by (auto simp: span_explicit simp del: uminus_apply)
	+ moreover from \<open>finite TA\<close> \<open>TA \<subseteq> A\<close> have "?x \<in> span A" by (auto simp: span_explicit)
	+ ultimately have "?y \<in> span A \<inter> span B" by (simp add: \<open>?x = ?y\<close>)
	+ hence "?x = 0" and "?y = 0" by (simp_all add: \<open>?x = ?y\<close> assms(3))
	+ from \<open>v \<in> T\<close> have "v \<in> TA \<union> TB" by (simp only: T)
	+ hence "u v = 0"
	+ proof
	+ assume "v \<in> TA"
	+ with assms(1) \<open>finite TA\<close> \<open>TA \<subseteq> A\<close> \<open>?x = 0\<close> show "u v = 0" by (rule independentD)
	+ next
	+ assume "v \<in> TB"
	+ with assms(2) \<open>finite TB\<close> \<open>TB \<subseteq> B\<close> \<open>?y = 0\<close> have "(- u) v = 0" by (rule independentD)
	+ thus "u v = 0" by simp
	+ qed
	+ with \<open>u v \<noteq> 0\<close> show False ..
	+qed
	+
	+lemma subspace_direct_decomp:
	+ assumes "direct_decomp A ss" and "\<And>s. s \<in> set ss \<Longrightarrow> subspace s"
	+ shows "subspace A"
	+proof (rule subspaceI)
	+ let ?qs = "map (\<lambda>_. 0) ss"
	+ from assms(2) have "?qs \<in> listset ss"
	+ by (induct ss) (auto simp del: listset.simps(2) dest: subspace_0 intro: listset_ConsI)
	+ with assms(1) have "sum_list ?qs \<in> A" by (rule direct_decompD)
	+ thus "0 \<in> A" by simp
	+next
	+ fix p q
	+ assume "p \<in> A"
	+ with assms(1) obtain ps where ps: "ps \<in> listset ss" and p: "p = sum_list ps" by (rule direct_decompE)
	+ assume "q \<in> A"
	+ with assms(1) obtain qs where qs: "qs \<in> listset ss" and q: "q = sum_list qs" by (rule direct_decompE)
	+ from ps qs have l: "length ps = length qs" by (simp only: listsetD)
	+ from ps qs have "map2 (+) ps qs \<in> listset ss" (is "?qs \<in> _")
	+ by (rule listset_closed_map2) (auto dest: assms(2) subspace_add)
	+ with assms(1) have "sum_list ?qs \<in> A" by (rule direct_decompD)
	+ thus "p + q \<in> A" using l by (simp only: p q sum_list_map2_plus)
	+next
	+ fix c p
	+ assume "p \<in> A"
	+ with assms(1) obtain ps where "ps \<in> listset ss" and p: "p = sum_list ps" by (rule direct_decompE)
	+ from this(1) have "map ((*s) c) ps \<in> listset ss" (is "?qs \<in> _")
	+ by (rule listset_closed_map) (auto dest: assms(2) subspace_scale)
	+ with assms(1) have "sum_list ?qs \<in> A" by (rule direct_decompD)
	+ also have "sum_list ?qs = c *s sum_list ps" by (induct ps) (simp_all add: scale_right_distrib)
	+ finally show "c *s p \<in> A" by (simp only: p)
	+qed
	+
	+lemma is_basis_alt: "subspace V \<Longrightarrow> is_basis V B \<longleftrightarrow> (independent B \<and> span B = V)"
	+ by (metis (full_types) is_basis_def dim_eq_card span_eq span_eq_iff)
	+
	+lemma is_basis_finite: "is_basis V A \<Longrightarrow> is_basis V B \<Longrightarrow> finite A \<longleftrightarrow> finite B"
	+ unfolding is_basis_def using independent_span_bound by auto
	+
	+lemma some_basis_is_basis: "is_basis V (some_basis V)"
	+proof -
	+ obtain B where "B \<subseteq> V" and "independent B" and "V \<subseteq> span B" and "card B = dim V"
	+ by (rule basis_exists)
	+ hence "is_basis V B" by (simp add: is_basis_def)
	+ thus ?thesis unfolding some_basis_def by (rule someI)
	+qed
	+
	+corollary
	+ shows some_basis_subset: "some_basis V \<subseteq> V"
	+ and independent_some_basis: "independent (some_basis V)"
	+ and span_some_basis_supset: "V \<subseteq> span (some_basis V)"
	+ and card_some_basis: "card (some_basis V) = dim V"
	+ using some_basis_is_basis[of V] by (simp_all add: is_basis_def)
	+
	+lemma some_basis_not_zero: "0 \<notin> some_basis V"
	+ using independent_some_basis dependent_zero by blast
	+
	+lemma span_some_basis: "subspace V \<Longrightarrow> span (some_basis V) = V"
	+ by (simp add: span_subspace some_basis_subset span_some_basis_supset)
	+
	+lemma direct_decomp_some_basis_pairwise_disjnt:
	+ assumes "direct_decomp A ss" and "\<And>s. s \<in> set ss \<Longrightarrow> subspace s"
	+ shows "pairwise (\<lambda>s1 s2. disjnt (some_basis s1) (some_basis s2)) (set ss)"
	+proof (rule pairwiseI)
	+ fix s1 s2
	+ assume "s1 \<in> set ss" and "s2 \<in> set ss" and "s1 \<noteq> s2"
	+ have "some_basis s1 \<inter> some_basis s2 \<subseteq> s1 \<inter> s2" using some_basis_subset by blast
	+ also from direct_decomp_pairwise_zero have "\<dots> = {0}"
	+ proof (rule pairwiseD)
	+ fix s
	+ assume "s \<in> set ss"
	+ hence "subspace s" by (rule assms(2))
	+ thus "0 \<in> s" by (rule subspace_0)
	+ qed fact+
	+ finally have "some_basis s1 \<inter> some_basis s2 \<subseteq> {0}" .
	+ with some_basis_not_zero show "disjnt (some_basis s1) (some_basis s2)"
	+ unfolding disjnt_def by blast
	+qed
	+
	+lemma direct_decomp_span_some_basis:
	+ assumes "direct_decomp A ss" and "\<And>s. s \<in> set ss \<Longrightarrow> subspace s"
	+ shows "span (\<Union>(some_basis ` set ss)) = A"
	+proof -
	+ from assms(1) have eq0[symmetric]: "sum_list ` listset ss = A" by (rule direct_decompD)
	+ show ?thesis unfolding eq0 using assms(2)
	+ proof (induct ss)
	+ case Nil
	+ show ?case by simp
	+ next
	+ case (Cons s ss)
	+ have "subspace s" by (rule Cons.prems) simp
	+ hence eq1: "span (some_basis s) = s" by (rule span_some_basis)
	+ have "\<And>s'. s' \<in> set ss \<Longrightarrow> subspace s'" by (rule Cons.prems) simp
	+ hence eq2: "span (\<Union> (some_basis ` set ss)) = sum_list ` listset ss" by (rule Cons.hyps)
	+ have "span (\<Union> (some_basis ` set (s # ss))) = {x + y \|x y. x \<in> s \<and> y \<in> sum_list ` listset ss}"
	+ by (simp add: span_Un eq1 eq2)
	+ also have "\<dots> = sum_list ` listset (s # ss)" (is "?A = ?B")
	+ proof
	+ show "?A \<subseteq> ?B"
	+ proof
	+ fix a
	+ assume "a \<in> ?A"
	+ then obtain x y where "x \<in> s" and "y \<in> sum_list ` listset ss" and a: "a = x + y" by blast
	+ from this(2) obtain qs where "qs \<in> listset ss" and y: "y = sum_list qs" ..
	+ from \<open>x \<in> s\<close> this(1) refl have "x # qs \<in> listset (s # ss)" by (rule listset_ConsI)
	+ hence "sum_list (x # qs) \<in> ?B" by (rule imageI)
	+ also have "sum_list (x # qs) = a" by (simp add: a y)
	+ finally show "a \<in> ?B" .
	+ qed
	+ next
	+ show "?B \<subseteq> ?A"
	+ proof
	+ fix a
	+ assume "a \<in> ?B"
	+ then obtain qs' where "qs' \<in> listset (s # ss)" and a: "a = sum_list qs'" ..
	+ from this(1) obtain x qs where "x \<in> s" and "qs \<in> listset ss" and qs': "qs' = x # qs"
	+ by (rule listset_ConsE)
	+ from this(2) have "sum_list qs \<in> sum_list ` listset ss" by (rule imageI)
	+ moreover have "a = x + sum_list qs" by (simp add: a qs')
	+ ultimately show "a \<in> ?A" using \<open>x \<in> s\<close> by blast
	+ qed
	+ qed
	+ finally show ?case .
	+ qed
	+qed
	+
	+lemma direct_decomp_independent_some_basis:
	+ assumes "direct_decomp A ss" and "\<And>s. s \<in> set ss \<Longrightarrow> subspace s"
	+ shows "independent (\<Union>(some_basis ` set ss))"
	+ using assms
	+proof (induct ss arbitrary: A)
	+ case Nil
	+ from independent_empty show ?case by simp
	+next
	+ case (Cons s ss)
	+ have 1: "\<And>s'. s' \<in> set ss \<Longrightarrow> subspace s'" by (rule Cons.prems) simp
	+ have "subspace s" by (rule Cons.prems) simp
	+ hence "0 \<in> s" and eq1: "span (some_basis s) = s" by (rule subspace_0, rule span_some_basis)
	+ from Cons.prems(1) have *: "direct_decomp A ([s] @ ss)" by simp
	+ moreover from \<open>0 \<in> s\<close> have "{} \<notin> set [s]" by auto
	+ ultimately have 2: "direct_decomp (sum_list ` listset ss) ss" by (rule direct_decomp_appendD)
	+ hence eq2: "span (\<Union> (some_basis ` set ss)) = sum_list ` listset ss" using 1
	+ by (rule direct_decomp_span_some_basis)
	+
	+ note independent_some_basis[of s]
	+ moreover from 2 1 have "independent (\<Union> (some_basis ` set ss))" by (rule Cons.hyps)
	+ moreover have "span (some_basis s) \<inter> span (\<Union> (some_basis ` set ss)) = {0}"
	+ proof -
	+ from * have "direct_decomp A [sum_list ` listset [s], sum_list ` listset ss]"
	+ by (rule direct_decomp_appendD)
	+ hence "direct_decomp A [s, sum_list ` listset ss]" by (simp add: image_image)
	+ moreover have "0 < (1::nat)" by simp
	+ moreover have "1 < length [s, sum_list ` listset ss]" by simp
	+ ultimately have "[s, sum_list ` listset ss] ! 0 \<inter> [s, sum_list ` listset ss] ! 1 = {0}"
	+ by (rule direct_decomp_Int_zero) (auto simp: \<open>0 \<in> s\<close> eq2[symmetric] span_zero)
	+ thus ?thesis by (simp add: eq1 eq2)
	+ qed
	+ ultimately have "independent (some_basis s \<union> (\<Union> (some_basis ` set ss)))"
	+ by (rule independent_UnI)
	+ thus ?case by simp
	+qed
	+
	+corollary direct_decomp_is_basis:
	+ assumes "direct_decomp A ss" and "\<And>s. s \<in> set ss \<Longrightarrow> subspace s"
	+ shows "is_basis A (\<Union>(some_basis ` set ss))"
	+proof -
	+ from assms have "subspace A" by (rule subspace_direct_decomp)
	+ moreover from assms have "span (\<Union>(some_basis ` set ss)) = A"
	+ by (rule direct_decomp_span_some_basis)
	+ moreover from assms have "independent (\<Union>(some_basis ` set ss))"
	+ by (rule direct_decomp_independent_some_basis)
	+ ultimately show ?thesis by (simp add: is_basis_alt)
	+qed
	+
	+lemma dim_direct_decomp:
	+ assumes "direct_decomp A ss" and "finite B" and "A \<subseteq> span B" and "\<And>s. s \<in> set ss \<Longrightarrow> subspace s"
	+ shows "dim A = (\<Sum>s\<in>set ss. dim s)"
	+proof -
	+ from assms(1, 4) have "is_basis A (\<Union>(some_basis ` set ss))"
	+ (is "is_basis A ?B") by (rule direct_decomp_is_basis)
	+ hence "dim A = card ?B" and "independent ?B" and "?B \<subseteq> A" by (simp_all add: is_basis_def)
	+ from this(3) assms(3) have "?B \<subseteq> span B" by (rule subset_trans)
	+ with assms(2) \<open>independent ?B\<close> have "finite ?B" using independent_span_bound by blast
	+ note \<open>dim A = card ?B\<close>
	+ also from finite_set have "card ?B = (\<Sum>s\<in>set ss. card (some_basis s))"
	+ proof (intro card_UN_disjoint ballI impI)
	+ fix s
	+ assume "s \<in> set ss"
	+ with \<open>finite ?B\<close> show "finite (some_basis s)" by auto
	+ next
	+ fix s1 s2
	+ have "pairwise (\<lambda>s t. disjnt (some_basis s) (some_basis t)) (set ss)"
	+ using assms(1, 4) by (rule direct_decomp_some_basis_pairwise_disjnt)
	+ moreover assume "s1 \<in> set ss" and "s2 \<in> set ss" and "s1 \<noteq> s2"
	+ thm pairwiseD
	+ ultimately have "disjnt (some_basis s1) (some_basis s2)" by (rule pairwiseD)
	+ thus "some_basis s1 \<inter> some_basis s2 = {}" by (simp only: disjnt_def)
	+ qed
	+ also from refl card_some_basis have "\<dots> = (\<Sum>s\<in>set ss. dim s)" by (rule sum.cong)
	+ finally show ?thesis .
	+qed
	+
	+end (* vector_space *)
	+
	+subsection \<open>Homogeneous Sets of Polynomials with Fixed Degree\<close>
	+
	+lemma homogeneous_set_direct_decomp:
	+ assumes "direct_decomp A ss" and "\<And>s. s \<in> set ss \<Longrightarrow> homogeneous_set s"
	+ shows "homogeneous_set A"
	+proof (rule homogeneous_setI)
	+ fix a n
	+ assume "a \<in> A"
	+ with assms(1) obtain qs where "qs \<in> listset ss" and a: "a = sum_list qs" by (rule direct_decompE)
	+ have "hom_component a n = hom_component (sum_list qs) n" by (simp only: a)
	+ also have "\<dots> = sum_list (map (\<lambda>q. hom_component q n) qs)"
	+ by (induct qs) (simp_all add: hom_component_plus)
	+ also from assms(1) have "\<dots> \<in> A"
	+ proof (rule direct_decompD)
	+ show "map (\<lambda>q. hom_component q n) qs \<in> listset ss"
	+ proof (rule listset_closed_map)
	+ fix s q
	+ assume "s \<in> set ss"
	+ hence "homogeneous_set s" by (rule assms(2))
	+ moreover assume "q \<in> s"
	+ ultimately show "hom_component q n \<in> s" by (rule homogeneous_setD)
	+ qed fact
	+ qed
	+ finally show "hom_component a n \<in> A" .
	+qed
	+
	+definition hom_deg_set :: "nat \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) set \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::zero) set"
	+ where "hom_deg_set z A = (\<lambda>a. hom_component a z) ` A"
	+
	+lemma hom_deg_setD:
	+ assumes "p \<in> hom_deg_set z A"
	+ shows "homogeneous p" and "p \<noteq> 0 \<Longrightarrow> poly_deg p = z"
	+proof -
	+ from assms obtain a where "a \<in> A" and p: "p = hom_component a z" unfolding hom_deg_set_def ..
	+ show *: "homogeneous p" by (simp only: p homogeneous_hom_component)
	+
	+ assume "p \<noteq> 0"
	+ hence "keys p \<noteq> {}" by simp
	+ then obtain t where "t \<in> keys p" by blast
	+ with * have "deg_pm t = poly_deg p" by (rule homogeneousD_poly_deg)
	+ moreover from \<open>t \<in> keys p\<close> have "deg_pm t = z" unfolding p by (rule keys_hom_componentD)
	+ ultimately show "poly_deg p = z" by simp
	+qed
	+
	+lemma zero_in_hom_deg_set:
	+ assumes "0 \<in> A"
	+ shows "0 \<in> hom_deg_set z A"
	+proof -
	+ have "0 = hom_component 0 z" by simp
	+ also from assms have "\<dots> \<in> hom_deg_set z A" unfolding hom_deg_set_def by (rule imageI)
	+ finally show ?thesis .
	+qed
	+
	+lemma hom_deg_set_closed_uminus:
	+ assumes "\<And>a. a \<in> A \<Longrightarrow> - a \<in> A" and "p \<in> hom_deg_set z A"
	+ shows "- p \<in> hom_deg_set z A"
	+proof -
	+ from assms(2) obtain a where "a \<in> A" and p: "p = hom_component a z" unfolding hom_deg_set_def ..
	+ from this(1) have "- a \<in> A" by (rule assms(1))
	+ moreover have "- p = hom_component (- a) z" by (simp add: p)
	+ ultimately show ?thesis unfolding hom_deg_set_def by (rule rev_image_eqI)
	+qed
	+
	+lemma hom_deg_set_closed_plus:
	+ assumes "\<And>a1 a2. a1 \<in> A \<Longrightarrow> a2 \<in> A \<Longrightarrow> a1 + a2 \<in> A"
	+ and "p \<in> hom_deg_set z A" and "q \<in> hom_deg_set z A"
	+ shows "p + q \<in> hom_deg_set z A"
	+proof -
	+ from assms(2) obtain a1 where "a1 \<in> A" and p: "p = hom_component a1 z" unfolding hom_deg_set_def ..
	+ from assms(3) obtain a2 where "a2 \<in> A" and q: "q = hom_component a2 z" unfolding hom_deg_set_def ..
	+ from \<open>a1 \<in> A\<close> this(1) have "a1 + a2 \<in> A" by (rule assms(1))
	+ moreover have "p + q = hom_component (a1 + a2) z" by (simp only: p q hom_component_plus)
	+ ultimately show ?thesis unfolding hom_deg_set_def by (rule rev_image_eqI)
	+qed
	+
	+lemma hom_deg_set_closed_minus:
	+ assumes "\<And>a1 a2. a1 \<in> A \<Longrightarrow> a2 \<in> A \<Longrightarrow> a1 - a2 \<in> A"
	+ and "p \<in> hom_deg_set z A" and "q \<in> hom_deg_set z A"
	+ shows "p - q \<in> hom_deg_set z A"
	+proof -
	+ from assms(2) obtain a1 where "a1 \<in> A" and p: "p = hom_component a1 z" unfolding hom_deg_set_def ..
	+ from assms(3) obtain a2 where "a2 \<in> A" and q: "q = hom_component a2 z" unfolding hom_deg_set_def ..
	+ from \<open>a1 \<in> A\<close> this(1) have "a1 - a2 \<in> A" by (rule assms(1))
	+ moreover have "p - q = hom_component (a1 - a2) z" by (simp only: p q hom_component_minus)
	+ ultimately show ?thesis unfolding hom_deg_set_def by (rule rev_image_eqI)
	+qed
	+
	+lemma hom_deg_set_closed_scalar:
	+ assumes "\<And>a. a \<in> A \<Longrightarrow> c \<cdot> a \<in> A" and "p \<in> hom_deg_set z A"
	+ shows "(c::'a::semiring_0) \<cdot> p \<in> hom_deg_set z A"
	+proof -
	+ from assms(2) obtain a where "a \<in> A" and p: "p = hom_component a z" unfolding hom_deg_set_def ..
	+ from this(1) have "c \<cdot> a \<in> A" by (rule assms(1))
	+ moreover have "c \<cdot> p = hom_component (c \<cdot> a) z"
	+ by (simp add: p punit.map_scale_eq_monom_mult hom_component_monom_mult)
	+ ultimately show ?thesis unfolding hom_deg_set_def by (rule rev_image_eqI)
	+qed
	+
	+lemma hom_deg_set_closed_sum:
	+ assumes "0 \<in> A" and "\<And>a1 a2. a1 \<in> A \<Longrightarrow> a2 \<in> A \<Longrightarrow> a1 + a2 \<in> A"
	+ and "\<And>i. i \<in> I \<Longrightarrow> f i \<in> hom_deg_set z A"
	+ shows "sum f I \<in> hom_deg_set z A"
	+ using assms(3)
	+proof (induct I rule: infinite_finite_induct)
	+ case (infinite I)
	+ with assms(1) show ?case by (simp add: zero_in_hom_deg_set)
	+next
	+ case empty
	+ with assms(1) show ?case by (simp add: zero_in_hom_deg_set)
	+next
	+ case (insert j I)
	+ from insert.hyps(1, 2) have "sum f (insert j I) = f j + sum f I" by simp
	+ also from assms(2) have "\<dots> \<in> hom_deg_set z A"
	+ proof (intro hom_deg_set_closed_plus insert.hyps)
	+ show "f j \<in> hom_deg_set z A" by (rule insert.prems) simp
	+ next
	+ fix i
	+ assume "i \<in> I"
	+ hence "i \<in> insert j I" by simp
	+ thus "f i \<in> hom_deg_set z A" by (rule insert.prems)
	+ qed
	+ finally show ?case .
	+qed
	+
	+lemma hom_deg_set_subset: "homogeneous_set A \<Longrightarrow> hom_deg_set z A \<subseteq> A"
	+ by (auto dest: homogeneous_setD simp: hom_deg_set_def)
	+
	+lemma Polys_closed_hom_deg_set:
	+ assumes "A \<subseteq> P[X]"
	+ shows "hom_deg_set z A \<subseteq> P[X]"
	+proof
	+ fix p
	+ assume "p \<in> hom_deg_set z A"
	+ then obtain p' where "p' \<in> A" and p: "p = hom_component p' z" unfolding hom_deg_set_def ..
	+ from this(1) assms have "p' \<in> P[X]" ..
	+ have "keys p \<subseteq> keys p'" by (simp add: p keys_hom_component)
	+ also from \<open>p' \<in> P[X]\<close> have "\<dots> \<subseteq> .[X]" by (rule PolysD)
	+ finally show "p \<in> P[X]" by (rule PolysI)
	+qed
	+
	+lemma hom_deg_set_alt_homogeneous_set:
	+ assumes "homogeneous_set A"
	+ shows "hom_deg_set z A = {p \<in> A. homogeneous p \<and> (p = 0 \<or> poly_deg p = z)}" (is "?A = ?B")
	+proof
	+ show "?A \<subseteq> ?B"
	+ proof
	+ fix h
	+ assume "h \<in> ?A"
	+ also from assms have "\<dots> \<subseteq> A" by (rule hom_deg_set_subset)
	+ finally show "h \<in> ?B" using \<open>h \<in> ?A\<close> by (auto dest: hom_deg_setD)
	+ qed
	+next
	+ show "?B \<subseteq> ?A"
	+ proof
	+ fix h
	+ assume "h \<in> ?B"
	+ hence "h \<in> A" and "homogeneous h" and "h = 0 \<or> poly_deg h = z" by simp_all
	+ from this(3) show "h \<in> ?A"
	+ proof
	+ assume "h = 0"
	+ with \<open>h \<in> A\<close> have "0 \<in> A" by simp
	+ thus ?thesis unfolding \<open>h = 0\<close> by (rule zero_in_hom_deg_set)
	+ next
	+ assume "poly_deg h = z"
	+ with \<open>homogeneous h\<close> have "h = hom_component h z" by (simp add: hom_component_of_homogeneous)
	+ with \<open>h \<in> A\<close> show ?thesis unfolding hom_deg_set_def by (rule rev_image_eqI)
	+ qed
	+ qed
	+qed
	+
	+lemma hom_deg_set_sum_list_listset:
	+ assumes "A = sum_list ` listset ss"
	+ shows "hom_deg_set z A = sum_list ` listset (map (hom_deg_set z) ss)" (is "?A = ?B")
	+proof
	+ show "?A \<subseteq> ?B"
	+ proof
	+ fix h
	+ assume "h \<in> ?A"
	+ then obtain a where "a \<in> A" and h: "h = hom_component a z" unfolding hom_deg_set_def ..
	+ from this(1) obtain qs where "qs \<in> listset ss" and a: "a = sum_list qs" unfolding assms ..
	+ have "h = hom_component (sum_list qs) z" by (simp only: a h)
	+ also have "\<dots> = sum_list (map (\<lambda>q. hom_component q z) qs)"
	+ by (induct qs) (simp_all add: hom_component_plus)
	+ also have "\<dots> \<in> ?B"
	+ proof (rule imageI)
	+ show "map (\<lambda>q. hom_component q z) qs \<in> listset (map (hom_deg_set z) ss)"
	+ unfolding hom_deg_set_def using \<open>qs \<in> listset ss\<close> refl by (rule listset_map_imageI)
	+ qed
	+ finally show "h \<in> ?B" .
	+ qed
	+next
	+ show "?B \<subseteq> ?A"
	+ proof
	+ fix h
	+ assume "h \<in> ?B"
	+ then obtain qs where "qs \<in> listset (map (hom_deg_set z) ss)" and h: "h = sum_list qs" ..
	+ from this(1) obtain qs' where "qs' \<in> listset ss" and qs: "qs = map (\<lambda>q. hom_component q z) qs'"
	+ unfolding hom_deg_set_def by (rule listset_map_imageE)
	+ have "h = sum_list (map (\<lambda>q. hom_component q z) qs')" by (simp only: h qs)
	+ also have "\<dots> = hom_component (sum_list qs') z" by (induct qs') (simp_all add: hom_component_plus)
	+ finally have "h = hom_component (sum_list qs') z" .
	+ moreover have "sum_list qs' \<in> A" unfolding assms using \<open>qs' \<in> listset ss\<close> by (rule imageI)
	+ ultimately show "h \<in> ?A" unfolding hom_deg_set_def by (rule image_eqI)
	+ qed
	+qed
	+
	+lemma direct_decomp_hom_deg_set:
	+ assumes "direct_decomp A ss" and "\<And>s. s \<in> set ss \<Longrightarrow> homogeneous_set s"
	+ shows "direct_decomp (hom_deg_set z A) (map (hom_deg_set z) ss)"
	+proof (rule direct_decompI)
	+ from assms(1) have "sum_list ` listset ss = A" by (rule direct_decompD)
	+ from this[symmetric] show "sum_list ` listset (map (hom_deg_set z) ss) = hom_deg_set z A"
	+ by (simp only: hom_deg_set_sum_list_listset)
	+next
	+ from assms(1) have "inj_on sum_list (listset ss)" by (rule direct_decompD)
	+ moreover have "listset (map (hom_deg_set z) ss) \<subseteq> listset ss"
	+ proof (rule listset_mono)
	+ fix i
	+ assume "i < length ss"
	+ hence "map (hom_deg_set z) ss ! i = hom_deg_set z (ss ! i)" by simp
	+ also from \<open>i < length ss\<close> have "\<dots> \<subseteq> ss ! i" by (intro hom_deg_set_subset assms(2) nth_mem)
	+ finally show "map (hom_deg_set z) ss ! i \<subseteq> ss ! i" .
	+ qed simp
	+ ultimately show "inj_on sum_list (listset (map (hom_deg_set z) ss))" by (rule inj_on_subset)
	+qed
	+
	+subsection \<open>Interpreting Polynomial Rings as Vector Spaces over the Coefficient Field\<close>
	+
	+text \<open>There is no need to set up any further interpretation, since interpretation \<open>phull\<close> is exactly
	+ what we need.\<close>
	+
	+lemma subspace_ideal: "phull.subspace (ideal (F::('b::comm_powerprod \<Rightarrow>\<^sub>0 'a::field) set))"
	+ using ideal.span_zero ideal.span_add
	+proof (rule phull.subspaceI)
	+ fix c p
	+ assume "p \<in> ideal F"
	+ thus "c \<cdot> p \<in> ideal F" unfolding map_scale_eq_times by (rule ideal.span_scale)
	+qed
	+
	+lemma subspace_Polys: "phull.subspace (P[X]::(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::field) set)"
	+ using zero_in_Polys Polys_closed_plus Polys_closed_map_scale by (rule phull.subspaceI)
	+
	+lemma subspace_hom_deg_set:
	+ assumes "phull.subspace A"
	+ shows "phull.subspace (hom_deg_set z A)" (is "phull.subspace ?A")
	+proof (rule phull.subspaceI)
	+ from assms have "0 \<in> A" by (rule phull.subspace_0)
	+ thus "0 \<in> ?A" by (rule zero_in_hom_deg_set)
	+next
	+ fix p q
	+ assume "p \<in> ?A" and "q \<in> ?A"
	+ with phull.subspace_add show "p + q \<in> ?A" by (rule hom_deg_set_closed_plus) (rule assms)
	+next
	+ fix c p
	+ assume "p \<in> ?A"
	+ with phull.subspace_scale show "c \<cdot> p \<in> ?A" by (rule hom_deg_set_closed_scalar) (rule assms)
	+qed
	+
	+lemma hom_deg_set_Polys_eq_span:
	+ "hom_deg_set z P[X] = phull.span (monomial (1::'a::field) ` deg_sect X z)" (is "?A = ?B")
	+proof
	+ show "?A \<subseteq> ?B"
	+ proof
	+ fix p
	+ assume "p \<in> ?A"
	+ also from this have "\<dots> = {p \<in> P[X]. homogeneous p \<and> (p = 0 \<or> poly_deg p = z)}"
	+ by (simp only: hom_deg_set_alt_homogeneous_set[OF homogeneous_set_Polys])
	+ finally have "p \<in> P[X]" and "homogeneous p" and "p \<noteq> 0 \<Longrightarrow> poly_deg p = z" by simp_all
	+ thus "p \<in> ?B"
	+ proof (induct p rule: poly_mapping_plus_induct)
	+ case 1
	+ from phull.span_zero show ?case .
	+ next
	+ case (2 p c t)
	+ let ?m = "monomial c t"
	+ from 2(1) have "t \<in> keys ?m" by simp
	+ hence "t \<in> keys (?m + p)" using 2(2) by (rule in_keys_plusI1)
	+ hence "?m + p \<noteq> 0" by auto
	+ hence "poly_deg (monomial c t + p) = z" by (rule 2)
	+ from 2(4) have "keys (?m + p) \<subseteq> .[X]" by (rule PolysD)
	+ with \<open>t \<in> keys (?m + p)\<close> have "t \<in> .[X]" ..
	+ hence "?m \<in> P[X]" by (rule Polys_closed_monomial)
	+ have "t \<in> deg_sect X z"
	+ proof (rule deg_sectI)
	+ from 2(5) \<open>t \<in> keys (?m + p)\<close> have "deg_pm t = poly_deg (?m + p)"
	+ by (rule homogeneousD_poly_deg)
	+ also have "\<dots> = z" by fact
	+ finally show "deg_pm t = z" .
	+ qed fact
	+ hence "monomial 1 t \<in> monomial 1 ` deg_sect X z" by (rule imageI)
	+ hence "monomial 1 t \<in> ?B" by (rule phull.span_base)
	+ hence "c \<cdot> monomial 1 t \<in> ?B" by (rule phull.span_scale)
	+ hence "?m \<in> ?B" by simp
	+ moreover have "p \<in> ?B"
	+ proof (rule 2)
	+ from 2(4) \<open>?m \<in> P[X]\<close> have "(?m + p) - ?m \<in> P[X]" by (rule Polys_closed_minus)
	+ thus "p \<in> P[X]" by simp
	+ next
	+ have 1: "deg_pm s = z" if "s \<in> keys p" for s
	+ proof -
	+ from that 2(2) have "s \<noteq> t" by blast
	+ hence "s \<notin> keys ?m" by simp
	+ with that have "s \<in> keys (?m + p)" by (rule in_keys_plusI2)
	+ with 2(5) have "deg_pm s = poly_deg (?m + p)" by (rule homogeneousD_poly_deg)
	+ also have "\<dots> = z" by fact
	+ finally show ?thesis .
	+ qed
	+ show "homogeneous p" by (rule homogeneousI) (simp add: 1)
	+
	+ assume "p \<noteq> 0"
	+ show "poly_deg p = z"
	+ proof (rule antisym)
	+ show "poly_deg p \<le> z" by (rule poly_deg_leI) (simp add: 1)
	+ next
	+ from \<open>p \<noteq> 0\<close> have "keys p \<noteq> {}" by simp
	+ then obtain s where "s \<in> keys p" by blast
	+ hence "z = deg_pm s" by (simp only: 1)
	+ also from \<open>s \<in> keys p\<close> have "\<dots> \<le> poly_deg p" by (rule poly_deg_max_keys)
	+ finally show "z \<le> poly_deg p" .
	+ qed
	+ qed
	+ ultimately show ?case by (rule phull.span_add)
	+ qed
	+ qed
	+next
	+ show "?B \<subseteq> ?A"
	+ proof
	+ fix p
	+ assume "p \<in> ?B"
	+ then obtain M u where "M \<subseteq> monomial 1 ` deg_sect X z" and "finite M" and p: "p = (\<Sum>m\<in>M. u m \<cdot> m)"
	+ by (auto simp: phull.span_explicit)
	+ from this(1) obtain T where "T \<subseteq> deg_sect X z" and M: "M = monomial 1 ` T"
	+ and inj: "inj_on (monomial (1::'a)) T" by (rule subset_imageE_inj)
	+ define c where "c = (\<lambda>t. u (monomial 1 t))"
	+ from inj have "p = (\<Sum>t\<in>T. monomial (c t) t)" by (simp add: p M sum.reindex c_def)
	+ also have "\<dots> \<in> ?A"
	+ proof (intro hom_deg_set_closed_sum zero_in_Polys Polys_closed_plus)
	+ fix t
	+ assume "t \<in> T"
	+ hence "t \<in> deg_sect X z" using \<open>T \<subseteq> deg_sect X z\<close> ..
	+ hence "t \<in> .[X]" and eq: "deg_pm t = z" by (rule deg_sectD)+
	+ from this(1) have "monomial (c t) t \<in> P[X]" (is "?m \<in> _") by (rule Polys_closed_monomial)
	+ thus "?m \<in> ?A"
	+ by (simp add: hom_deg_set_alt_homogeneous_set[OF homogeneous_set_Polys] poly_deg_monomial
	+ monomial_0_iff eq)
	+ qed
	+ finally show "p \<in> ?A" .
	+ qed
	+qed
	+
	+subsection \<open>(Projective) Hilbert Function\<close>
	+
	+interpretation phull: vector_space map_scale
	+ apply standard
	+ subgoal by (fact map_scale_distrib_left)
	+ subgoal by (fact map_scale_distrib_right)
	+ subgoal by (fact map_scale_assoc)
	+ subgoal by (fact map_scale_one_left)
	+ done
	+
	+definition Hilbert_fun :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::field) set \<Rightarrow> nat \<Rightarrow> nat"
	+ where "Hilbert_fun A z = phull.dim (hom_deg_set z A)"
	+
	+lemma Hilbert_fun_empty [simp]: "Hilbert_fun {} = 0"
	+ by (rule ext) (simp add: Hilbert_fun_def hom_deg_set_def)
	+
	+lemma Hilbert_fun_zero [simp]: "Hilbert_fun {0} = 0"
	+ by (rule ext) (simp add: Hilbert_fun_def hom_deg_set_def)
	+
	+lemma Hilbert_fun_direct_decomp:
	+ assumes "finite X" and "A \<subseteq> P[X]" and "direct_decomp (A::(('x::countable \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::field) set) ps"
	+ and "\<And>s. s \<in> set ps \<Longrightarrow> homogeneous_set s" and "\<And>s. s \<in> set ps \<Longrightarrow> phull.subspace s"
	+ shows "Hilbert_fun A z = (\<Sum>p\<in>set ps. Hilbert_fun p z)"
	+proof -
	+ from assms(3, 4) have dd: "direct_decomp (hom_deg_set z A) (map (hom_deg_set z) ps)"
	+ by (rule direct_decomp_hom_deg_set)
	+ have "Hilbert_fun A z = phull.dim (hom_deg_set z A)" by (fact Hilbert_fun_def)
	+ also from dd have "\<dots> = sum phull.dim (set (map (hom_deg_set z) ps))"
	+ proof (rule phull.dim_direct_decomp)
	+ from assms(1) have "finite (deg_sect X z)" by (rule finite_deg_sect)
	+ thus "finite (monomial (1::'a) ` deg_sect X z)" by (rule finite_imageI)
	+ next
	+ from assms(2) have "hom_deg_set z A \<subseteq> hom_deg_set z P[X]"
	+ unfolding hom_deg_set_def by (rule image_mono)
	+ thus "hom_deg_set z A \<subseteq> phull.span (monomial 1 ` deg_sect X z)"
	+ by (simp only: hom_deg_set_Polys_eq_span)
	+ next
	+ fix s
	+ assume "s \<in> set (map (hom_deg_set z) ps)"
	+ then obtain s' where "s' \<in> set ps" and s: "s = hom_deg_set z s'" unfolding set_map ..
	+ from this(1) have "phull.subspace s'" by (rule assms(5))
	+ thus "phull.subspace s" unfolding s by (rule subspace_hom_deg_set)
	+ qed
	+ also have "\<dots> = sum (phull.dim \<circ> hom_deg_set z) (set ps)" unfolding set_map using finite_set
	+ proof (rule sum.reindex_nontrivial)
	+ fix s1 s2
	+ note dd
	+ moreover assume "s1 \<in> set ps" and "s2 \<in> set ps" and "s1 \<noteq> s2"
	+ moreover have "0 \<in> hom_deg_set z s" if "s \<in> set ps" for s
	+ proof (rule zero_in_hom_deg_set)
	+ from that have "phull.subspace s" by (rule assms(5))
	+ thus "0 \<in> s" by (rule phull.subspace_0)
	+ qed
	+ ultimately have "hom_deg_set z s1 \<inter> hom_deg_set z s2 = {0}" by (rule direct_decomp_map_Int_zero)
	+ moreover assume "hom_deg_set z s1 = hom_deg_set z s2"
	+ ultimately show "phull.dim (hom_deg_set z s1) = 0" by simp
	+ qed
	+ also have "\<dots> = (\<Sum>p\<in>set ps. Hilbert_fun p z)" by (simp only: o_def Hilbert_fun_def)
	+ finally show ?thesis .
	+qed
	+
	+context pm_powerprod
	+begin
	+
	+lemma image_lt_hom_deg_set:
	+ assumes "homogeneous_set A"
	+ shows "lpp ` (hom_deg_set z A - {0}) = {t \<in> lpp ` (A - {0}). deg_pm t = z}" (is "?B = ?A")
	+proof (intro set_eqI iffI)
	+ fix t
	+ assume "t \<in> ?A"
	+ hence "t \<in> lpp ` (A - {0})" and deg_t[symmetric]: "deg_pm t = z" by simp_all
	+ from this(1) obtain p where "p \<in> A - {0}" and t: "t = lpp p" ..
	+ from this(1) have "p \<in> A" and "p \<noteq> 0" by simp_all
	+ from this(1) have 1: "hom_component p z \<in> hom_deg_set z A" (is "?p \<in> _")
	+ unfolding hom_deg_set_def by (rule imageI)
	+ from \<open>p \<noteq> 0\<close> have "?p \<noteq> 0" and "lpp ?p = t" unfolding t deg_t by (rule hom_component_lpp)+
	+ note this(2)[symmetric]
	+ moreover from 1 \<open>?p \<noteq> 0\<close> have "?p \<in> hom_deg_set z A - {0}" by simp
	+ ultimately show "t \<in> ?B" by (rule image_eqI)
	+next
	+ fix t
	+ assume "t \<in> ?B"
	+ then obtain p where "p \<in> hom_deg_set z A - {0}" and t: "t = lpp p" ..
	+ from this(1) have "p \<in> hom_deg_set z A" and "p \<noteq> 0" by simp_all
	+ with assms have "p \<in> A" and "homogeneous p" and "poly_deg p = z"
	+ by (simp_all add: hom_deg_set_alt_homogeneous_set)
	+ from this(1) \<open>p \<noteq> 0\<close> have "p \<in> A - {0}" by simp
	+ hence 1: "t \<in> lpp ` (A - {0})" using t by (rule rev_image_eqI)
	+ from \<open>p \<noteq> 0\<close> have "t \<in> keys p" unfolding t by (rule punit.lt_in_keys)
	+ with \<open>homogeneous p\<close> have "deg_pm t = poly_deg p" by (rule homogeneousD_poly_deg)
	+ with 1 show "t \<in> ?A" by (simp add: \<open>poly_deg p = z\<close>)
	+qed
	+
	+lemma Hilbert_fun_alt:
	+ assumes "finite X" and "A \<subseteq> P[X]" and "phull.subspace A"
	+ shows "Hilbert_fun A z = card (lpp ` (hom_deg_set z A - {0}))" (is "_ = card ?A")
	+proof -
	+ have "?A \<subseteq> lpp ` (hom_deg_set z A - {0})" by simp
	+ then obtain B where sub: "B \<subseteq> hom_deg_set z A - {0}" and eq1: "?A = lpp ` B"
	+ and inj: "inj_on lpp B" by (rule subset_imageE_inj)
	+ have "Hilbert_fun A z = phull.dim (hom_deg_set z A)" by (fact Hilbert_fun_def)
	+ also have "\<dots> = card B"
	+ proof (rule phull.dim_eq_card)
	+ show "phull.span B = phull.span (hom_deg_set z A)"
	+ proof
	+ from sub have "B \<subseteq> hom_deg_set z A" by blast
	+ thus "phull.span B \<subseteq> phull.span (hom_deg_set z A)" by (rule phull.span_mono)
	+ next
	+ from assms(3) have "phull.subspace (hom_deg_set z A)" by (rule subspace_hom_deg_set)
	+ hence "phull.span (hom_deg_set z A) = hom_deg_set z A" by (simp only: phull.span_eq_iff)
	+ also have "\<dots> \<subseteq> phull.span B"
	+ proof (rule ccontr)
	+ assume "\<not> hom_deg_set z A \<subseteq> phull.span B"
	+ then obtain p0 where "p0 \<in> hom_deg_set z A - phull.span B" (is "_ \<in> ?B") by blast
	+ note assms(1) this
	+ moreover have "?B \<subseteq> P[X]"
	+ proof (rule subset_trans)
	+ from assms(2) show "hom_deg_set z A \<subseteq> P[X]" by (rule Polys_closed_hom_deg_set)
	+ qed blast
	+ ultimately obtain p where "p \<in> ?B" and p_min: "\<And>q. punit.ord_strict_p q p \<Longrightarrow> q \<notin> ?B"
	+ by (rule punit.ord_p_minimum_dgrad_p_set[OF dickson_grading_varnum, where m=0,
	+ simplified dgrad_p_set_varnum]) blast
	+ from this(1) have "p \<in> hom_deg_set z A" and "p \<notin> phull.span B" by simp_all
	+ from phull.span_zero this(2) have "p \<noteq> 0" by blast
	+ with \<open>p \<in> hom_deg_set z A\<close> have "p \<in> hom_deg_set z A - {0}" by simp
	+ hence "lpp p \<in> lpp ` (hom_deg_set z A - {0})" by (rule imageI)
	+ also have "\<dots> = lpp ` B" by (simp only: eq1)
	+ finally obtain b where "b \<in> B" and eq2: "lpp p = lpp b" ..
	+ from this(1) sub have "b \<in> hom_deg_set z A - {0}" ..
	+ hence "b \<in> hom_deg_set z A" and "b \<noteq> 0" by simp_all
	+ from this(2) have lcb: "punit.lc b \<noteq> 0" by (rule punit.lc_not_0)
	+ from \<open>p \<noteq> 0\<close> have lcp: "punit.lc p \<noteq> 0" by (rule punit.lc_not_0)
	+ from \<open>b \<in> B\<close> have "b \<in> phull.span B" by (rule phull.span_base)
	+ hence "(punit.lc p / punit.lc b) \<cdot> b \<in> phull.span B" (is "?b \<in> _") by (rule phull.span_scale)
	+ with \<open>p \<notin> phull.span B\<close> have "p - ?b \<noteq> 0" by auto
	+ moreover from lcb lcp \<open>b \<noteq> 0\<close> have "lpp ?b = lpp p"
	+ by (simp add: punit.map_scale_eq_monom_mult punit.lt_monom_mult eq2)
	+ moreover from lcb have "punit.lc ?b = punit.lc p" by (simp add: punit.map_scale_eq_monom_mult)
	+ ultimately have "lpp (p - ?b) \<prec> lpp p" by (rule punit.lt_minus_lessI)
	+ hence "punit.ord_strict_p (p - ?b) p" by (rule punit.lt_ord_p)
	+ hence "p - ?b \<notin> ?B" by (rule p_min)
	+ hence "p - ?b \<notin> hom_deg_set z A \<or> p - ?b \<in> phull.span B" by simp
	+ thus False
	+ proof
	+ assume *: "p - ?b \<notin> hom_deg_set z A"
	+ from phull.subspace_scale have "?b \<in> hom_deg_set z A"
	+ proof (rule hom_deg_set_closed_scalar)
	+ show "phull.subspace A" by fact
	+ next
	+ show "b \<in> hom_deg_set z A" by fact
	+ qed
	+ with phull.subspace_diff \<open>p \<in> hom_deg_set z A\<close> have "p - ?b \<in> hom_deg_set z A"
	+ by (rule hom_deg_set_closed_minus) (rule assms(3))
	+ with * show ?thesis ..
	+ next
	+ assume "p - ?b \<in> phull.span B"
	+ hence "p - ?b + ?b \<in> phull.span B" using \<open>?b \<in> phull.span B\<close> by (rule phull.span_add)
	+ hence "p \<in> phull.span B" by simp
	+ with \<open>p \<notin> phull.span B\<close> show ?thesis ..
	+ qed
	+ qed
	+ finally show "phull.span (hom_deg_set z A) \<subseteq> phull.span B" .
	+ qed
	+ next
	+ show "phull.independent B"
	+ proof
	+ assume "phull.dependent B"
	+ then obtain B' u b' where "finite B'" and "B' \<subseteq> B" and "(\<Sum>b\<in>B'. u b \<cdot> b) = 0"
	+ and "b' \<in> B'" and "u b' \<noteq> 0" unfolding phull.dependent_explicit by blast
	+ define B0 where "B0 = {b \<in> B'. u b \<noteq> 0}"
	+ have "B0 \<subseteq> B'" by (simp add: B0_def)
	+ with \<open>finite B'\<close> have "(\<Sum>b\<in>B0. u b \<cdot> b) = (\<Sum>b\<in>B'. u b \<cdot> b)"
	+ by (rule sum.mono_neutral_left) (simp add: B0_def)
	+ also have "\<dots> = 0" by fact
	+ finally have eq: "(\<Sum>b\<in>B0. u b \<cdot> b) = 0" .
	+ define t where "t = ordered_powerprod_lin.Max (lpp ` B0)"
	+ from \<open>b' \<in> B'\<close> \<open>u b' \<noteq> 0\<close> have "b' \<in> B0" by (simp add: B0_def)
	+ hence "lpp b' \<in> lpp ` B0" by (rule imageI)
	+ hence "lpp ` B0 \<noteq> {}" by blast
	+ from \<open>B0 \<subseteq> B'\<close> \<open>finite B'\<close> have "finite B0" by (rule finite_subset)
	+ hence "finite (lpp ` B0)" by (rule finite_imageI)
	+ hence "t \<in> lpp ` B0" unfolding t_def using \<open>lpp ` B0 \<noteq> {}\<close>
	+ by (rule ordered_powerprod_lin.Max_in)
	+ then obtain b0 where "b0 \<in> B0" and t: "t = lpp b0" ..
	+ note this(1)
	+ moreover from \<open>B0 \<subseteq> B'\<close> \<open>B' \<subseteq> B\<close> have "B0 \<subseteq> B" by (rule subset_trans)
	+ also have "\<dots> \<subseteq> hom_deg_set z A - {0}" by fact
	+ finally have "b0 \<in> hom_deg_set z A - {0}" .
	+ hence "b0 \<noteq> 0" by simp
	+ hence "t \<in> keys b0" unfolding t by (rule punit.lt_in_keys)
	+ have "lookup (\<Sum>b\<in>B0. u b \<cdot> b) t = (\<Sum>b\<in>B0. u b * lookup b t)" by (simp add: lookup_sum)
	+ also from \<open>finite B0\<close> have "\<dots> = (\<Sum>b\<in>{b0}. u b * lookup b t)"
	+ proof (rule sum.mono_neutral_right)
	+ from \<open>b0 \<in> B0\<close> show "{b0} \<subseteq> B0" by simp
	+ next
	+ show "\<forall>b\<in>B0 - {b0}. u b * lookup b t = 0"
	+ proof
	+ fix b
	+ assume "b \<in> B0 - {b0}"
	+ hence "b \<in> B0" and "b \<noteq> b0" by simp_all
	+ from this(1) have "lpp b \<in> lpp ` B0" by (rule imageI)
	+ with \<open>finite (lpp ` B0)\<close> have "lpp b \<preceq> t" unfolding t_def
	+ by (rule ordered_powerprod_lin.Max_ge)
	+ have "t \<notin> keys b"
	+ proof
	+ assume "t \<in> keys b"
	+ hence "t \<preceq> lpp b" by (rule punit.lt_max_keys)
	+ with \<open>lpp b \<preceq> t\<close> have "lpp b = lpp b0"
	+ unfolding t by (rule ordered_powerprod_lin.antisym)
	+ from inj \<open>B0 \<subseteq> B\<close> have "inj_on lpp B0" by (rule inj_on_subset)
	+ hence "b = b0" using \<open>lpp b = lpp b0\<close> \<open>b \<in> B0\<close> \<open>b0 \<in> B0\<close> by (rule inj_onD)
	+ with \<open>b \<noteq> b0\<close> show False ..
	+ qed
	+ thus "u b * lookup b t = 0" by (simp add: in_keys_iff)
	+ qed
	+ qed
	+ also from \<open>t \<in> keys b0\<close> \<open>b0 \<in> B0\<close> have "\<dots> \<noteq> 0" by (simp add: B0_def in_keys_iff)
	+ finally show False by (simp add: eq)
	+ qed
	+ qed
	+ also have "\<dots> = card ?A" unfolding eq1 using inj by (rule card_image[symmetric])
	+ finally show ?thesis .
	+qed
	+
	+end (* pm_powerprod *)
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Monomial_Module.thy b/thys/Groebner_Macaulay/Monomial_Module.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Monomial_Module.thy
	@@ -0,0 +1,553 @@
	+section \<open>Monomial Modules\<close>
	+
	+theory Monomial_Module
	+ imports Groebner_Bases.Reduced_GB
	+begin
	+
	+text \<open>Properties of modules generated by sets of monomials, and (reduced) Gr\"obner bases thereof.\<close>
	+
	+subsection \<open>Sets of Monomials\<close>
	+
	+definition is_monomial_set :: "('a \<Rightarrow>\<^sub>0 'b::zero) set \<Rightarrow> bool"
	+ where "is_monomial_set A \<longleftrightarrow> (\<forall>p\<in>A. is_monomial p)"
	+
	+lemma is_monomial_setI: "(\<And>p. p \<in> A \<Longrightarrow> is_monomial p) \<Longrightarrow> is_monomial_set A"
	+ by (simp add: is_monomial_set_def)
	+
	+lemma is_monomial_setD: "is_monomial_set A \<Longrightarrow> p \<in> A \<Longrightarrow> is_monomial p"
	+ by (simp add: is_monomial_set_def)
	+
	+lemma is_monomial_set_subset: "is_monomial_set B \<Longrightarrow> A \<subseteq> B \<Longrightarrow> is_monomial_set A"
	+ by (auto simp: is_monomial_set_def)
	+
	+lemma is_monomial_set_Un: "is_monomial_set (A \<union> B) \<longleftrightarrow> (is_monomial_set A \<and> is_monomial_set B)"
	+ by (auto simp: is_monomial_set_def)
	+
	+subsection \<open>Modules\<close>
	+
	+context term_powerprod
	+begin
	+
	+lemma monomial_pmdl:
	+ assumes "is_monomial_set B" and "p \<in> pmdl B"
	+ shows "monomial (lookup p v) v \<in> pmdl B"
	+ using assms(2)
	+proof (induct p rule: pmdl_induct)
	+ case base: module_0
	+ show ?case by (simp add: pmdl.span_zero)
	+next
	+ case step: (module_plus p b c t)
	+ have eq: "monomial (lookup (p + monom_mult c t b) v) v =
	+ monomial (lookup p v) v + monomial (lookup (monom_mult c t b) v) v"
	+ by (simp only: single_add lookup_add)
	+ from assms(1) step.hyps(3) have "is_monomial b" by (rule is_monomial_setD)
	+ then obtain d u where b: "b = monomial d u" by (rule is_monomial_monomial)
	+ have "monomial (lookup (monom_mult c t b) v) v \<in> pmdl B"
	+ proof (simp add: b monom_mult_monomial lookup_single when_def pmdl.span_zero, intro impI)
	+ assume "t \<oplus> u = v"
	+ hence "monomial (c * d) v = monom_mult c t b" by (simp add: b monom_mult_monomial)
	+ also from step.hyps(3) have "\<dots> \<in> pmdl B" by (rule monom_mult_in_pmdl)
	+ finally show "monomial (c * d) v \<in> pmdl B" .
	+ qed
	+ with step.hyps(2) show ?case unfolding eq by (rule pmdl.span_add)
	+qed
	+
	+lemma monomial_pmdl_field:
	+ assumes "is_monomial_set B" and "p \<in> pmdl B" and "v \<in> keys (p::_ \<Rightarrow>\<^sub>0 'b::field)"
	+ shows "monomial c v \<in> pmdl B"
	+proof -
	+ from assms(1, 2) have "monomial (lookup p v) v \<in> pmdl B" by (rule monomial_pmdl)
	+ hence "monom_mult (c / lookup p v) 0 (monomial (lookup p v) v) \<in> pmdl B"
	+ by (rule pmdl_closed_monom_mult)
	+ with assms(3) show ?thesis by (simp add: monom_mult_monomial splus_zero in_keys_iff)
	+qed
	+
	+end (* term_powerprod *)
	+
	+context ordered_term
	+begin
	+
	+lemma keys_monomial_pmdl:
	+ assumes "is_monomial_set F" and "p \<in> pmdl F" and "t \<in> keys p"
	+ obtains f where "f \<in> F" and "f \<noteq> 0" and "lt f adds\<^sub>t t"
	+ using assms(2) assms(3)
	+proof (induct arbitrary: thesis rule: pmdl_induct)
	+ case module_0
	+ from this(2) show ?case by simp
	+next
	+ case step: (module_plus p f0 c s)
	+ from assms(1) step(3) have "is_monomial f0" unfolding is_monomial_set_def ..
	+ hence "keys f0 = {lt f0}" and "f0 \<noteq> 0" by (rule keys_monomial, rule monomial_not_0)
	+ from Poly_Mapping.keys_add step(6) have "t \<in> keys p \<union> keys (monom_mult c s f0)" ..
	+ thus ?case
	+ proof
	+ assume "t \<in> keys p"
	+ from step(2)[OF _ this] obtain f where "f \<in> F" and "f \<noteq> 0" and "lt f adds\<^sub>t t" by blast
	+ thus ?thesis by (rule step(5))
	+ next
	+ assume "t \<in> keys (monom_mult c s f0)"
	+ with keys_monom_mult_subset have "t \<in> (\<oplus>) s ` keys f0" ..
	+ hence "t = s \<oplus> lt f0" by (simp add: \<open>keys f0 = {lt f0}\<close>)
	+ hence "lt f0 adds\<^sub>t t" by (simp add: term_simps)
	+ with \<open>f0 \<in> F\<close> \<open>f0 \<noteq> 0\<close> show ?thesis by (rule step(5))
	+ qed
	+qed
	+
	+lemma image_lt_monomial_lt: "lt ` monomial (1::'b::zero_neq_one) ` lt ` F = lt ` F"
	+ by (auto simp: lt_monomial intro!: image_eqI)
	+
	+subsection \<open>Reduction\<close>
	+
	+lemma red_setE2:
	+ assumes "red B p q"
	+ obtains b where "b \<in> B" and "b \<noteq> 0" and "red {b} p q"
	+proof -
	+ from assms obtain b t where "b \<in> B" and "red_single p q b t" by (rule red_setE)
	+ from this(2) have "b \<noteq> 0" by (simp add: red_single_def)
	+ have "red {b} p q" by (rule red_setI, simp, fact)
	+ show ?thesis by (rule, fact+)
	+qed
	+
	+lemma red_monomial_keys:
	+ assumes "is_monomial r" and "red {r} p q"
	+ shows "card (keys p) = Suc (card (keys q))"
	+proof -
	+ from assms(2) obtain s where rs: "red_single p q r s" unfolding red_singleton ..
	+ hence cp0: "lookup p (s \<oplus> lt r) \<noteq> 0" and q_def0: "q = p - monom_mult (lookup p (s \<oplus> lt r) / lc r) s r"
	+ unfolding red_single_def by simp_all
	+ from assms(1) obtain c t where "c \<noteq> 0" and r_def: "r = monomial c t" by (rule is_monomial_monomial)
	+ have ltr: "lt r = t" unfolding r_def by (rule lt_monomial, fact)
	+ have lcr: "lc r = c" unfolding r_def by (rule lc_monomial)
	+ define u where "u = s \<oplus> t"
	+ from q_def0 have "q = p - monom_mult (lookup p u / c) s r" unfolding u_def ltr lcr .
	+ also have "... = p - monomial ((lookup p u / c) * c) u" unfolding u_def r_def monom_mult_monomial ..
	+ finally have q_def: "q = p - monomial (lookup p u) u" using \<open>c \<noteq> 0\<close> by simp
	+ from cp0 have "lookup p u \<noteq> 0" unfolding u_def ltr .
	+ hence "u \<in> keys p" by (simp add: in_keys_iff)
	+
	+ have "keys q = keys p - {u}" unfolding q_def
	+ proof (rule, rule)
	+ fix x
	+ assume "x \<in> keys (p - monomial (lookup p u) u)"
	+ hence "lookup (p - monomial (lookup p u) u) x \<noteq> 0" by (simp add: in_keys_iff)
	+ hence a: "lookup p x - lookup (monomial (lookup p u) u) x \<noteq> 0" unfolding lookup_minus .
	+ hence "x \<noteq> u" unfolding lookup_single by auto
	+ with a have "lookup p x \<noteq> 0" unfolding lookup_single by auto
	+ show "x \<in> keys p - {u}"
	+ proof
	+ from \<open>lookup p x \<noteq> 0\<close> show "x \<in> keys p" by (simp add: in_keys_iff)
	+ next
	+ from \<open>x \<noteq> u\<close> show "x \<notin> {u}" by simp
	+ qed
	+ next
	+ show "keys p - {u} \<subseteq> keys (p - monomial (lookup p u) u)"
	+ proof
	+ fix x
	+ assume "x \<in> keys p - {u}"
	+ hence "x \<in> keys p" and "x \<noteq> u" by auto
	+ from \<open>x \<in> keys p\<close> have "lookup p x \<noteq> 0" by (simp add: in_keys_iff)
	+ with \<open>x \<noteq> u\<close> have "lookup (p - monomial (lookup p u) u) x \<noteq> 0" by (simp add: lookup_minus lookup_single)
	+ thus "x \<in> keys (p - monomial (lookup p u) u)" by (simp add: in_keys_iff)
	+ qed
	+ qed
	+
	+ have "Suc (card (keys q)) = card (keys p)" unfolding \<open>keys q = keys p - {u}\<close>
	+ by (rule card_Suc_Diff1, rule finite_keys, fact)
	+ thus ?thesis by simp
	+qed
	+
	+lemma red_monomial_monomial_setD:
	+ assumes "is_monomial p" and "is_monomial_set B" and "red B p q"
	+ shows "q = 0"
	+proof -
	+ from assms(3) obtain b where "b \<in> B" and "b \<noteq> 0" and *: "red {b} p q" by (rule red_setE2)
	+ from assms(2) this(1) have "is_monomial b" by (rule is_monomial_setD)
	+ hence "card (keys p) = Suc (card (keys q))" using * by (rule red_monomial_keys)
	+ with assms(1) show ?thesis by (simp add: is_monomial_def)
	+qed
	+
	+corollary is_red_monomial_monomial_setD:
	+ assumes "is_monomial p" and "is_monomial_set B" and "is_red B p"
	+ shows "red B p 0"
	+proof -
	+ from assms(3) obtain q where "red B p q" by (rule is_redE)
	+ moreover from assms(1, 2) this have "q = 0" by (rule red_monomial_monomial_setD)
	+ ultimately show ?thesis by simp
	+qed
	+
	+corollary is_red_monomial_monomial_set_in_pmdl:
	+ "is_monomial p \<Longrightarrow> is_monomial_set B \<Longrightarrow> is_red B p \<Longrightarrow> p \<in> pmdl B"
	+ by (intro red_rtranclp_0_in_pmdl r_into_rtranclp is_red_monomial_monomial_setD)
	+
	+corollary red_rtrancl_monomial_monomial_set_cases:
	+ assumes "is_monomial p" and "is_monomial_set B" and "(red B)\<^sup>\<^sup> p q"
	+ obtains "q = p" \| "q = 0"
	+ using assms(3)
	+proof (induct q arbitrary: thesis rule: rtranclp_induct)
	+ case base
	+ from refl show ?case by (rule base)
	+next
	+ case (step y z)
	+ show ?case
	+ proof (rule step.hyps)
	+ assume "y = p"
	+ with step.hyps(2) have "red B p z" by simp
	+ with assms(1, 2) have "z = 0" by (rule red_monomial_monomial_setD)
	+ thus ?thesis by (rule step.prems)
	+ next
	+ assume "y = 0"
	+ from step.hyps(2) have "is_red B 0" unfolding \<open>y = 0\<close> by (rule is_redI)
	+ with irred_0 show ?thesis ..
	+ qed
	+qed
	+
	+lemma is_red_monomial_lt:
	+ assumes "0 \<notin> B"
	+ shows "is_red (monomial (1::'b::field) ` lt ` B) = is_red B"
	+proof
	+ fix p
	+ let ?B = "monomial (1::'b) ` lt ` B"
	+ show "is_red ?B p \<longleftrightarrow> is_red B p"
	+ proof
	+ assume "is_red ?B p"
	+ then obtain f v where "f \<in> ?B" and "v \<in> keys p" and adds: "lt f adds\<^sub>t v" by (rule is_red_addsE)
	+ from this(1) have "lt f \<in> lt ` ?B" by (rule imageI)
	+ also have "\<dots> = lt ` B" by (fact image_lt_monomial_lt)
	+ finally obtain b where "b \<in> B" and eq: "lt f = lt b" ..
	+ note this(1)
	+ moreover from this assms have "b \<noteq> 0" by blast
	+ moreover note \<open>v \<in> keys p\<close>
	+ moreover from adds have "lt b adds\<^sub>t v" by (simp only: eq)
	+ ultimately show "is_red B p" by (rule is_red_addsI)
	+ next
	+ assume "is_red B p"
	+ then obtain b v where "b \<in> B" and "v \<in> keys p" and adds: "lt b adds\<^sub>t v" by (rule is_red_addsE)
	+ from this(1) have "lt b \<in> lt ` B" by (rule imageI)
	+ also from image_lt_monomial_lt have "\<dots> = lt ` ?B" by (rule sym)
	+ finally obtain f where "f \<in> ?B" and eq: "lt b = lt f" ..
	+ note this(1)
	+ moreover from this have "f \<noteq> 0" by (auto simp: monomial_0_iff)
	+ moreover note \<open>v \<in> keys p\<close>
	+ moreover from adds have "lt f adds\<^sub>t v" by (simp only: eq)
	+ ultimately show "is_red ?B p" by (rule is_red_addsI)
	+ qed
	+qed
	+
	+end (* ordered_term *)
	+
	+subsection \<open>Gr\"obner Bases\<close>
	+
	+context gd_term
	+begin
	+
	+lemma monomial_set_is_GB:
	+ assumes "is_monomial_set G"
	+ shows "is_Groebner_basis G"
	+ unfolding GB_alt_1
	+proof
	+ fix f
	+ assume "f \<in> pmdl G"
	+ thus "(red G)\<^sup>\<^sup> f 0"
	+ proof (induct f rule: poly_mapping_plus_induct)
	+ case 1
	+ show ?case ..
	+ next
	+ case (2 f c t)
	+ let ?f = "monomial c t + f"
	+ from 2(1) have "t \<in> keys (monomial c t)" by simp
	+ from this 2(2) have "t \<in> keys ?f" by (rule in_keys_plusI1)
	+ with assms \<open>?f \<in> pmdl G\<close> obtain g where "g \<in> G" and "g \<noteq> 0" and "lt g adds\<^sub>t t"
	+ by (rule keys_monomial_pmdl)
	+ from this(1) have "red G ?f f"
	+ proof (rule red_setI)
	+ from \<open>lt g adds\<^sub>t t\<close> have "component_of_term (lt g) = component_of_term t" and "lp g adds pp_of_term t"
	+ by (simp_all add: adds_term_def)
	+ from this have eq: "(pp_of_term t - lp g) \<oplus> lt g = t"
	+ by (simp add: adds_minus splus_def term_of_pair_pair)
	+ moreover from 2(2) have "lookup ?f t = c" by (simp add: lookup_add in_keys_iff)
	+ ultimately show "red_single (monomial c t + f) f g (pp_of_term t - lp g)"
	+ proof (simp add: red_single_def \<open>g \<noteq> 0\<close> \<open>t \<in> keys ?f\<close> 2(1))
	+ from \<open>g \<noteq> 0\<close> have "lc g \<noteq> 0" by (rule lc_not_0)
	+ hence "monomial c t = monom_mult (c / lc g) (pp_of_term t - lp g) (monomial (lc g) (lt g))"
	+ by (simp add: monom_mult_monomial eq)
	+ moreover from assms \<open>g \<in> G\<close> have "is_monomial g" unfolding is_monomial_set_def ..
	+ ultimately show "monomial c t = monom_mult (c / lc g) (pp_of_term t - lp g) g"
	+ by (simp only: monomial_eq_itself)
	+ qed
	+ qed
	+ have "f \<in> pmdl G" by (rule pmdl_closed_red, fact subset_refl, fact+)
	+ hence "(red G)\<^sup>\<^sup> f 0" by (rule 2(3))
	+ with \<open>red G ?f f\<close> show ?case by simp
	+ qed
	+qed
	+
	+context
	+ fixes d
	+ assumes dgrad: "dickson_grading (d::'a \<Rightarrow> nat)"
	+begin
	+
	+context
	+ fixes F m
	+ assumes fin_comps: "finite (component_of_term ` Keys F)"
	+ and F_sub: "F \<subseteq> dgrad_p_set d m"
	+ and F_monom: "is_monomial_set (F::(_ \<Rightarrow>\<^sub>0 'b::field) set)"
	+begin
	+
	+text \<open>The proof of the following lemma could be simplified, analogous to homogeneous ideals.\<close>
	+
	+lemma reduced_GB_subset_monic_dgrad_p_set: "reduced_GB F \<subseteq> monic ` F"
	+proof -
	+ from subset_refl obtain F' where "F' \<subseteq> F - {0}" and "lt ` (F - {0}) = lt ` F'" and "inj_on lt F'"
	+ by (rule subset_imageE_inj)
	+ define G where "G = {f \<in> F'. \<forall>f'\<in>F'. lt f' adds\<^sub>t lt f \<longrightarrow> f' = f}"
	+ have "G \<subseteq> F'" by (simp add: G_def)
	+ hence "G \<subseteq> F - {0}" using \<open>F' \<subseteq> F - {0}\<close> by (rule subset_trans)
	+ also have "\<dots> \<subseteq> F" by blast
	+ finally have "G \<subseteq> F" .
	+ have 1: thesis if "f \<in> F" and "f \<noteq> 0" and "\<And>g. g \<in> G \<Longrightarrow> lt g adds\<^sub>t lt f \<Longrightarrow> thesis" for thesis f
	+ proof -
	+ let ?K = "component_of_term ` Keys F"
	+ let ?A = "{t. pp_of_term t \<in> dgrad_set d m \<and> component_of_term t \<in> ?K}"
	+ let ?Q = "{f' \<in> F'. lt f' adds\<^sub>t lt f}"
	+ from dgrad fin_comps have "almost_full_on (adds\<^sub>t) ?A" by (rule Dickson_term)
	+ moreover have "transp_on (adds\<^sub>t) ?A" by (auto intro: transp_onI dest: adds_term_trans)
	+ ultimately have "wfp_on (strict (adds\<^sub>t)) ?A" by (rule af_trans_imp_wf)
	+ moreover have "lt f \<in> lt ` ?Q"
	+ proof -
	+ from that(1, 2) have "f \<in> F - {0}" by simp
	+ hence "lt f \<in> lt ` (F - {0})" by (rule imageI)
	+ also have "\<dots> = lt ` F'" by fact
	+ finally have "lt f \<in> lt ` F'" .
	+ with adds_term_refl show ?thesis by fastforce
	+ qed
	+ moreover have "lt ` ?Q \<subseteq> ?A"
	+ proof
	+ fix s
	+ assume "s \<in> lt ` ?Q"
	+ then obtain q where "q \<in> ?Q" and s: "s = lt q" ..
	+ from this(1) have "q \<in> F'" by simp
	+ hence "q \<in> F - {0}" using \<open>F' \<subseteq> F - {0}\<close> ..
	+ hence "q \<in> F" and "q \<noteq> 0" by simp_all
	+ from this(1) F_sub have "q \<in> dgrad_p_set d m" ..
	+ from \<open>q \<noteq> 0\<close> have "lt q \<in> keys q" by (rule lt_in_keys)
	+ hence "pp_of_term (lt q) \<in> pp_of_term ` keys q" by (rule imageI)
	+ also from \<open>q \<in> dgrad_p_set d m\<close> have "\<dots> \<subseteq> dgrad_set d m" by (simp add: dgrad_p_set_def)
	+ finally have 1: "pp_of_term s \<in> dgrad_set d m" by (simp only: s)
	+ from \<open>lt q \<in> keys q\<close> \<open>q \<in> F\<close> have "lt q \<in> Keys F" by (rule in_KeysI)
	+ hence "component_of_term s \<in> ?K" unfolding s by (rule imageI)
	+ with 1 show "s \<in> ?A" by simp
	+ qed
	+ ultimately obtain t where "t \<in> lt ` ?Q" and t_min: "\<And>s. strict (adds\<^sub>t) s t \<Longrightarrow> s \<notin> lt ` ?Q"
	+ by (rule wfp_onE_min) blast
	+ from this(1) obtain g where "g \<in> ?Q" and t: "t = lt g" ..
	+ from this(1) have "g \<in> F'" and adds: "lt g adds\<^sub>t lt f" by simp_all
	+ show ?thesis
	+ proof (rule that)
	+ {
	+ fix f'
	+ assume "f' \<in> F'"
	+ assume "lt f' adds\<^sub>t lt g"
	+ hence "lt f' adds\<^sub>t lt f" using adds by (rule adds_term_trans)
	+ with \<open>f' \<in> F'\<close> have "f' \<in> ?Q" by simp
	+ hence "lt f' \<in> lt ` ?Q" by (rule imageI)
	+ with t_min have "\<not> strict (adds\<^sub>t) (lt f') (lt g)" unfolding t by blast
	+ with \<open>lt f' adds\<^sub>t lt g\<close> have "lt g adds\<^sub>t lt f'" by blast
	+ with \<open>lt f' adds\<^sub>t lt g\<close> have "lt f' = lt g" by (rule adds_term_antisym)
	+ with \<open>inj_on lt F'\<close> have "f' = g" using \<open>f' \<in> F'\<close> \<open>g \<in> F'\<close> by (rule inj_onD)
	+ }
	+ with \<open>g \<in> F'\<close> show "g \<in> G" by (simp add: G_def)
	+ qed fact
	+ qed
	+ have 2: "is_red G q" if "q \<in> pmdl F" and "q \<noteq> 0" for q
	+ proof -
	+ from that(2) have "keys q \<noteq> {}" by simp
	+ then obtain t where "t \<in> keys q" by blast
	+ with F_monom that(1) obtain f where "f \<in> F" and "f \<noteq> 0" and *: "lt f adds\<^sub>t t"
	+ by (rule keys_monomial_pmdl)
	+ from this(1, 2) obtain g where "g \<in> G" and "lt g adds\<^sub>t lt f" by (rule 1)
	+ from this(2) have *: "lt g adds\<^sub>t t" using by (rule adds_term_trans)
	+ from \<open>g \<in> G\<close> \<open>G \<subseteq> F - {0}\<close> have "g \<in> F - {0}" ..
	+ hence "g \<noteq> 0" by simp
	+ with \<open>g \<in> G\<close> show ?thesis using \<open>t \<in> keys q\<close> ** by (rule is_red_addsI)
	+ qed
	+ from \<open>G \<subseteq> F - {0}\<close> have "G \<subseteq> F" by blast
	+ hence "pmdl G \<subseteq> pmdl F" by (rule pmdl.span_mono)
	+ note dgrad fin_comps F_sub
	+ moreover have "is_reduced_GB (monic ` G)" unfolding is_reduced_GB_def GB_image_monic
	+ proof (intro conjI image_monic_is_auto_reduced image_monic_is_monic_set)
	+ from dgrad show "is_Groebner_basis G"
	+ proof (rule isGB_I_is_red)
	+ from \<open>G \<subseteq> F\<close> F_sub show "G \<subseteq> dgrad_p_set d m" by (rule subset_trans)
	+ next
	+ fix f
	+ assume "f \<in> pmdl G"
	+ hence "f \<in> pmdl F" using \<open>pmdl G \<subseteq> pmdl F\<close> ..
	+ moreover assume "f \<noteq> 0"
	+ ultimately show "is_red G f" by (rule 2)
	+ qed
	+ next
	+ show "is_auto_reduced G" unfolding is_auto_reduced_def
	+ proof (intro ballI notI)
	+ fix g
	+ assume "g \<in> G"
	+ hence "g \<in> F" using \<open>G \<subseteq> F\<close> ..
	+ with F_monom have "is_monomial g" by (rule is_monomial_setD)
	+ hence keys_g: "keys g = {lt g}" by (rule keys_monomial)
	+ assume "is_red (G - {g}) g"
	+ then obtain g' t where "g' \<in> G - {g}" and "t \<in> keys g" and adds: "lt g' adds\<^sub>t t" by (rule is_red_addsE)
	+ from this(1) have "g' \<in> F'" and "g' \<noteq> g" by (simp_all add: G_def)
	+ from \<open>t \<in> keys g\<close> have "t = lt g" by (simp add: keys_g)
	+ with \<open>g \<in> G\<close> \<open>g' \<in> F'\<close> adds have "g' = g" by (simp add: G_def)
	+ with \<open>g' \<noteq> g\<close> show False ..
	+ qed
	+ next
	+ show "0 \<notin> monic ` G"
	+ proof
	+ assume "0 \<in> monic ` G"
	+ then obtain g where "0 = monic g" and "g \<in> G" ..
	+ moreover from this(2) \<open>G \<subseteq> F - {0}\<close> have "g \<noteq> 0" by blast
	+ ultimately show False by (simp add: monic_0_iff)
	+ qed
	+ qed
	+ moreover have "pmdl (monic ` G) = pmdl F" unfolding pmdl_image_monic
	+ proof
	+ show "pmdl F \<subseteq> pmdl G"
	+ proof (rule pmdl.span_subset_spanI, rule)
	+ fix f
	+ assume "f \<in> F"
	+ hence "f \<in> pmdl F" by (rule pmdl.span_base)
	+ note dgrad
	+ moreover from \<open>G \<subseteq> F\<close> F_sub have "G \<subseteq> dgrad_p_set d m" by (rule subset_trans)
	+ moreover note \<open>pmdl G \<subseteq> pmdl F\<close> 2 \<open>f \<in> pmdl F\<close>
	+ moreover from \<open>f \<in> F\<close> F_sub have "f \<in> dgrad_p_set d m" ..
	+ ultimately have "(red G)\<^sup>\<^sup> f 0" by (rule is_red_implies_0_red_dgrad_p_set)
	+ thus "f \<in> pmdl G" by (rule red_rtranclp_0_in_pmdl)
	+ qed
	+ qed fact
	+ ultimately have "reduced_GB F = monic ` G" by (rule reduced_GB_unique_dgrad_p_set)
	+ also from \<open>G \<subseteq> F\<close> have "\<dots> \<subseteq> monic ` F" by (rule image_mono)
	+ finally show ?thesis .
	+qed
	+
	+corollary reduced_GB_is_monomial_set_dgrad_p_set: "is_monomial_set (reduced_GB F)"
	+proof (rule is_monomial_setI)
	+ fix g
	+ assume "g \<in> reduced_GB F"
	+ also have "\<dots> \<subseteq> monic ` F" by (fact reduced_GB_subset_monic_dgrad_p_set)
	+ finally obtain f where "f \<in> F" and g: "g = monic f" ..
	+ from F_monom this(1) have "is_monomial f" by (rule is_monomial_setD)
	+ hence "card (keys f) = 1" by (simp only: is_monomial_def)
	+ hence "f \<noteq> 0" by auto
	+ hence "lc f \<noteq> 0" by (rule lc_not_0)
	+ hence "1 / lc f \<noteq> 0" by simp
	+ hence "keys g = (\<oplus>) 0 ` keys f" by (simp add: keys_monom_mult monic_def g)
	+ also from refl have "\<dots> = (\<lambda>x. x) ` keys f" by (rule image_cong) (simp only: splus_zero)
	+ finally show "is_monomial g" using \<open>card (keys f) = 1\<close> by (simp only: is_monomial_def image_ident)
	+qed
	+
	+end
	+
	+lemma is_red_reduced_GB_monomial_dgrad_set:
	+ assumes "finite (component_of_term ` S)" and "pp_of_term ` S \<subseteq> dgrad_set d m"
	+ shows "is_red (reduced_GB (monomial 1 ` S)) = is_red (monomial (1::'b::field) ` S)"
	+proof
	+ fix p
	+ let ?F = "monomial (1::'b) ` S"
	+ from assms(1) have 1: "finite (component_of_term ` Keys ?F)" by (simp add: Keys_def)
	+ moreover from assms(2) have 2: "?F \<subseteq> dgrad_p_set d m" by (auto simp: dgrad_p_set_def)
	+ moreover have "is_monomial_set ?F" by (auto intro!: is_monomial_setI monomial_is_monomial)
	+ ultimately have "reduced_GB ?F \<subseteq> monic ` ?F" by (rule reduced_GB_subset_monic_dgrad_p_set)
	+ also have "\<dots> = ?F" by (auto simp: monic_def intro!: image_eqI)
	+ finally have 3: "reduced_GB ?F \<subseteq> ?F" .
	+ show "is_red (reduced_GB ?F) p \<longleftrightarrow> is_red ?F p"
	+ proof
	+ assume "is_red (reduced_GB ?F) p"
	+ thus "is_red ?F p" using 3 by (rule is_red_subset)
	+ next
	+ assume "is_red ?F p"
	+ then obtain f v where "f \<in> ?F" and "v \<in> keys p" and "f \<noteq> 0" and adds1: "lt f adds\<^sub>t v"
	+ by (rule is_red_addsE)
	+ from this(1) have "f \<in> pmdl ?F" by (rule pmdl.span_base)
	+ from dgrad 1 2 have "is_Groebner_basis (reduced_GB ?F)" by (rule reduced_GB_is_GB_dgrad_p_set)
	+ moreover from \<open>f \<in> pmdl ?F\<close> dgrad 1 2 have "f \<in> pmdl (reduced_GB ?F)"
	+ by (simp only: reduced_GB_pmdl_dgrad_p_set)
	+ ultimately obtain g where "g \<in> reduced_GB ?F" and "g \<noteq> 0" and "lt g adds\<^sub>t lt f"
	+ using \<open>f \<noteq> 0\<close> by (rule GB_adds_lt)
	+ from this(3) adds1 have "lt g adds\<^sub>t v" by (rule adds_term_trans)
	+ with \<open>g \<in> reduced_GB ?F\<close> \<open>g \<noteq> 0\<close> \<open>v \<in> keys p\<close> show "is_red (reduced_GB ?F) p"
	+ by (rule is_red_addsI)
	+ qed
	+qed
	+
	+corollary is_red_reduced_GB_monomial_lt_GB_dgrad_p_set:
	+ assumes "finite (component_of_term ` Keys G)" and "G \<subseteq> dgrad_p_set d m" and "0 \<notin> G"
	+ shows "is_red (reduced_GB (monomial (1::'b::field) ` lt ` G)) = is_red G"
	+proof -
	+ let ?S = "lt ` G"
	+ let ?G = "monomial (1::'b) ` ?S"
	+ from assms(3) have "?S \<subseteq> Keys G" by (auto intro: lt_in_keys in_KeysI)
	+ hence "component_of_term ` ?S \<subseteq> component_of_term ` Keys G"
	+ and *: "pp_of_term ` ?S \<subseteq> pp_of_term ` Keys G" by (rule image_mono)+
	+ from this(1) have "finite (component_of_term ` ?S)" using assms(1) by (rule finite_subset)
	+ moreover from * have "pp_of_term ` ?S \<subseteq> dgrad_set d m"
	+ proof (rule subset_trans)
	+ from assms(2) show "pp_of_term ` Keys G \<subseteq> dgrad_set d m" by (auto simp: dgrad_p_set_def Keys_def)
	+ qed
	+ ultimately have "is_red (reduced_GB ?G) = is_red ?G" by (rule is_red_reduced_GB_monomial_dgrad_set)
	+ also from assms(3) have "\<dots> = is_red G" by (rule is_red_monomial_lt)
	+ finally show ?thesis .
	+qed
	+
	+lemma reduced_GB_monomial_lt_reduced_GB_dgrad_p_set:
	+ assumes "finite (component_of_term ` Keys F)" and "F \<subseteq> dgrad_p_set d m"
	+ shows "reduced_GB (monomial 1 ` lt ` reduced_GB F) = monomial (1::'b::field) ` lt ` reduced_GB F"
	+proof (rule reduced_GB_unique)
	+ let ?G = "reduced_GB F"
	+ let ?F = "monomial (1::'b) ` lt ` ?G"
	+
	+ from dgrad assms have "0 \<notin> ?G" and ar: "is_auto_reduced ?G" and "finite ?G"
	+ by (rule reduced_GB_nonzero_dgrad_p_set, rule reduced_GB_is_auto_reduced_dgrad_p_set,
	+ rule finite_reduced_GB_dgrad_p_set)
	+ from this(3) show "finite ?F" by (intro finite_imageI)
	+
	+ show "is_reduced_GB ?F" unfolding is_reduced_GB_def
	+ proof (intro conjI monomial_set_is_GB)
	+ show "is_monomial_set ?F" by (auto intro!: is_monomial_setI monomial_is_monomial)
	+ next
	+ show "is_monic_set ?F" by (simp add: is_monic_set_def)
	+ next
	+ show "0 \<notin> ?F" by (auto simp: monomial_0_iff)
	+ next
	+ show "is_auto_reduced ?F" unfolding is_auto_reduced_def
	+ proof (intro ballI notI)
	+ fix f
	+ assume "f \<in> ?F"
	+ then obtain g where "g \<in> ?G" and f: "f = monomial 1 (lt g)" by blast
	+ assume "is_red (?F - {f}) f"
	+ then obtain f' v where "f' \<in> ?F - {f}" and "v \<in> keys f" and "f' \<noteq> 0" and adds1: "lt f' adds\<^sub>t v"
	+ by (rule is_red_addsE)
	+ from this(1) have "f' \<in> ?F" and "f' \<noteq> f" by simp_all
	+ from this(1) obtain g' where "g' \<in> ?G" and f': "f' = monomial 1 (lt g')" by blast
	+ from \<open>v \<in> keys f\<close> have v: "v = lt g" by (simp add: f)
	+ from ar \<open>g \<in> ?G\<close> have "\<not> is_red (?G - {g}) g" by (rule is_auto_reducedD)
	+ moreover have "is_red (?G - {g}) g"
	+ proof (rule is_red_addsI)
	+ from \<open>g' \<in> ?G\<close> \<open>f' \<noteq> f\<close> show "g' \<in> ?G - {g}" by (auto simp: f f')
	+ next
	+ from \<open>g' \<in> ?G\<close> \<open>0 \<notin> ?G\<close> show "g' \<noteq> 0" by blast
	+ next
	+ from \<open>g \<in> ?G\<close> \<open>0 \<notin> ?G\<close> have "g \<noteq> 0" by blast
	+ thus "lt g \<in> keys g" by (rule lt_in_keys)
	+ next
	+ from adds1 show adds2: "lt g' adds\<^sub>t lt g" by (simp add: v f' lt_monomial)
	+ qed
	+ ultimately show False ..
	+ qed
	+ qed
	+qed (fact refl)
	+
	+end
	+
	+end (* gd_term *)
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/Poly_Fun.thy b/thys/Groebner_Macaulay/Poly_Fun.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/Poly_Fun.thy
	@@ -0,0 +1,218 @@
	+section \<open>Integer Polynomial Functions\<close>
	+
	+theory Poly_Fun
	+ imports Binomial_Int "HOL-Computational_Algebra.Polynomial"
	+begin
	+
	+subsection \<open>Definition and Basic Properties\<close>
	+
	+definition poly_fun :: "(int \<Rightarrow> int) \<Rightarrow> bool"
	+ where "poly_fun f \<longleftrightarrow> (\<exists>p::rat poly. \<forall>a. rat_of_int (f a) = poly p (rat_of_int a))"
	+
	+lemma poly_funI: "(\<And>a. rat_of_int (f a) = poly p (rat_of_int a)) \<Longrightarrow> poly_fun f"
	+ by (auto simp: poly_fun_def)
	+
	+lemma poly_funE:
	+ assumes "poly_fun f"
	+ obtains p where "\<And>a. rat_of_int (f a) = poly p (rat_of_int a)"
	+ using assms by (auto simp: poly_fun_def)
	+
	+lemma poly_fun_eqI:
	+ assumes "poly_fun f" and "poly_fun g" and "infinite {a. f a = g a}"
	+ shows "f = g"
	+proof (rule ext)
	+ fix a
	+ from assms(1) obtain p where p: "\<And>a. rat_of_int (f a) = poly p (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ from assms(2) obtain q where q: "\<And>a. rat_of_int (g a) = poly q (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ have "p = q"
	+ proof (rule ccontr)
	+ let ?A = "{a. poly p (rat_of_int a) = poly q (rat_of_int a)}"
	+ assume "p \<noteq> q"
	+ hence "p - q \<noteq> 0" by simp
	+ hence fin: "finite {x. poly (p - q) x = 0}" by (rule poly_roots_finite)
	+ have "rat_of_int ` ?A \<subseteq> {x. poly (p - q) x = 0}" by (simp add: image_Collect_subsetI)
	+ hence "finite (rat_of_int ` ?A)" using fin by (rule finite_subset)
	+ moreover have "inj_on rat_of_int ?A" by (simp add: inj_on_def)
	+ ultimately have "finite ?A" by (simp only: finite_image_iff)
	+ also have "?A = {a. f a = g a}" by (simp flip: p q)
	+ finally show False using assms(3) by simp
	+ qed
	+ hence "rat_of_int (f a) = rat_of_int (g a)" by (simp add: p q)
	+ thus "f a = g a" by simp
	+qed
	+
	+corollary poly_fun_eqI_ge:
	+ assumes "poly_fun f" and "poly_fun g" and "\<And>a. b \<le> a \<Longrightarrow> f a = g a"
	+ shows "f = g"
	+ using assms(1, 2)
	+proof (rule poly_fun_eqI)
	+ have "{b..} \<subseteq> {a. f a = g a}" by (auto intro: assms(3))
	+ thus "infinite {a. f a = g a}" using infinite_Ici by (rule infinite_super)
	+qed
	+
	+corollary poly_fun_eqI_gr:
	+ assumes "poly_fun f" and "poly_fun g" and "\<And>a. b < a \<Longrightarrow> f a = g a"
	+ shows "f = g"
	+ using assms(1, 2)
	+proof (rule poly_fun_eqI)
	+ have "{b<..} \<subseteq> {a. f a = g a}" by (auto intro: assms(3))
	+ thus "infinite {a. f a = g a}" using infinite_Ioi by (rule infinite_super)
	+qed
	+
	+subsection \<open>Closure Properties\<close>
	+
	+lemma poly_fun_const [simp]: "poly_fun (\<lambda>_. c)"
	+ by (rule poly_funI[where p="[:rat_of_int c:]"]) simp
	+
	+lemma poly_fun_id [simp]: "poly_fun (\<lambda>x. x)" "poly_fun id"
	+proof -
	+ show "poly_fun (\<lambda>x. x)" by (rule poly_funI[where p="[:0, 1:]"]) simp
	+ thus "poly_fun id" by (simp only: id_def)
	+qed
	+
	+lemma poly_fun_uminus:
	+ assumes "poly_fun f"
	+ shows "poly_fun (\<lambda>x. - f x)" and "poly_fun (- f)"
	+proof -
	+ from assms obtain p where p: "\<And>a. rat_of_int (f a) = poly p (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ show "poly_fun (\<lambda>x. - f x)" by (rule poly_funI[where p="- p"]) (simp add: p)
	+ thus "poly_fun (- f)" by (simp only: fun_Compl_def)
	+qed
	+
	+lemma poly_fun_uminus_iff [simp]:
	+ "poly_fun (\<lambda>x. - f x) \<longleftrightarrow> poly_fun f" "poly_fun (- f) \<longleftrightarrow> poly_fun f"
	+proof -
	+ show "poly_fun (\<lambda>x. - f x) \<longleftrightarrow> poly_fun f"
	+ proof
	+ assume "poly_fun (\<lambda>x. - f x)"
	+ hence "poly_fun (\<lambda>x. - (- f x))" by (rule poly_fun_uminus)
	+ thus "poly_fun f" by simp
	+ qed (rule poly_fun_uminus)
	+ thus "poly_fun (- f) \<longleftrightarrow> poly_fun f" by (simp only: fun_Compl_def)
	+qed
	+
	+lemma poly_fun_plus [simp]:
	+ assumes "poly_fun f" and "poly_fun g"
	+ shows "poly_fun (\<lambda>x. f x + g x)"
	+proof -
	+ from assms(1) obtain p where p: "\<And>a. rat_of_int (f a) = poly p (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ from assms(2) obtain q where q: "\<And>a. rat_of_int (g a) = poly q (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ show ?thesis by (rule poly_funI[where p="p + q"]) (simp add: p q)
	+qed
	+
	+lemma poly_fun_minus [simp]:
	+ assumes "poly_fun f" and "poly_fun g"
	+ shows "poly_fun (\<lambda>x. f x - g x)"
	+proof -
	+ from assms(1) obtain p where p: "\<And>a. rat_of_int (f a) = poly p (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ from assms(2) obtain q where q: "\<And>a. rat_of_int (g a) = poly q (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ show ?thesis by (rule poly_funI[where p="p - q"]) (simp add: p q)
	+qed
	+
	+lemma poly_fun_times [simp]:
	+ assumes "poly_fun f" and "poly_fun g"
	+ shows "poly_fun (\<lambda>x. f x * g x)"
	+proof -
	+ from assms(1) obtain p where p: "\<And>a. rat_of_int (f a) = poly p (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ from assms(2) obtain q where q: "\<And>a. rat_of_int (g a) = poly q (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ show ?thesis by (rule poly_funI[where p="p * q"]) (simp add: p q)
	+qed
	+
	+lemma poly_fun_divide:
	+ assumes "poly_fun f" and "\<And>a. c dvd f a"
	+ shows "poly_fun (\<lambda>x. f x div c)"
	+proof -
	+ from assms(1) obtain p where p: "\<And>a. rat_of_int (f a) = poly p (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ let ?p = "p * [:1 / rat_of_int c:]"
	+ show ?thesis
	+ proof (rule poly_funI)
	+ fix a
	+ have "c dvd f a" by fact
	+ hence "rat_of_int (f a div c) = rat_of_int (f a) / rat_of_int c" by auto
	+ also have "\<dots> = poly ?p (rat_of_int a)" by (simp add: p)
	+ finally show "rat_of_int (f a div c) = poly ?p (rat_of_int a)" .
	+ qed
	+qed
	+
	+lemma poly_fun_pow [simp]:
	+ assumes "poly_fun f"
	+ shows "poly_fun (\<lambda>x. f x ^ k)"
	+proof -
	+ from assms(1) obtain p where p: "\<And>a. rat_of_int (f a) = poly p (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ show ?thesis by (rule poly_funI[where p="p ^ k"]) (simp add: p)
	+qed
	+
	+lemma poly_fun_comp:
	+ assumes "poly_fun f" and "poly_fun g"
	+ shows "poly_fun (\<lambda>x. f (g x))" and "poly_fun (f \<circ> g)"
	+proof -
	+ from assms(1) obtain p where p: "\<And>a. rat_of_int (f a) = poly p (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ from assms(2) obtain q where q: "\<And>a. rat_of_int (g a) = poly q (rat_of_int a)"
	+ by (rule poly_funE, blast)
	+ show "poly_fun (\<lambda>x. f (g x))" by (rule poly_funI[where p="p \<circ>\<^sub>p q"]) (simp add: p q poly_pcompose)
	+ thus "poly_fun (f \<circ> g)" by (simp only: comp_def)
	+qed
	+
	+lemma poly_fun_sum [simp]: "(\<And>i. i \<in> I \<Longrightarrow> poly_fun (f i)) \<Longrightarrow> poly_fun (\<lambda>x. (\<Sum>i\<in>I. f i x))"
	+proof (induct I rule: infinite_finite_induct)
	+ case (infinite I)
	+ from infinite(1) show ?case by simp
	+next
	+ case empty
	+ show ?case by simp
	+next
	+ case (insert i I)
	+ have "i \<in> insert i I" by simp
	+ hence "poly_fun (f i)" by (rule insert.prems)
	+ moreover have "poly_fun (\<lambda>x. \<Sum>i\<in>I. f i x)"
	+ proof (rule insert.hyps)
	+ fix j
	+ assume "j \<in> I"
	+ hence "j \<in> insert i I" by simp
	+ thus "poly_fun (f j)" by (rule insert.prems)
	+ qed
	+ ultimately have "poly_fun (\<lambda>x. f i x + (\<Sum>i\<in>I. f i x))" by (rule poly_fun_plus)
	+ with insert.hyps(1, 2) show ?case by simp
	+qed
	+
	+lemma poly_fun_prod [simp]: "(\<And>i. i \<in> I \<Longrightarrow> poly_fun (f i)) \<Longrightarrow> poly_fun (\<lambda>x. (\<Prod>i\<in>I. f i x))"
	+proof (induct I rule: infinite_finite_induct)
	+ case (infinite I)
	+ from infinite(1) show ?case by simp
	+next
	+ case empty
	+ show ?case by simp
	+next
	+ case (insert i I)
	+ have "i \<in> insert i I" by simp
	+ hence "poly_fun (f i)" by (rule insert.prems)
	+ moreover have "poly_fun (\<lambda>x. \<Prod>i\<in>I. f i x)"
	+ proof (rule insert.hyps)
	+ fix j
	+ assume "j \<in> I"
	+ hence "j \<in> insert i I" by simp
	+ thus "poly_fun (f j)" by (rule insert.prems)
	+ qed
	+ ultimately have "poly_fun (\<lambda>x. f i x * (\<Prod>i\<in>I. f i x))" by (rule poly_fun_times)
	+ with insert.hyps(1, 2) show ?case by simp
	+qed
	+
	+lemma poly_fun_pochhammer [simp]: "poly_fun f \<Longrightarrow> poly_fun (\<lambda>x. pochhammer (f x) k)"
	+ by (simp add: pochhammer_prod)
	+
	+lemma poly_fun_gbinomial [simp]: "poly_fun f \<Longrightarrow> poly_fun (\<lambda>x. f x gchoose k)"
	+ by (simp add: gbinomial_int_pochhammer' poly_fun_divide fact_dvd_pochhammer)
	+
	+end (* theory *)
	diff --git a/thys/Groebner_Macaulay/ROOT b/thys/Groebner_Macaulay/ROOT
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/ROOT
	@@ -0,0 +1,9 @@
	+chapter AFP
	+
	+session Groebner_Macaulay (AFP) = Groebner_Bases +
	+ options [timeout = 3600]
	+ theories
	+ Groebner_Macaulay_Examples
	+ document_files
	+ "root.tex"
	+ "root.bib"
	diff --git a/thys/Groebner_Macaulay/document/root.bib b/thys/Groebner_Macaulay/document/root.bib
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/document/root.bib
	@@ -0,0 +1,39 @@
	+@article{Dube1990,
	+ author = {Thomas W. Dub\'e},
	+ title = {{The Structure of Polynomial Ideals and Gr\" obner Bases}},
	+ journal = {SIAM Journal on Computing},
	+ volume = {19},
	+ number = {4},
	+ pages = {750--773},
	+ year = {1990},
	+ doi = {10.1137/0219053}
	+}
	+
	+@phdthesis{Wiesinger-Widi2015,
	+ author = {Manuela Wiesinger-Widi},
	+ title = {{Gr\"obner Bases and Generalized Sylvester Matrices}},
	+ year = {2015},
	+ school = {RISC, Johannes Kepler University Linz, Austria},
	+ url = {http://epub.jku.at/obvulihs/content/titleinfo/776913}
	+}
	+
	+@inproceedings{Maletzky2019,
	+author = {Alexander Maletzky},
	+title = {{Formalization of Dub\'e's Degree Bounds for Gr\"obner Bases in Isabelle/HOL}},
	+booktitle = {{Intelligent Computer Mathematics (Proceedings of CICM 2019, Prague, Czech Republic, July 8-12)}},
	+series = {Lecture Notes in Computer Science},
	+volume = {11617},
	+publisher = {Springer},
	+year = {2019},
	+editor = {Cezary Kaliszyk and Edwin Brady and Andrea Kohlhase and Claudio Sacerdoti-Coen},
	+note = {to appear; preprint at \url{http://www.risc.jku.at/publications/download/risc_5919/Paper.pdf}}
	+}
	+
	+@techreport{Maletzky2019b,
	+ author = {Alexander Maletzky},
	+ title = {{Gr\"obner Bases and Macaulay Matrices in Isabelle/HOL}},
	+ year = {2019},
	+ institution = {RISC, Johannes Kepler University Linz, Austria},
	+ length = {14},
	+ note = {\url{http://www.risc.jku.at/publications/download/risc_5929/Paper.pdf}; Submitted to Formal Aspects of Computing}
	+}
	diff --git a/thys/Groebner_Macaulay/document/root.tex b/thys/Groebner_Macaulay/document/root.tex
	new file mode 100755
	--- /dev/null
	+++ b/thys/Groebner_Macaulay/document/root.tex
	@@ -0,0 +1,80 @@
	+\documentclass[11pt,a4paper]{article}
	+\usepackage{isabelle,isabellesym,latexsym}
	+
	+% further packages required for unusual symbols (see also
	+% isabellesym.sty), use only when needed
	+
	+\usepackage{amssymb}
	+ %for \<leadsto>, \<box>, \<diamond>, \<sqsupset>, \<mho>, \<Join>,
	+ %\<lhd>, \<lesssim>, \<greatersim>, \<lessapprox>, \<greaterapprox>,
	+ %\<triangleq>, \<yen>, \<lozenge>
	+
	+%\usepackage{eurosym}
	+ %for \<euro>
	+
	+%\usepackage[only,bigsqcap]{stmaryrd}
	+ %for \<Sqinter>
	+
	+%\usepackage{eufrak}
	+ %for \<AA> ... \<ZZ>, \<aa> ... \<zz> (also included in amssymb)
	+
	+%\usepackage{textcomp}
	+ %for \<onequarter>, \<onehalf>, \<threequarters>, \<degree>, \<cent>,
	+ %\<currency>
	+
	+% this should be the last package used
	+\usepackage{pdfsetup}
	+
	+% urls in roman style, theory text in math-similar italics
	+\urlstyle{rm}
	+\isabellestyle{it}
	+
	+% for uniform font size
	+%\renewcommand{\isastyle}{\isastyleminor}
	+
	+
	+\begin{document}
	+
	+\title{Gr\"obner Bases, Macaulay Matrices\\and Dub\'e's Degree Bounds}
	+\author{Alexander Maletzky\thanks{Funded by the Austrian
	+Science Fund (FWF): grant no. P 29498-N31}}
	+\maketitle
	+
	+\begin{abstract}
	+This entry formalizes the connection between Gr\"obner bases and Macaulay matrices (sometimes also referred to as `generalized Sylvester matrices'). In particular, it contains a method for computing Gr\"obner bases, which proceeds by first constructing some Macaulay matrix of the initial set of polynomials, then row-reducing this matrix, and finally converting the result back into a set of polynomials. The output is shown to be a Gr\"obner basis if the Macaulay matrix constructed in the first step is sufficiently large. In order to obtain concrete upper bounds on the size of the matrix (and hence turn the method into an effectively executable algorithm), Dub\'e's degree bounds on Gr\"obner bases are utilized; consequently, they are also part of the formalization.
	+\end{abstract}
	+
	+\tableofcontents
	+
	+% sane default for proof documents
	+\parindent 0pt\parskip 0.5ex
	+
	+\newpage
	+\section{Introduction}
	+
	+The formalization consists of two main parts:
	+\begin{itemize}
	+ \item The connection between Gr\"obner bases and Macaulay matrices (or `generalized Sylvester matrices'), due to Wiesinger-Widi~\cite{Wiesinger-Widi2015}. In particular, this includes a method for computing Gr\"obner bases via Macaulay matrices.
	+
	+ \item Dub\'e's upper bounds on the degrees of Gr\"obner bases~\cite{Dube1990}. These bounds are not only of theoretical interest, but are also necessary to turn the above-mentioned method for computing Gr\"obner bases into an actual algorithm.
	+\end{itemize}
	+
	+For more information about this formalization, see the accompanying papers~\cite{Maletzky2019} (Dub\'e's bound) and~\cite{Maletzky2019b} (Macaulay matrices).
	+
	+\subsection{Future Work}
	+
	+This formalization could be extended by formalizing improved degree bounds for special input. For instance, Wiesinger-Widi in~\cite{Wiesinger-Widi2015} obtains much smaller bounds if the initial set of polynomials only consists of two binomials.
	+
	+% generated text of all theories
	+\input{session}
	+
	+% optional bibliography
	+\bibliographystyle{abbrv}
	+\bibliography{root}
	+
	+\end{document}
	+
	+%%% Local Variables:
	+%%% mode: latex
	+%%% TeX-master: t
	+%%% End:
	diff --git a/thys/IMP2_Binary_Heap/IMP2_Binary_Heap.thy b/thys/IMP2_Binary_Heap/IMP2_Binary_Heap.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/IMP2_Binary_Heap/IMP2_Binary_Heap.thy
	@@ -0,0 +1,903 @@
	+theory IMP2_Binary_Heap
	+ imports IMP2.IMP2 IMP2.IMP2_Aux_Lemmas
	+begin
	+section \<open>Introduction\<close>
	+text \<open>In this submission imperative versions of the following array-based binary minimum heap
	+ functions are implemented and verified: insert, get-min, delete-min, make-heap.
	+ The latter three are then used to prove the correctness of an in-place heapsort, which sorts
	+ an array in descending order. To do that in Isabelle/HOL, the proof framework IMP2
	+ \cite{IMP2-AFP} is used. Here arrays are modeled by \<open>int \<Rightarrow> int\<close> functions. The imperative
	+ implementations are iterative versions of the partly recursive algorithms described in
	+ \cite{MS} and \cite{CLRS}.
	+
	+ This submission starts with the basic definitions and lemmas, which are needed for array-based
	+ binary heaps. These definitions and lemmas are parameterised with an arbitrary (transitive)
	+ comparison function (where such a function is needed), so they are not only applicable to
	+ minimum heaps. After some more general, useful lemmas on arrays, the imperative minimum heap
	+ functions and the heapsort are implemented and verified.\<close>
	+
	+section \<open>Heap Related Definitions and Theorems\<close>
	+subsection \<open>Array Bounds\<close>
	+text \<open>A small helper function is used to define valid array indices. Note that the lower index
	+ bound \<open>l\<close> is arbitrary and not fixed to 0 or 1. The upper index bound \<open>r\<close> is not a valid
	+ index itself, so that the empty array can be denoted by having \<open>l = r\<close>.\<close>
	+abbreviation bounded :: "int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> bool" where
	+ "bounded l r x \<equiv> l \<le> x \<and> x < r"
	+
	+subsection \<open>Parent and Children\<close>
	+
	+subsubsection \<open>Definitions\<close>
	+text \<open>For the notion of an array-based binary heap, the parent and child relations on the array
	+ indices need to be defined.\<close>
	+definition parent :: "int \<Rightarrow> int \<Rightarrow> int" where
	+ "parent l c = l + (c - l - 1) div 2"
	+
	+definition l_child :: "int \<Rightarrow> int \<Rightarrow> int" where
	+ "l_child l p = 2 * p - l + 1"
	+
	+definition r_child :: "int \<Rightarrow> int \<Rightarrow> int" where
	+ "r_child l p = 2 * p - l + 2"
	+
	+subsubsection \<open>Lemmas\<close>
	+lemma parent_upper_bound: "parent l c < c \<longleftrightarrow> l \<le> c"
	+ unfolding parent_def by auto
	+
	+lemma parent_upper_bound_alt: "l \<le> parent l c \<Longrightarrow> parent l c < c"
	+ unfolding parent_def by simp
	+
	+lemma parent_lower_bound: "l \<le> parent l c \<longleftrightarrow> l < c"
	+ unfolding parent_def by linarith
	+
	+lemma grand_parent_upper_bound: "parent l (parent l c) < c \<longleftrightarrow> l \<le> c"
	+ unfolding parent_def by linarith
	+
	+corollary parent_bounds: "l < x \<Longrightarrow> x < r \<Longrightarrow> bounded l r (parent l x)"
	+ using parent_lower_bound parent_upper_bound_alt by fastforce
	+
	+
	+lemma l_child_lower_bound: " p < l_child l p \<longleftrightarrow> l \<le> p"
	+ unfolding l_child_def by simp
	+
	+corollary l_child_lower_bound_alt: "l \<le> x \<Longrightarrow> x \<le> p \<Longrightarrow> x < l_child l p"
	+ using l_child_lower_bound[of p l] by linarith
	+
	+lemma parent_l_child[simp]: "parent l (l_child l n) = n"
	+ unfolding parent_def l_child_def by simp
	+
	+
	+lemma r_child_lower_bound: "l \<le> p \<Longrightarrow> p < r_child l p"
	+ unfolding r_child_def by simp
	+
	+corollary r_child_lower_bound_alt: "l \<le> x \<Longrightarrow> x \<le> p \<Longrightarrow> x < r_child l p"
	+ using r_child_lower_bound[of l p] by linarith
	+
	+lemma parent_r_child[simp]: "parent l (r_child l n) = n"
	+ unfolding parent_def r_child_def by simp
	+
	+
	+lemma smaller_l_child: "l_child l x < r_child l x"
	+ unfolding l_child_def r_child_def by simp
	+
	+lemma parent_two_children:
	+ "(c = l_child l p \<or> c = r_child l p) \<longleftrightarrow> parent l c = p"
	+ unfolding parent_def l_child_def r_child_def by linarith
	+
	+subsection \<open>Heap Invariants\<close>
	+subsubsection \<open>Definitions\<close>
	+text \<open>The following heap invariants and the following lemmas are parameterised with an arbitrary
	+ (transitive) comparison function. For the concrete function implementations at the end of
	+ this submission \<open>\<le>\<close> on ints is used.\<close>
	+
	+text \<open>For the \<open>make_heap\<close> function, which transforms an unordered array into a valid heap,
	+ the notion of a partial heap is needed. Here the heap invariant only holds for array indices
	+ between a certain valid array index \<open>m\<close> and \<open>r\<close>. The standard heap invariant is then
	+ simply the special case where \<open>m = l\<close>.\<close>
	+definition is_partial_heap
	+ :: "('a::order \<Rightarrow> 'a::order \<Rightarrow> bool) \<Rightarrow> (int \<Rightarrow> 'a::order) \<Rightarrow> int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> bool" where
	+ "is_partial_heap cmp heap l m r = (\<forall> x. bounded m r x \<longrightarrow>
	+ bounded m r (parent l x) \<longrightarrow> cmp (heap (parent l x)) (heap x))"
	+
	+abbreviation is_heap
	+ :: "('a::order \<Rightarrow> 'a::order \<Rightarrow> bool) \<Rightarrow> (int \<Rightarrow> 'a::order) \<Rightarrow> int \<Rightarrow> int \<Rightarrow> bool" where
	+ "is_heap cmp heap l r \<equiv> is_partial_heap cmp heap l l r"
	+
	+
	+text \<open>During all of the modifying heap functions the heap invariant is temporarily violated at
	+ a single index \<open>i\<close> and it is then gradually restored by either \<open>sift_down\<close> or
	+ \<open>sift_up\<close>. The following definitions formalize these weakened invariants.
	+
	+ The second part of the conjunction in the following definitions states, that the comparison
	+ between the parent of \<open>i\<close> and each of the children of \<open>i\<close> evaluates to \<open>True\<close> without
	+ explicitly using the child relations.\<close>
	+definition is_partial_heap_except_down
	+ :: "('a::order \<Rightarrow> 'a::order \<Rightarrow> bool) \<Rightarrow> (int \<Rightarrow> 'a::order) \<Rightarrow> int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> bool" where
	+ "is_partial_heap_except_down cmp heap l m r i = (\<forall> x. bounded m r x \<longrightarrow>
	+ ((parent l x \<noteq> i \<longrightarrow> bounded m r (parent l x) \<longrightarrow> cmp (heap (parent l x)) (heap x)) \<and>
	+ (parent l x = i \<longrightarrow> bounded m r (parent l (parent l x))
	+ \<longrightarrow> cmp (heap (parent l (parent l x))) (heap x))))"
	+
	+abbreviation is_heap_except_down
	+ :: "('a::order \<Rightarrow> 'a::order \<Rightarrow> bool) \<Rightarrow> (int \<Rightarrow> 'a::order) \<Rightarrow> int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> bool" where
	+ "is_heap_except_down cmp heap l r i \<equiv> is_partial_heap_except_down cmp heap l l r i"
	+
	+
	+text \<open>As mentioned the notion of a partial heap is only needed for \<open>make_heap\<close>,
	+ which only uses \<open>sift_down\<close> internally, so there doesn't need to be an additional
	+ definition for the partial heap version of the \<open>sift_up\<close> invariant.\<close>
	+definition is_heap_except_up
	+ :: "('a::order \<Rightarrow> 'a::order \<Rightarrow> bool) \<Rightarrow> (int \<Rightarrow> 'a::order) \<Rightarrow> int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> bool" where
	+ "is_heap_except_up cmp heap l r i = (\<forall> x. bounded l r x \<longrightarrow>
	+ ((x \<noteq> i \<longrightarrow> bounded l r (parent l x) \<longrightarrow> cmp (heap (parent l x)) (heap x)) \<and>
	+ (parent l x = i \<longrightarrow> bounded l r (parent l (parent l x))
	+ \<longrightarrow> cmp (heap (parent l (parent l x))) (heap x))))"
	+
	+subsubsection \<open>Lemmas\<close>
	+
	+lemma empty_partial_heap[simp]: "is_partial_heap cmp heap l r r"
	+ unfolding is_partial_heap_def by linarith
	+
	+lemma is_partial_heap_smaller_back:
	+ "is_partial_heap cmp heap l m r \<Longrightarrow> r' \<le> r \<Longrightarrow> is_partial_heap cmp heap l m r'"
	+ unfolding is_partial_heap_def by simp
	+
	+lemma is_partial_heap_smaller_front:
	+ "is_partial_heap cmp heap l m r \<Longrightarrow> m \<le> m' \<Longrightarrow> is_partial_heap cmp heap l m' r"
	+ unfolding is_partial_heap_def by simp
	+
	+text \<open>The second half of each array is a is a partial binary heap, since it contains only leafs,
	+ which are all trivial binary heaps.\<close>
	+lemma snd_half_is_partial_heap:
	+ "(l + r) div 2 \<le> m \<Longrightarrow> is_partial_heap cmp heap l m r"
	+ unfolding is_partial_heap_def parent_def by linarith
	+
	+lemma modify_outside_partial_heap:
	+ assumes
	+ "heap = heap' on {m..<r}"
	+ "is_partial_heap cmp heap l m r"
	+ shows "is_partial_heap cmp heap' l m r"
	+ using assms eq_onD unfolding is_partial_heap_def by fastforce
	+
	+text \<open>The next few lemmas formalize how the heap invariant is weakened, when the heap is modified
	+ in a certain way.\<close>
	+
	+text \<open>This lemma is used by \<open>make_heap\<close>.\<close>
	+lemma partial_heap_added_first_el:
	+ assumes
	+ "l \<le> m" "m \<le> r"
	+ "is_partial_heap cmp heap l (m + 1) r"
	+ shows "is_partial_heap_except_down cmp heap l m r m"
	+ unfolding is_partial_heap_except_down_def
	+proof
	+ fix x
	+ let ?p_x = "parent l x"
	+ let ?gp_x = "parent l ?p_x"
	+ show "bounded m r x \<longrightarrow>
	+ (?p_x \<noteq> m \<longrightarrow> bounded m r ?p_x \<longrightarrow> cmp (heap ?p_x) (heap x)) \<and>
	+ (?p_x = m \<longrightarrow> bounded m r ?gp_x \<longrightarrow> cmp (heap ?gp_x) (heap x))"
	+ proof
	+ assume x_bound: "bounded m r x"
	+ have p_x_lower: "?p_x \<noteq> m \<longrightarrow> bounded m r ?p_x \<longrightarrow> ?p_x \<ge> m + 1"
	+ by simp
	+ hence "?p_x \<noteq> m \<longrightarrow> bounded m r ?p_x \<longrightarrow> x \<ge> m + 1"
	+ using parent_upper_bound[of l x] x_bound assms(1) by linarith
	+ hence p_invariant: "(?p_x \<noteq> m \<longrightarrow> bounded m r ?p_x \<longrightarrow> cmp (heap ?p_x) (heap x))"
	+ using assms(3) is_partial_heap_def p_x_lower x_bound by blast
	+
	+ have gp_up_bound: "(?p_x = m \<longrightarrow> ?gp_x < m)"
	+ by (simp add: assms(1) parent_upper_bound)
	+ show "(?p_x \<noteq> m \<longrightarrow> bounded m r ?p_x \<longrightarrow> cmp (heap ?p_x) (heap x)) \<and>
	+ (?p_x = m \<longrightarrow> bounded m r ?gp_x \<longrightarrow> cmp (heap ?gp_x) (heap x))"
	+ using gp_up_bound p_invariant by linarith
	+ qed
	+qed
	+
	+text \<open>This lemma is used by \<open>del_min\<close>.\<close>
	+lemma heap_changed_first_el:
	+ assumes "is_heap cmp heap l r" "l \<le> r"
	+ shows "is_heap_except_down cmp (heap(l := b)) l r l"
	+proof -
	+ have "is_partial_heap cmp heap l (l + 1) r"
	+ using assms(1) is_partial_heap_smaller_front by fastforce
	+ hence "is_partial_heap cmp (heap(l := b)) l (l + 1) r"
	+ using modify_outside_partial_heap[of heap] by simp
	+ thus ?thesis
	+ by (simp add: assms(2) partial_heap_added_first_el)
	+qed
	+
	+text \<open>This lemma is used by \<open>insert\<close>.\<close>
	+lemma heap_appended_el:
	+ assumes
	+ "is_heap cmp heap l r"
	+ "heap = heap' on {l..<r}"
	+ shows "is_heap_except_up cmp heap' l (r+1) r"
	+proof -
	+ have "is_heap cmp heap' l r"
	+ using assms(1,2) modify_outside_partial_heap by blast
	+ thus ?thesis unfolding is_partial_heap_def is_heap_except_up_def
	+ by (metis not_less_iff_gr_or_eq parent_upper_bound zless_add1_eq)
	+qed
	+
	+subsubsection \<open>First Heap Element\<close>
	+text \<open>The next step is to show that the first element of the heap is always the ``smallest''
	+ according to the given comparison function. For the proof a rule for strong induction on lower
	+ bounded integers is needed. Its proof is based on the proof of strong induction on natural
	+ numbers found in \cite{Str_Ind}.\<close>
	+lemma strong_int_gr_induct_helper:
	+ assumes "k < (i::int)" "(\<And>i. k < i \<Longrightarrow> (\<And>j. k < j \<Longrightarrow> j < i \<Longrightarrow> P j) \<Longrightarrow> P i)"
	+ shows "\<And>j. k < j \<Longrightarrow> j < i \<Longrightarrow> P j"
	+ using assms
	+proof(induction i rule: int_gr_induct)
	+ case base
	+ then show ?case by linarith
	+next
	+ case (step i)
	+ then show ?case
	+ proof(cases "j = i")
	+ case True
	+ then show ?thesis using step.IH step.prems(1,3) by blast
	+ next
	+ case False
	+ hence "j < i" using step.prems(2) by simp
	+ then show ?thesis using step.IH step.prems(1,3) by blast
	+ qed
	+qed
	+
	+theorem strong_int_gr_induct:
	+ assumes
	+ "k < (i::int)"
	+ "(\<And>i. k < i \<Longrightarrow> (\<And>j. k < j \<Longrightarrow> j < i \<Longrightarrow> P j) \<Longrightarrow> P i)"
	+ shows "P i"
	+ using assms less_induct strong_int_gr_induct_helper by blast
	+
	+text \<open>Now the main theorem, that the first heap element is the ``smallest'' according to the
	+ given comparison function, can be proven.\<close>
	+theorem heap_first_el:
	+ assumes
	+ "is_heap cmp heap l r"
	+ "transp cmp"
	+ "l < x" "x < r"
	+ shows "cmp (heap l) (heap x)"
	+ using assms unfolding is_partial_heap_def
	+proof(induction x rule: strong_int_gr_induct[of l])
	+ case 1
	+ then show ?case using assms(3) by simp
	+next
	+ case (2 i)
	+ have cmp_pi_i: "cmp (heap (parent l i)) (heap i)"
	+ using "2.hyps" "2.prems"(1,4) parent_bounds by simp
	+ then show ?case
	+ proof(cases)
	+ assume "parent l i > l"
	+ then have "cmp (heap l) (heap (parent l i))"
	+ using "2.IH" "2.prems"(1,2,4) parent_upper_bound_alt by simp
	+ then show ?thesis
	+ using "2.prems"(2) cmp_pi_i transpE by metis
	+ next
	+ assume "\<not> parent l i > l"
	+ then have "parent l i = l"
	+ using "2.hyps" dual_order.order_iff_strict parent_lower_bound by metis
	+ then show ?thesis
	+ using cmp_pi_i by simp
	+ qed
	+qed
	+
	+
	+
	+section \<open>General Lemmas on Arrays\<close>
	+text \<open>Some additional lemmas on @{const "mset_ran"}, @{const "swap"} and @{const "eq_on"} are needed
	+ for the final proofs.\<close>
	+
	+subsection \<open>Lemmas on @{const "mset_ran"}\<close>
	+abbreviation arr_mset :: "(int \<Rightarrow> 'a) \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a multiset" where
	+ "arr_mset arr l r \<equiv> mset_ran arr {l..<r}"
	+
	+lemma in_mset_imp_in_array:
	+ "x \<in># (arr_mset arr l r) \<longleftrightarrow> (\<exists>i. bounded l r i \<and> arr i = x)"
	+ unfolding mset_ran_def by fastforce
	+
	+lemma arr_mset_remove_last:
	+ "l \<le> r \<Longrightarrow> arr_mset arr l r = arr_mset arr l (r + 1) - {#arr r#}"
	+ by (simp add: intvs_upper_decr mset_ran_def)
	+
	+lemma arr_mset_append:
	+ "l \<le> r \<Longrightarrow> arr_mset arr l (r + 1) = arr_mset arr l r + {#arr r#}"
	+ using arr_mset_remove_last[of l r arr] by simp
	+
	+corollary arr_mset_append_alt:
	+ "l \<le> r \<Longrightarrow> arr_mset (arr(r := b)) l (r + 1) = arr_mset arr l r + {#b#}"
	+ by (simp add: arr_mset_append mset_ran_subst_outside)
	+
	+lemma arr_mset_remove_first:
	+ "i \<le> r \<Longrightarrow> arr_mset arr (i - 1) r = arr_mset arr i r + {#arr (i - 1)#}"
	+ by(induction r rule: int_ge_induct) (auto simp add: arr_mset_append)
	+
	+lemma arr_mset_split:
	+ assumes "l \<le> m" "m \<le> r"
	+ shows "arr_mset arr l r = arr_mset arr l m + arr_mset arr m r"
	+ using assms
	+proof(induction m rule: int_ge_induct[of l])
	+ case (step i)
	+ have add_last: "arr_mset arr l (i + 1) = arr_mset arr l i + {#arr i#}"
	+ using step arr_mset_append by blast
	+ have rem_first: "arr_mset arr (i+1) r = arr_mset arr i r - {#arr i#}"
	+ by (metis step.prems arr_mset_remove_first add_diff_cancel_right')
	+ show ?case
	+ using step add_last rem_first by fastforce
	+qed (simp)
	+
	+text \<open>That the first element in a heap is the ``smallest'', can now be expressed using multisets.\<close>
	+corollary heap_first_el_alt:
	+ assumes
	+ "transp cmp"
	+ "is_heap cmp heap l r"
	+ "x \<in># (arr_mset heap l r)"
	+ "heap l \<noteq> x"
	+ shows "cmp (heap l) x"
	+ by(metis assms heap_first_el in_mset_imp_in_array le_less)
	+
	+
	+subsection \<open>Lemmas on @{term "swap"} and @{term "eq_on"}\<close>
	+
	+lemma eq_on_subset:
	+ "arr1 = arr2 on R \<Longrightarrow> S \<subseteq> R \<Longrightarrow> arr1 = arr2 on S"
	+ by (simp add: eq_on_def set_mp)
	+
	+lemma swap_swaps:
	+ "arr' = swap arr x y \<Longrightarrow> arr' y = arr x \<and> arr' x = arr y"
	+ unfolding swap_def by simp
	+
	+lemma swap_only_swaps:
	+ "arr' = swap arr x y \<Longrightarrow> z \<noteq> x \<Longrightarrow> z \<noteq> y \<Longrightarrow> arr' z = arr z"
	+ unfolding swap_def by simp
	+
	+lemma swap_commute: "swap arr x y = swap arr y x"
	+ unfolding swap_def by fastforce
	+
	+lemma swap_eq_on:
	+ "arr1 = arr2 on S \<Longrightarrow> x \<notin> S \<Longrightarrow> y \<notin> S \<Longrightarrow> arr1 = swap arr2 x y on S"
	+ unfolding swap_def by simp
	+
	+corollary swap_parent_eq_on:
	+ assumes
	+ "arr1 = arr2 on - {l..<r}"
	+ "l < c" "c < r"
	+ shows "arr1 = swap arr2 (parent l c) c on - {l..<r} "
	+ using parent_bounds swap_eq_on assms by fastforce
	+
	+corollary swap_child_eq_on:
	+ assumes
	+ "arr1 = arr2 on - {l..<r}"
	+ "c = l_child l p \<or> c = r_child l p"
	+ "l \<le> p" "c < r"
	+ shows "arr1 = swap arr2 p c on - {l..<r} "
	+ by (metis assms parent_lower_bound parent_two_children swap_parent_eq_on)
	+
	+lemma swap_child_mset:
	+ assumes
	+ "arr_mset arr1 l r = arr_mset arr2 l r"
	+ "c = l_child l p \<or> c = r_child l p"
	+ "l \<le> p" "c < r"
	+ shows "arr_mset arr1 l r = arr_mset (swap arr2 p c) l r"
	+proof -
	+ have child_bounded: "l < c \<and> c < r"
	+ by (metis assms(2-4) parent_lower_bound parent_two_children)
	+ have parent_bounded: "bounded l r p"
	+ by (metis assms(2-4) dual_order.strict_trans parent_two_children parent_upper_bound_alt)
	+ thus ?thesis
	+ using assms(1) child_bounded mset_ran_swap[of p "{l..<r}" c arr2] atLeastLessThan_iff
	+ by simp
	+qed
	+
	+text \<open>The following lemma shows, which propositions have to hold on the pre-swap array, so that
	+ a comparison between two elements holds on the post-swap array. This is useful for the
	+ proofs of the loop invariants of \<open>sift_up\<close> and \<open>sift_down\<close>. The lemma is kept
	+ quite general (except for the argument order) and could probably be more closely
	+ related to the parent relation for more concise proofs.\<close>
	+lemma cmp_swapI:
	+ fixes arr::"'a::order \<Rightarrow> 'a::order"
	+ assumes
	+ "m < n \<and> x < y"
	+ "m < n \<and> x < y \<Longrightarrow> x = m \<Longrightarrow> y = n \<Longrightarrow> P (arr n) (arr m)"
	+ "m < n \<and> x < y \<Longrightarrow> x \<noteq> m \<Longrightarrow> x \<noteq> n \<Longrightarrow> y \<noteq> m \<Longrightarrow> y \<noteq> n \<Longrightarrow> P (arr m) (arr n)"
	+ "m < n \<and> x < y \<Longrightarrow> x = m \<Longrightarrow> y \<noteq> m \<Longrightarrow> y \<noteq> n \<Longrightarrow> P (arr y) (arr n)"
	+ "m < n \<and> x < y \<Longrightarrow> x = n \<Longrightarrow> y \<noteq> m \<Longrightarrow> y \<noteq> n \<Longrightarrow> P (arr m) (arr y)"
	+ "m < n \<and> x < y \<Longrightarrow> x \<noteq> m \<Longrightarrow> x \<noteq> n \<Longrightarrow> y = n \<Longrightarrow> P (arr m) (arr x)"
	+ "m < n \<and> x < y \<Longrightarrow> x \<noteq> m \<Longrightarrow> x \<noteq> n \<Longrightarrow> y = m \<Longrightarrow> P (arr x) (arr n)"
	+ shows "P (swap arr x y m) (swap arr x y n)"
	+ by (metis assms order.asym swap_only_swaps swap_swaps)
	+
	+section \<open>Imperative Heap Implementation\<close>
	+text \<open>The following imperative heap functions are based on \cite{MS} and \cite{CLRS}. All functions,
	+ that are recursive in these books, are iterative in the following implementations. The
	+ function definitions are done with IMP2 \cite{IMP2-AFP}. From now on the heaps only contain
	+ ints and only use \<open>\<le>\<close> as comparison function. The auxiliary lemmas used from now on are
	+ heavily modeled after the proof goals, that are generated by the vcg tool (also part of IMP2).\<close>
	+
	+subsection \<open>Simple Functions\<close>
	+subsubsection \<open>Parent, Children and Swap\<close>
	+text \<open>In this section the parent and children relations are expressed as IMP2 procedures.
	+ Additionally a simple procedure, that swaps two array elements, is defined.\<close>
	+procedure_spec prnt (l, x) returns p
	+ assumes True
	+ ensures "p = parent l\<^sub>0 x\<^sub>0"
	+ defines \<open>p = ((x - l - 1) / 2 + l)\<close>
	+ by vcg (simp add: parent_def)
	+
	+procedure_spec left_child (l, x) returns lc
	+ assumes True
	+ ensures "lc = l_child l\<^sub>0 x\<^sub>0"
	+ defines \<open>lc = 2 * x - l + 1\<close>
	+ by vcg (simp add: l_child_def)
	+
	+procedure_spec right_child (l, x) returns rc
	+ assumes True
	+ ensures "rc = r_child l\<^sub>0 x\<^sub>0"
	+ defines \<open>rc = 2 * x - l + 2\<close>
	+ by vcg (simp add: r_child_def)
	+
	+procedure_spec swp (heap, x, y) returns heap
	+ assumes True
	+ ensures "heap = swap heap\<^sub>0 x\<^sub>0 y\<^sub>0 "
	+ defines \<open>tmp = heap[x]; heap[x] = heap[y]; heap[y] = tmp\<close>
	+ by vcg (simp add: swap_def)
	+
	+subsubsection \<open>\<open>get_min\<close>\<close>
	+text \<open>In this section \<open>get_min\<close> is defined, which simply returns the first element (the minimum) of
	+ the heap. For this definition an additional theorem is proven, which enables the use of
	+ @{const "Min_mset"} in the postcondition.\<close>
	+
	+theorem heap_minimum:
	+ assumes
	+ "l < r"
	+ "is_heap (\<le>) heap l r"
	+ shows "heap l = Min_mset (arr_mset heap l r)"
	+proof -
	+ have "(\<forall>x \<in># (arr_mset heap l r). (heap l) \<le> x)"
	+ using assms(2) heap_first_el_alt transp_le by blast
	+ thus ?thesis
	+ by (simp add: assms(1) dual_order.antisym)
	+qed
	+
	+procedure_spec get_min (heap, l, r) returns min
	+ assumes "l < r \<and> is_heap (\<le>) heap l r"
	+ ensures "min = Min_mset (arr_mset heap\<^sub>0 l\<^sub>0 r\<^sub>0)"
	+ for heap[] l r
	+ defines \<open>min = heap[l]\<close>
	+ by vcg (simp add: heap_minimum)
	+
	+subsection \<open>Modifying Functions\<close>
	+
	+subsubsection \<open>\<open>sift_up\<close> and \<open>insert\<close>\<close>
	+text \<open>The next heap function is \<open>insert\<close>, which internally uses \<open>sift_up\<close>. In the beginning of
	+ this section \<open>sift_up_step\<close> is proven, which states that each \<open>sift_up\<close> loop iteration
	+ correctly transforms the weakened heap invariant. For its proof two additional
	+ auxiliary lemmas are used. After \<open>sift_up_step\<close> \<open>sift_up\<close> and then \<open>insert\<close> are verified.\<close>
	+
	+text \<open>\<open>sift_up_step\<close> can be proven directly by the smt-solver without auxiliary lemmas, but they
	+ were introduced to show the proof details. The analogous proofs for \<open>sift_down\<close> were
	+ just solved with smt, since the proof structure should be very similar, even though the
	+ \<open>sift_down\<close> proof goals are slightly more complex.\<close>
	+lemma sift_up_step_aux1:
	+ fixes heap::"int \<Rightarrow> int"
	+ assumes
	+ "is_heap_except_up (\<le>) heap l r x"
	+ "parent l x \<ge> l"
	+ "(heap x) \<le> (heap (parent l x))"
	+ "bounded l r k"
	+ "k \<noteq> (parent l x)"
	+ "bounded l r (parent l k)"
	+ shows "(swap heap (parent l x) x (parent l k)) \<le> (swap heap (parent l x) x k)"
	+ apply(intro cmp_swapI[of "(parent l k)" k "(parent l x)" x "(\<le>)" heap])
	+ subgoal using assms(2,6) parent_upper_bound_alt by blast
	+ subgoal using assms(3) by blast
	+ subgoal using assms(1,4,6) unfolding is_heap_except_up_def by blast
	+ subgoal using assms(1,3,4,6) unfolding is_heap_except_up_def by fastforce
	+ subgoal using assms(5) by blast
	+ subgoal by blast
	+ subgoal using assms(1,2,4) unfolding is_heap_except_up_def by simp
	+ done
	+
	+lemma sift_up_step_aux2:
	+ fixes heap::"int \<Rightarrow> int"
	+ assumes
	+ "is_heap_except_up (\<le>) heap l r x"
	+ "parent l x \<ge> l"
	+ "heap x \<le> (heap (parent l x))"
	+ "bounded l r k"
	+ "parent l k = parent l x"
	+ "bounded l r (parent l (parent l k))"
	+ shows
	+ "swap heap (parent l x) x (parent l (parent l k)) \<le> swap heap (parent l x) x k"
	+ using assms unfolding is_heap_except_up_def
	+proof-
	+ let ?gp_k = "parent l (parent l k)"
	+ let ?gp_x = "parent l (parent l x)"
	+ have gp_k_eq_gp_x: "swap heap (parent l x) x ?gp_k = heap ?gp_x"
	+ by (metis assms(2,5) grand_parent_upper_bound less_irrefl swap_only_swaps)
	+ show ?thesis
	+ using assms unfolding is_heap_except_up_def
	+ proof(cases)
	+ assume k_eq_x: "k = x"
	+ have "swap heap (parent l x) x k = heap (parent l x)"
	+ by (metis k_eq_x swap_swaps)
	+ then show ?thesis
	+ using assms(1,2,4,6) unfolding is_heap_except_up_def
	+ by (metis gp_k_eq_gp_x k_eq_x parent_bounds parent_lower_bound)
	+ next
	+ assume k_neq_x: "k \<noteq> x"
	+ have "swap heap (parent l x) x k = heap k"
	+ by (metis assms(5) gp_k_eq_gp_x k_neq_x swap_only_swaps)
	+ then show ?thesis using assms unfolding is_heap_except_up_def
	+ by (metis gp_k_eq_gp_x k_neq_x order_trans parent_bounds parent_lower_bound)
	+ qed
	+qed
	+
	+lemma sift_up_step:
	+ fixes heap::"int \<Rightarrow> int"
	+ assumes
	+ "is_heap_except_up (\<le>) heap l r x"
	+ "parent l x \<ge> l"
	+ "(heap x) \<le> (heap (parent l x))"
	+ shows "is_heap_except_up (\<le>) (swap heap (parent l x) x) l r (parent l x)"
	+ using assms sift_up_step_aux1 sift_up_step_aux2
	+ unfolding is_heap_except_up_def by blast
	+
	+text \<open>\<open>sift_up\<close> restores the heap invariant, that is only violated at the current position, by
	+ iteratively swapping the current element with its parent until the beginning of the array is
	+ reached or the current element is bigger than its parent.\<close>
	+procedure_spec sift_up (heap, l, r, x) returns heap
	+ assumes "is_heap_except_up (\<le>) heap l r x \<and> bounded l r x"
	+ ensures "is_heap (\<le>) heap l\<^sub>0 r\<^sub>0 \<and>
	+ arr_mset heap\<^sub>0 l\<^sub>0 r\<^sub>0 = arr_mset heap l\<^sub>0 r\<^sub>0 \<and>
	+ heap\<^sub>0 = heap on - {l\<^sub>0..<r\<^sub>0}"
	+ for heap[] l x r
	+ defines \<open>
	+ p = prnt(l, x);
	+ while (x > l \<and> heap[x] \<le> heap[p])
	+ @variant \<open>x - l\<close>
	+ @invariant \<open>is_heap_except_up (\<le>) heap l r x \<and> p = parent l x \<and>
	+ bounded l r x \<and> arr_mset heap\<^sub>0 l\<^sub>0 r\<^sub>0 = arr_mset heap l r \<and>
	+ heap\<^sub>0 = heap on - {l..<r}\<close>
	+ {
	+ heap = swp(heap, p, x);
	+ x = p;
	+ p = prnt(l, x)
	+ }\<close>
	+ apply vcg_cs
	+ apply(intro conjI)
	+ subgoal using parent_lower_bound sift_up_step by blast
	+ subgoal using parent_lower_bound by blast
	+ subgoal using parent_bounds by blast
	+ subgoal using parent_bounds by (simp add: mset_ran_swap)
	+ subgoal using swap_parent_eq_on by blast
	+ subgoal using parent_upper_bound by simp
	+ subgoal unfolding is_heap_except_up_def is_partial_heap_def
	+ by (metis le_less not_less parent_lower_bound)
	+ done
	+
	+text \<open>\<open>insert\<close> inserts an element into a heap by appending it to the heap and restoring the heap
	+ invariant with @{const "sift_up"}.\<close>
	+procedure_spec insert (heap, l, r, el) returns (heap, l, r)
	+ assumes "is_heap (\<le>) heap l r \<and> l \<le> r"
	+ ensures "is_heap (\<le>) heap l r \<and>
	+ arr_mset heap l r = arr_mset heap\<^sub>0 l\<^sub>0 r\<^sub>0 + {#el\<^sub>0#} \<and>
	+ l = l\<^sub>0 \<and> r = r\<^sub>0 + 1 \<and> heap\<^sub>0 = heap on - {l..<r}"
	+ for heap l r el
	+ defines \<open>
	+ heap[r] = el;
	+ x = r;
	+ r = r + 1;
	+ heap = sift_up(heap, l, r, x)
	+ \<close>
	+ apply vcg_cs
	+ subgoal by (simp add: heap_appended_el)
	+ subgoal by (metis arr_mset_append_alt add_mset_add_single)
	+ done
	+
	+subsubsection \<open>\<open>sift_down\<close>, \<open>del_min\<close> and \<open>make_heap\<close>\<close>
	+text \<open>The next heap functions are \<open>del_min\<close> and \<open>make_heap\<close>, which both use \<open>sift_down\<close> to
	+ restore/establish the heap invariant. \<open>sift_down\<close> is proven first (this time without
	+ additional auxiliary lemmas) followed by \<open>del_min\<close> and \<open>make_heap\<close>.\<close>
	+
	+text \<open>\<open>sift_down\<close> restores the heap invariant, that is only violated at the current position, by
	+ iteratively swapping the current element with its smallest child until the end of
	+ the array is reached or the current element is smaller than its children.\<close>
	+procedure_spec sift_down(heap, l, r, x) returns heap
	+ assumes "is_partial_heap_except_down (\<le>) heap l x r x \<and> l \<le> x \<and> x \<le> r"
	+ ensures "is_partial_heap (\<le>) heap l\<^sub>0 x\<^sub>0 r\<^sub>0 \<and>
	+ arr_mset heap\<^sub>0 l\<^sub>0 r\<^sub>0 = arr_mset heap l\<^sub>0 r\<^sub>0 \<and>
	+ heap\<^sub>0 = heap on - {l\<^sub>0..<r\<^sub>0}"
	+ defines \<open>
	+ lc = left_child(l, x);
	+ rc = right_child(l, x);
	+ while (lc < r \<and> (heap[lc] < heap[x] \<or> (rc < r \<and> heap[rc] < heap[x])))
	+ @variant \<open>r - x\<close>
	+ @invariant \<open>is_partial_heap_except_down (\<le>) heap l x\<^sub>0 r x \<and>
	+ x\<^sub>0 \<le> x \<and> x \<le> r \<and> lc = l_child l x \<and> rc = r_child l x \<and>
	+ arr_mset heap\<^sub>0 l r = arr_mset heap l r \<and>
	+ heap\<^sub>0 = heap on - {l..<r}\<close>
	+ {
	+ smallest = lc;
	+ if (rc < r \<and> heap[rc] < heap[lc]) {
	+ smallest = rc
	+ };
	+ heap = swp(heap, x, smallest);
	+ x = smallest;
	+ lc = left_child(l, x);
	+ rc = right_child(l, x)
	+ }\<close>
	+ apply vcg_cs
	+ subgoal
	+ apply(intro conjI)
	+ subgoal unfolding is_partial_heap_except_down_def
	+ by (smt parent_two_children swap_swaps swap_only_swaps
	+ swap_commute parent_upper_bound_alt)
	+ subgoal using r_child_lower_bound_alt by fastforce
	+ subgoal using swap_child_mset order_trans by blast
	+ subgoal using swap_child_eq_on by fastforce
	+ done
	+ subgoal
	+ by (meson less_le_trans not_le order.asym r_child_lower_bound)
	+ subgoal
	+ apply(intro conjI)
	+ subgoal unfolding is_partial_heap_except_down_def
	+ by (smt parent_two_children swap_swaps swap_only_swaps
	+ swap_commute parent_upper_bound_alt)
	+ subgoal using l_child_lower_bound_alt by fastforce
	+ subgoal using swap_child_mset order_trans by blast
	+ subgoal using swap_child_eq_on by fastforce
	+ done
	+ subgoal
	+ by (meson less_le_trans not_le order.asym l_child_lower_bound)
	+ subgoal unfolding is_partial_heap_except_down_def is_partial_heap_def
	+ by (metis dual_order.strict_trans not_less parent_two_children smaller_l_child)
	+ done
	+
	+
	+text \<open>\<open>del_min\<close> needs an additional lemma which shows, that it actually removes (only) the minimum
	+ from the heap.\<close>
	+lemma del_min_mset:
	+ fixes heap::"int \<Rightarrow> int"
	+ assumes
	+ "l < r"
	+ "is_heap (\<le>) heap l r"
	+ "mod_heap = heap(l := heap (r - 1))"
	+ "arr_mset mod_heap l (r - 1) = arr_mset new_heap l (r - 1)"
	+ shows
	+ "arr_mset new_heap l (r - 1) = arr_mset heap l r - {#Min_mset (arr_mset heap l r)#}"
	+proof -
	+ let ?heap_mset = "arr_mset heap l r"
	+ have l_is_min: "heap l = Min_mset ?heap_mset"
	+ using assms(1,2) heap_minimum by blast
	+ have "(arr_mset mod_heap l r) = ?heap_mset + {#heap (r-1)#} - {#heap l#}"
	+ by (simp add: assms(1,3) mset_ran_subst_inside)
	+ hence "(arr_mset mod_heap l (r - 1)) = ?heap_mset - {#heap l#}"
	+ by (simp add: assms(1,3) arr_mset_remove_last)
	+ thus ?thesis
	+ using assms(4) l_is_min by simp
	+qed
	+
	+text \<open>\<open>del_min\<close> removes the minimum element from the heap by replacing the first element with the
	+ last element, shrinking the array by one and subsequently restoring the heap invariant
	+ with @{const "sift_down"}.\<close>
	+procedure_spec del_min (heap, l, r) returns (heap, l, r)
	+ assumes "l < r \<and> is_heap (\<le>) heap l r"
	+ ensures "is_heap (\<le>) heap l r \<and>
	+ arr_mset heap l r = arr_mset heap\<^sub>0 l\<^sub>0 r\<^sub>0 - {#Min_mset (arr_mset heap\<^sub>0 l\<^sub>0 r\<^sub>0)#} \<and>
	+ l = l\<^sub>0 \<and> r = r\<^sub>0 - 1 \<and>
	+ heap\<^sub>0 = heap on - {l\<^sub>0..<r\<^sub>0}"
	+ for heap l r
	+ defines \<open>
	+ r = r - 1;
	+ heap[l] = heap[r];
	+ heap = sift_down(heap, l, r, l)
	+ \<close>
	+ apply vcg_cs
	+ subgoal by (simp add: heap_changed_first_el is_partial_heap_smaller_back)
	+ subgoal
	+ apply(rule conjI)
	+ subgoal using del_min_mset by blast
	+ subgoal by (simp add: eq_on_def intvs_incdec(3) intvs_lower_incr)
	+ done
	+ done
	+
	+
	+text \<open>\<open>make_heap\<close> transforms an arbitrary array into a heap by iterating through all array
	+ positions from the middle of the array up to the beginning of the array and calling
	+ @{const "sift_down"} for each one.\<close>
	+procedure_spec make_heap (heap, l, r) returns heap
	+ assumes "l \<le> r"
	+ ensures "is_heap (\<le>) heap l\<^sub>0 r\<^sub>0 \<and>
	+ arr_mset heap l\<^sub>0 r\<^sub>0 = arr_mset heap\<^sub>0 l\<^sub>0 r\<^sub>0 \<and>
	+ heap\<^sub>0 = heap on - {l\<^sub>0..< r\<^sub>0}"
	+ for heap[] l r
	+ defines \<open>
	+ y = (r + l)/2 - 1;
	+ while (y \<ge> l)
	+ @variant \<open>y - l + 1\<close>
	+ @invariant \<open>is_partial_heap (\<le>) heap l (y + 1) r \<and>
	+ arr_mset heap l r = arr_mset heap\<^sub>0 l\<^sub>0 r\<^sub>0 \<and>
	+ l - 1 \<le> y \<and> y < r \<and> heap\<^sub>0 = heap on - {l..<r}\<close>
	+ {
	+ heap = sift_down(heap, l, r, y);
	+ y = y - 1
	+ }\<close>
	+ apply(vcg_cs)
	+ subgoal
	+ apply(rule conjI)
	+ subgoal by (simp add: snd_half_is_partial_heap add.commute)
	+ subgoal by linarith
	+ done
	+ subgoal using partial_heap_added_first_el le_less by blast
	+ subgoal using eq_on_trans by blast
	+ subgoal using dual_order.antisym by fastforce
	+ done
	+
	+subsection \<open>Heapsort Implementation\<close>
	+
	+text \<open>The final part of this submission is the implementation of the in-place heapsort. Firstly it
	+ builds the \<open>\<le>\<close>-heap and then it iteratively removes the minimum of the heap, which is put at
	+ the now vacant end of the shrinking heap. This is done until the heap is empty, which leaves
	+ the array sorted in descending order.\<close>
	+subsubsection \<open>Auxiliary Lemmas\<close>
	+text \<open>Firstly the notion of a sorted array is needed. This is more or less the same as
	+ @{const "ran_sorted"} generalized for arbitrary comparison functions.\<close>
	+definition array_is_sorted :: "(int \<Rightarrow> int \<Rightarrow> bool) \<Rightarrow> (int \<Rightarrow> int) \<Rightarrow> int \<Rightarrow> int \<Rightarrow> bool" where
	+ "array_is_sorted cmp a l r \<equiv> \<forall>i. \<forall>j. bounded l r i \<longrightarrow> bounded l r j \<longrightarrow> i < j \<longrightarrow> cmp (a i) (a j)"
	+
	+text \<open>This lemma states, that the heapsort doesn't change the elements contained in the array during
	+ the loop iterations.\<close>
	+lemma heap_sort_mset_step:
	+ fixes arr::"int \<Rightarrow> int"
	+ assumes
	+ "l < m" "m \<le> r"
	+ "arr_mset arr' l (m - 1) = arr_mset arr l m - {#Min_mset (arr_mset arr l m)#}"
	+ "arr = arr' on - {l..<m}"
	+ "mod_arr = arr'(m - 1 := Min_mset (arr_mset arr l m))"
	+ shows "arr_mset arr l r = arr_mset mod_arr l r"
	+proof -
	+ let ?min = "{#Min_mset (arr_mset arr l m)#}"
	+ let ?new_arr_mset = "arr_mset mod_arr"
	+ have middle: "?new_arr_mset (m - 1) m = ?min"
	+ by (simp add: assms(5))
	+ have first_half: "?new_arr_mset l (m - 1) = arr_mset arr l m - ?min"
	+ by (simp add: assms(3,5) mset_ran_subst_outside)
	+ hence "?new_arr_mset l m = ?new_arr_mset l (m - 1) + ?new_arr_mset (m - 1) m"
	+ by (metis assms(1,3,5) diff_add_cancel middle arr_mset_append_alt zle_diff1_eq)
	+ hence first_half_middle: "?new_arr_mset l m = arr_mset arr l m"
	+ using middle first_half assms(1) by simp
	+
	+ hence "mod_arr = arr on - {l..<m}"
	+ using assms(1,4,5) eq_on_sym eq_on_trans by auto
	+ then have second_half: "arr_mset arr m r = arr_mset mod_arr m r"
	+ by (simp add: eq_on_def mset_ran_cong)
	+
	+ then show ?thesis
	+ by (metis arr_mset_split assms(1,2) first_half_middle le_less)
	+qed
	+
	+text \<open>This lemma states, that each loop iteration leaves the growing second half of the array
	+ sorted in descending order.\<close>
	+lemma heap_sort_second_half_sorted_step:
	+ fixes arr::"int \<Rightarrow> int"
	+ assumes
	+ "l\<^sub>0 < m" "m \<le> r\<^sub>0"
	+ "arr = arr' on - {l\<^sub>0..<m}"
	+ "\<forall>i. \<forall>j. bounded m r\<^sub>0 i \<longrightarrow> bounded m r\<^sub>0 j \<longrightarrow> i < j \<longrightarrow> arr j \<le> arr i"
	+ "\<forall>x\<in>#arr_mset arr l\<^sub>0 m. \<forall>y\<in>#arr_mset arr m r\<^sub>0. \<not> x < y"
	+ "bounded (m - 1) r\<^sub>0 i"
	+ "bounded (m - 1) r\<^sub>0 j"
	+ "i < j"
	+ "mod_arr = (arr'(m - 1 := Min_mset (arr_mset arr l\<^sub>0 m)))"
	+ shows "mod_arr j \<le> mod_arr i"
	+proof -
	+ have second_half_eq: "mod_arr = arr on {m..< r\<^sub>0}"
	+ using assms(3, 9) unfolding eq_on_def by simp
	+ have j_stricter_bound: "bounded m r\<^sub>0 j"
	+ using assms(6-8) by simp
	+ then have el_at_j: "mod_arr j \<in># arr_mset arr m r\<^sub>0"
	+ using eq_onD second_half_eq by fastforce
	+ then show ?thesis
	+ proof(cases)
	+ assume "i = (m-1)"
	+ then have "mod_arr i \<in># arr_mset arr l\<^sub>0 m"
	+ by (simp add: assms(1, 9))
	+ then show ?thesis
	+ using assms(5) el_at_j not_less by blast
	+ next
	+ assume "i \<noteq> (m-1)"
	+ then have "bounded m r\<^sub>0 i"
	+ using assms(6) by simp
	+ then show ?thesis
	+ using assms(4, 8) eq_on_def j_stricter_bound second_half_eq by force
	+ qed
	+qed
	+
	+
	+text \<open>The following lemma shows that all elements in the first part of the array (the binary heap)
	+ are bigger than the elements in the second part (the sorted part) after every iteration. This
	+ lemma and the invariant of the \<open>heap_sort\<close> loop use \<open>\<not> x < y\<close> instead of \<open>x \<ge> y\<close> since
	+ \<open>vcg_cs\<close> doesn't terminate in the latter case.\<close>
	+lemma heap_sort_fst_part_bigger_snd_part_step:
	+ fixes arr::"int \<Rightarrow> int"
	+ assumes
	+ "l\<^sub>0 < m"
	+ "m \<le> r\<^sub>0"
	+ "arr_mset arr' l\<^sub>0 (m - 1) = arr_mset arr l\<^sub>0 m - {#Min_mset (arr_mset arr l\<^sub>0 m)#}"
	+ "arr = arr' on - {l\<^sub>0..<m}"
	+ "\<forall>x\<in>#arr_mset arr l\<^sub>0 m. \<forall>y\<in>#arr_mset arr m r\<^sub>0. \<not> x < y"
	+ "mod_arr = arr'(m - 1 := Min_mset (arr_mset arr l\<^sub>0 m))"
	+ "x\<in>#arr_mset mod_arr l\<^sub>0 (m - 1)"
	+ "y\<in>#arr_mset mod_arr (m - 1) r\<^sub>0"
	+ shows "\<not> x < y"
	+proof -
	+ have "{m..<r\<^sub>0} \<subseteq> - {l\<^sub>0..<m}"
	+ by auto
	+ hence "arr' = arr on {m..<r\<^sub>0}"
	+ using assms(4) eq_on_sym eq_on_subset by blast
	+ hence arr_eq_on: "mod_arr = arr on {m..<r\<^sub>0}"
	+ by (simp add: assms(6))
	+ hence same_mset: "arr_mset mod_arr m r\<^sub>0 = arr_mset arr m r\<^sub>0"
	+ using mset_ran_cong by blast
	+ have "x \<in># arr_mset arr l\<^sub>0 m" using same_mset assms
	+ by (metis assms(3,6,7) add_mset_remove_trivial_eq lran_upd_outside(2)
	+ mset_lran cancel_ab_semigroup_add_class.diff_right_commute
	+ diff_single_trivial multi_self_add_other_not_self order_refl)
	+ then have x_bigger_min: "x \<ge> Min_mset (arr_mset arr l\<^sub>0 m)"
	+ using Min_le by blast
	+ have y_smaller_min: "y \<le> Min_mset (arr_mset arr l\<^sub>0 m)"
	+ proof(cases "y = mod_arr (m - 1)")
	+ case False
	+ hence "y\<in>#arr_mset mod_arr (m - 1) r\<^sub>0 - {#mod_arr (m - 1)#}"
	+ by (metis assms(8) diff_single_trivial insert_DiffM insert_noteq_member)
	+ then have "y\<in>#arr_mset arr m r\<^sub>0"
	+ by (simp add: assms(2) intvs_decr_l mset_ran_insert same_mset)
	+ then show ?thesis
	+ using assms(1) assms(5) by fastforce
	+ qed (simp add: assms(6))
	+ then show ?thesis
	+ using x_bigger_min by linarith
	+qed
	+
	+subsubsection \<open>Implementation\<close>
	+text \<open>Now finally the correctness of the \<open>heap_sort\<close> is shown. As mentioned, it starts by
	+ transforming the array into a minimum heap using @{const "make_heap"}. Then in each
	+ iteration it removes the first element from the heap with @{const "del_min"} after its value
	+ was retrieved with @{const "get_min"}. This value is then put at the position freed by
	+ @{const "del_min"}.\<close>
	+program_spec heap_sort
	+ assumes "l \<le> r"
	+ ensures "array_is_sorted (\<ge>) arr l\<^sub>0 r\<^sub>0 \<and>
	+ arr_mset arr\<^sub>0 l\<^sub>0 r\<^sub>0 = arr_mset arr l\<^sub>0 r\<^sub>0 \<and>
	+ arr\<^sub>0 = arr on - {l\<^sub>0 ..<r\<^sub>0 } \<and> l = l\<^sub>0 \<and> r = r\<^sub>0"
	+ for l r arr[]
	+ defines \<open>
	+ arr = make_heap(arr, l, r);
	+ m = r;
	+ while (m > l)
	+ @variant \<open>m - l + 1\<close>
	+ @invariant \<open>is_heap (\<le>) arr l m \<and>
	+ array_is_sorted (\<ge>) arr m r\<^sub>0 \<and>
	+ (\<forall>x \<in># arr_mset arr l\<^sub>0 m. \<forall>y \<in># arr_mset arr m r\<^sub>0. \<not> x < y) \<and>
	+ arr_mset arr\<^sub>0 l\<^sub>0 r\<^sub>0 = arr_mset arr l\<^sub>0 r\<^sub>0 \<and>
	+ l \<le> m \<and> m \<le> r\<^sub>0 \<and> l = l\<^sub>0 \<and> arr\<^sub>0 = arr on - {l\<^sub>0 ..<r\<^sub>0}\<close>
	+ {
	+ min = get_min(arr, l, m);
	+ (arr, l, m) = del_min(arr, l, m);
	+ arr[m] = min
	+ }
	+ \<close>
	+ apply vcg_cs
	+ subgoal unfolding array_is_sorted_def by simp
	+ subgoal
	+ apply(intro conjI)
	+ subgoal unfolding is_partial_heap_def by simp
	+ subgoal unfolding array_is_sorted_def using heap_sort_second_half_sorted_step
	+ by blast
	+ subgoal using heap_sort_fst_part_bigger_snd_part_step by blast
	+ subgoal using heap_sort_mset_step by blast
	+ subgoal unfolding eq_on_def
	+ by (metis ComplD ComplI atLeastLessThan_iff less_le_trans)
	+ done
	+ done
	+end
	diff --git a/thys/IMP2_Binary_Heap/ROOT b/thys/IMP2_Binary_Heap/ROOT
	new file mode 100644
	--- /dev/null
	+++ b/thys/IMP2_Binary_Heap/ROOT
	@@ -0,0 +1,9 @@
	+chapter AFP
	+
	+session "IMP2_Binary_Heap" (AFP) = IMP2 +
	+ options [timeout=300]
	+ theories
	+ IMP2_Binary_Heap
	+ document_files
	+ "root.tex"
	+ "root.bib"
	diff --git a/thys/IMP2_Binary_Heap/document/root.bib b/thys/IMP2_Binary_Heap/document/root.bib
	new file mode 100644
	--- /dev/null
	+++ b/thys/IMP2_Binary_Heap/document/root.bib
	@@ -0,0 +1,33 @@
	+@article{IMP2-AFP,
	+ author = {Peter Lammich and Simon Wimmer},
	+ title = "{IMP}2 – {S}imple {P}rogram {V}erification in {I}sabelle/{HOL}",
	+ journal = {Archive of Formal Proofs},
	+ month = jan,
	+ year = 2019,
	+ note = {\url{http://isa-afp.org/entries/IMP2.html},
	+ Formal proof development},
	+ ISSN = {2150-914x},
	+}
	+
	+@article{CLRS,
	+ author = {Thomas H. Cormen and Charles E. Leiserson and Ronald L. Rivest and Clifford Stein},
	+ title = {{I}ntroduction to {A}lgorithms},
	+ publisher = {The MIT Press},
	+ year = 2009,
	+ edition = 3,
	+}
	+
	+@article{MS,
	+ author = {Kurt Mehlhorn and Peter Sanders},
	+ title = {{A}lgorithms and {D}ata {S}tructures: {T}he {B}asic {T}oolbox},
	+ publisher = {Springer},
	+ year = 2007,
	+}
	+
	+@inbook{Str_Ind,
	+ author = {Tobias Nipkow and Lawrence C. Paulson and Markus Wenzel},
	+ title = {Isabelle/HOL --- A Proof Assistant for Higher-Order Logic},
	+ publisher = Springer,year=2018,
	+ pages = {184},
	+ note = {\url{http://isabelle.in.tum.de/dist/Isabelle2018/doc/tutorial.pdf}}
	+}
	diff --git a/thys/IMP2_Binary_Heap/document/root.tex b/thys/IMP2_Binary_Heap/document/root.tex
	new file mode 100644
	--- /dev/null
	+++ b/thys/IMP2_Binary_Heap/document/root.tex
	@@ -0,0 +1,61 @@
	+\documentclass[11pt,a4paper]{article}
	+\usepackage{isabelle,isabellesym}
	+
	+% further packages required for unusual symbols (see also
	+% isabellesym.sty), use only when needed
	+
	+%\usepackage{amssymb}
	+ %for \<leadsto>, \<box>, \<diamond>, \<sqsupset>, \<mho>, \<Join>,
	+ %\<lhd>, \<lesssim>, \<greatersim>, \<lessapprox>, \<greaterapprox>,
	+ %\<triangleq>, \<yen>, \<lozenge>
	+
	+%\usepackage{eurosym}
	+ %for \<euro>
	+
	+%\usepackage[only,bigsqcap]{stmaryrd}
	+ %for \<Sqinter>
	+
	+%\usepackage{eufrak}
	+ %for \<AA> ... \<ZZ>, \<aa> ... \<zz> (also included in amssymb)
	+
	+%\usepackage{textcomp}
	+ %for \<onequarter>, \<onehalf>, \<threequarters>, \<degree>, \<cent>,
	+ %\<currency>
	+
	+% this should be the last package used
	+\usepackage{pdfsetup}
	+
	+% urls in roman style, theory text in math-similar italics
	+\urlstyle{rm}
	+\isabellestyle{it}
	+
	+% for uniform font size
	+\renewcommand{\isastyle}{\isastyleminor}
	+
	+
	+\begin{document}
	+\title{IMP2 Binary Heap}
	+\author{Simon Griebel}
	+\date{\today}
	+\maketitle
	+\begin{abstract}
	+In this submission array-based binary minimum heaps are formalized. The correctness of the following heap operations is proven: \mbox{insert}, get-min, delete-min and make-heap. These are then used to verify an in-place heapsort. The formalization is based on IMP2, an imperative program verification framework implemented in Isabelle/HOL. The verified heap functions are iterative versions of the partly recursive functions found in ``Algorithms and Data Structures – The Basic Toolbox'' by K. Mehlhorn and P. Sanders and ``Introduction to Algorithms'' by T. H. Cormen, C. E. Leiserson, R. L. Rivest and C. Stein.
	+\end{abstract}
	+\tableofcontents
	+
	+% sane default for proof documents
	+\parindent 0pt\parskip 0.5ex
	+\newpage
	+% generated text of all theories
	+\input{session}
	+
	+% optional bibliography
	+\bibliographystyle{abbrv}
	+\bibliography{root}
	+
	+\end{document}
	+
	+%%% Local Variables:
	+%%% mode: latex
	+%%% TeX-master: t
	+%%% End:
	diff --git a/thys/Linear_Inequalities/Basis_Extension.thy b/thys/Linear_Inequalities/Basis_Extension.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Basis_Extension.thy
	@@ -0,0 +1,141 @@
	+section \<open>Basis Extension\<close>
	+
	+text \<open>We prove that every linear indepent set/list of vectors can be extended into a basis.
	+ Similarly, from every set of vectors one can extract a linear independent set of vectors
	+ that spans the same space.\<close>
	+
	+theory Basis_Extension
	+ imports
	+ LLL_Basis_Reduction.Gram_Schmidt_2
	+begin
	+
	+
	+context cof_vec_space
	+begin
	+
	+lemma lin_indpt_list_length_le_n: assumes "lin_indpt_list xs"
	+ shows "length xs \<le> n"
	+proof -
	+ from assms[unfolded lin_indpt_list_def]
	+ have xs: "set xs \<subseteq> carrier_vec n" and dist: "distinct xs" and lin: "lin_indpt (set xs)" by auto
	+ from dist have "card (set xs) = length xs" by (rule distinct_card)
	+ moreover have "card (set xs) \<le> n"
	+ using lin xs dim_is_n li_le_dim(2) by auto
	+ ultimately show ?thesis by auto
	+qed
	+
	+lemma lin_indpt_list_length_eq_n: assumes "lin_indpt_list xs"
	+ and "length xs = n"
	+shows "span (set xs) = carrier_vec n" "basis (set xs)"
	+proof -
	+ from assms[unfolded lin_indpt_list_def]
	+ have xs: "set xs \<subseteq> carrier_vec n" and dist: "distinct xs" and lin: "lin_indpt (set xs)" by auto
	+ from dist have "card (set xs) = length xs" by (rule distinct_card)
	+ with assms have "card (set xs) = n" by auto
	+ with lin xs show "span (set xs) = carrier_vec n" "basis (set xs)" using dim_is_n
	+ by (metis basis_def dim_basis dim_li_is_basis fin_dim finite_basis_exists gen_ge_dim li_le_dim(1))+
	+qed
	+
	+lemma expand_to_basis: assumes lin: "lin_indpt_list xs"
	+ shows "\<exists> ys. set ys \<subseteq> set (unit_vecs n) \<and> lin_indpt_list (xs @ ys) \<and> length (xs @ ys) = n"
	+proof -
	+ define y where "y = n - length xs"
	+ from lin have "length xs \<le> n" by (rule lin_indpt_list_length_le_n)
	+ hence "length xs + y = n" unfolding y_def by auto
	+ thus "\<exists> ys. set ys \<subseteq> set (unit_vecs n) \<and> lin_indpt_list (xs @ ys) \<and> length (xs @ ys) = n"
	+ using lin
	+ proof (induct y arbitrary: xs)
	+ case (0 xs)
	+ thus ?case by (intro exI[of _ Nil], auto)
	+ next
	+ case (Suc y xs)
	+ hence "length xs < n" by auto
	+ from Suc(3)[unfolded lin_indpt_list_def]
	+ have xs: "set xs \<subseteq> carrier_vec n" and dist: "distinct xs" and lin: "lin_indpt (set xs)" by auto
	+ from distinct_card[OF dist] Suc(2) have card: "card (set xs) < n" by auto
	+ have "span (set xs) \<noteq> carrier_vec n" using card dim_is_n xs basis_def dim_basis lin by auto
	+ with span_closed[OF xs] have "span (set xs) \<subset> carrier_vec n" by auto
	+ also have "carrier_vec n = span (set (unit_vecs n))"
	+ unfolding span_unit_vecs_is_carrier ..
	+ finally have sub: "span (set xs) \<subset> span (set (unit_vecs n))" .
	+ have "\<exists> u. u \<in> set (unit_vecs n) \<and> u \<notin> span (set xs)"
	+ using span_subsetI[OF xs, of "set (unit_vecs n)"] sub by force
	+ then obtain u where uu: "u \<in> set (unit_vecs n)" and usxs: "u \<notin> span (set xs)" by auto
	+ then have u: "u \<in> carrier_vec n" unfolding unit_vecs_def by auto
	+ let ?xs = "xs @ [u]"
	+ from span_mem[OF xs, of u] usxs have uxs: "u \<notin> set xs" by auto
	+ with dist have dist: "distinct ?xs" by auto
	+ have lin: "lin_indpt (set ?xs)" using lin_dep_iff_in_span[OF xs lin u uxs] usxs by auto
	+ from lin dist u xs have lin: "lin_indpt_list ?xs" unfolding lin_indpt_list_def by auto
	+ from Suc(2) have "length ?xs + y = n" by auto
	+ from Suc(1)[OF this lin] obtain ys where
	+ "set ys \<subseteq> set (unit_vecs n)" "lin_indpt_list (?xs @ ys)" "length (?xs @ ys) = n" by auto
	+ thus ?case using uu
	+ by (intro exI[of _ "u # ys"], auto)
	+ qed
	+qed
	+
	+definition "basis_extension xs = (SOME ys.
	+ set ys \<subseteq> set (unit_vecs n) \<and> lin_indpt_list (xs @ ys) \<and> length (xs @ ys) = n)"
	+
	+lemma basis_extension: assumes "lin_indpt_list xs"
	+ shows "set (basis_extension xs) \<subseteq> set (unit_vecs n)"
	+ "lin_indpt_list (xs @ basis_extension xs)"
	+ "length (xs @ basis_extension xs) = n"
	+ using someI_ex[OF expand_to_basis[OF assms], folded basis_extension_def] by auto
	+
	+lemma exists_lin_indpt_sublist: assumes X: "X \<subseteq> carrier_vec n"
	+ shows "\<exists> Ls. lin_indpt_list Ls \<and> span (set Ls) = span X \<and> set Ls \<subseteq> X"
	+proof -
	+ let ?T = ?thesis
	+ have "(\<exists> Ls. lin_indpt_list Ls \<and> span (set Ls) \<subseteq> span X \<and> set Ls \<subseteq> X \<and> length Ls = k) \<or> ?T" for k
	+ proof (induct k)
	+ case 0
	+ have "lin_indpt {}" by (simp add: lindep_span)
	+ thus ?case using span_is_monotone by (auto simp: lin_indpt_list_def)
	+ next
	+ case (Suc k)
	+ show ?case
	+ proof (cases ?T)
	+ case False
	+ with Suc obtain Ls where lin: "lin_indpt_list Ls"
	+ and span: "span (set Ls) \<subseteq> span X" and Ls: "set Ls \<subseteq> X" and len: "length Ls = k" by auto
	+ from Ls X have LsC: "set Ls \<subseteq> carrier_vec n" by auto
	+ show ?thesis
	+ proof (cases "X \<subseteq> span (set Ls)")
	+ case True
	+ hence "span X \<subseteq> span (set Ls)" using LsC X by (metis span_subsetI)
	+ with span have "span (set Ls) = span X" by auto
	+ hence ?T by (intro exI[of _ Ls] conjI True lin Ls)
	+ thus ?thesis by auto
	+ next
	+ case False
	+ with span obtain x where xX: "x \<in> X" and xSLs: "x \<notin> span (set Ls)" by auto
	+ from Ls X have LsC: "set Ls \<subseteq> carrier_vec n" by auto
	+ from span_mem[OF this, of x] xSLs have xLs: "x \<notin> set Ls" by auto
	+ let ?Ls = "x # Ls"
	+ show ?thesis
	+ proof (intro disjI1 exI[of _ ?Ls] conjI)
	+ show "length ?Ls = Suc k" using len by auto
	+ show "lin_indpt_list ?Ls" using lin xSLs xLs unfolding lin_indpt_list_def
	+ using lin_dep_iff_in_span[OF LsC _ _ xLs] xX X by auto
	+ show "set ?Ls \<subseteq> X" using xX Ls by auto
	+ from span_is_monotone[OF this]
	+ show "span (set ?Ls) \<subseteq> span X" .
	+ qed
	+ qed
	+ qed auto
	+ qed
	+ from this[of "n + 1"] lin_indpt_list_length_le_n show ?thesis by fastforce
	+qed
	+
	+lemma exists_lin_indpt_subset: assumes "X \<subseteq> carrier_vec n"
	+ shows "\<exists> Ls. lin_indpt Ls \<and> span (Ls) = span X \<and> Ls \<subseteq> X"
	+proof -
	+ from exists_lin_indpt_sublist[OF assms]
	+ obtain Ls where "lin_indpt_list Ls \<and> span (set Ls) = span X \<and> set Ls \<subseteq> X" by auto
	+ thus ?thesis by (intro exI[of _ "set Ls"], auto simp: lin_indpt_list_def)
	+qed
	+end
	+
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Cone.thy b/thys/Linear_Inequalities/Cone.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Cone.thy
	@@ -0,0 +1,602 @@
	+section \<open>Cones\<close>
	+
	+text \<open>We define the notions like cone, polyhedral cone, etc. and prove some basic facts about them.\<close>
	+
	+theory Cone
	+ imports
	+ Basis_Extension
	+ Missing_VS_Connect
	+ Integral_Bounded_Vectors
	+begin
	+
	+context gram_schmidt
	+begin
	+
	+definition "nonneg_lincomb c Vs b = (lincomb c Vs = b \<and> c ` Vs \<subseteq> {x. x \<ge> 0})"
	+definition "nonneg_lincomb_list c Vs b = (lincomb_list c Vs = b \<and> (\<forall> i < length Vs. c i \<ge> 0))"
	+
	+definition finite_cone :: "'a vec set \<Rightarrow> 'a vec set" where
	+ "finite_cone Vs = ({ b. \<exists> c. nonneg_lincomb c (if finite Vs then Vs else {}) b})"
	+
	+definition cone :: "'a vec set \<Rightarrow> 'a vec set" where
	+ "cone Vs = ({ x. \<exists> Ws. finite Ws \<and> Ws \<subseteq> Vs \<and> x \<in> finite_cone Ws})"
	+
	+definition cone_list :: "'a vec list \<Rightarrow> 'a vec set" where
	+ "cone_list Vs = {b. \<exists>c. nonneg_lincomb_list c Vs b}"
	+
	+lemma finite_cone_iff_cone_list: assumes Vs: "Vs \<subseteq> carrier_vec n"
	+ and id: "Vs = set Vsl"
	+shows "finite_cone Vs = cone_list Vsl"
	+proof -
	+ have fin: "finite Vs" unfolding id by auto
	+ from Vs id have Vsl: "set Vsl \<subseteq> carrier_vec n" by auto
	+ {
	+ fix c b
	+ assume b: "lincomb c Vs = b" and c: "c ` Vs \<subseteq> {x. x \<ge> 0}"
	+ from lincomb_as_lincomb_list[OF Vsl, of c]
	+ have b: "lincomb_list (\<lambda>i. if \<exists>j<i. Vsl ! i = Vsl ! j then 0 else c (Vsl ! i)) Vsl = b"
	+ unfolding b[symmetric] id by simp
	+ have "\<exists> c. nonneg_lincomb_list c Vsl b"
	+ unfolding nonneg_lincomb_list_def
	+ apply (intro exI conjI, rule b)
	+ by (insert c, auto simp: set_conv_nth id)
	+ }
	+ moreover
	+ {
	+ fix c b
	+ assume b: "lincomb_list c Vsl = b" and c: "(\<forall> i < length Vsl. c i \<ge> 0)"
	+ have "nonneg_lincomb (mk_coeff Vsl c) Vs b"
	+ unfolding b[symmetric] nonneg_lincomb_def
	+ apply (subst lincomb_list_as_lincomb[OF Vsl])
	+ by (insert c, auto simp: id mk_coeff_def intro!: sum_list_nonneg)
	+ hence "\<exists> c. nonneg_lincomb c Vs b" by blast
	+ }
	+ ultimately show ?thesis unfolding finite_cone_def cone_list_def
	+ nonneg_lincomb_def nonneg_lincomb_list_def using fin by auto
	+qed
	+
	+lemma cone_alt_def: assumes Vs: "Vs \<subseteq> carrier_vec n"
	+ shows "cone Vs = ({ x. \<exists> Ws. set Ws \<subseteq> Vs \<and> x \<in> cone_list Ws})"
	+ unfolding cone_def
	+proof (intro Collect_cong iffI)
	+ fix x
	+ assume "\<exists>Ws. finite Ws \<and> Ws \<subseteq> Vs \<and> x \<in> finite_cone Ws"
	+ then obtain Ws where *: "finite Ws" "Ws \<subseteq> Vs" "x \<in> finite_cone Ws" by auto
	+ from finite_list[OF *(1)] obtain Wsl where id: "Ws = set Wsl" by auto
	+ from finite_cone_iff_cone_list[OF _ this] *(2-3) Vs
	+ have "x \<in> cone_list Wsl" by auto
	+ with *(2) id show "\<exists>Wsl. set Wsl \<subseteq> Vs \<and> x \<in> cone_list Wsl" by blast
	+next
	+ fix x
	+ assume "\<exists>Wsl. set Wsl \<subseteq> Vs \<and> x \<in> cone_list Wsl"
	+ then obtain Wsl where "set Wsl \<subseteq> Vs" "x \<in> cone_list Wsl" by auto
	+ thus "\<exists>Ws. finite Ws \<and> Ws \<subseteq> Vs \<and> x \<in> finite_cone Ws" using Vs
	+ by (intro exI[of _ "set Wsl"], subst finite_cone_iff_cone_list, auto)
	+qed
	+
	+lemma cone_mono: "Vs \<subseteq> Ws \<Longrightarrow> cone Vs \<subseteq> cone Ws"
	+ unfolding cone_def by blast
	+
	+lemma finite_cone_mono: assumes fin: "finite Ws"
	+ and Ws: "Ws \<subseteq> carrier_vec n"
	+ and sub: "Vs \<subseteq> Ws"
	+shows "finite_cone Vs \<subseteq> finite_cone Ws"
	+proof
	+ fix b
	+ assume "b \<in> finite_cone Vs"
	+ then obtain c where b: "b = lincomb c Vs" and c: "c ` Vs \<subseteq> {x. x \<ge> 0}"
	+ unfolding finite_cone_def nonneg_lincomb_def using finite_subset[OF sub fin] by auto
	+ define d where "d = (\<lambda> v. if v \<in> Vs then c v else 0)"
	+ from c have d: "d ` Ws \<subseteq> {x. x \<ge> 0}" unfolding d_def by auto
	+ have "lincomb d Ws = lincomb d (Ws - Vs) + lincomb d Vs"
	+ by (rule lincomb_vec_diff_add[OF Ws sub fin], auto)
	+ also have "lincomb d Vs = lincomb c Vs"
	+ by (rule lincomb_cong, insert Ws sub, auto simp: d_def)
	+ also have "lincomb d (Ws - Vs) = 0\<^sub>v n"
	+ by (rule lincomb_zero, insert Ws sub, auto simp: d_def)
	+ also have "0\<^sub>v n + lincomb c Vs = lincomb c Vs" using Ws sub by auto
	+ also have "\<dots> = b" unfolding b by simp
	+ finally
	+ have "b = lincomb d Ws" by auto
	+ then show "b \<in> finite_cone Ws" using d fin
	+ unfolding finite_cone_def nonneg_lincomb_def by auto
	+qed
	+
	+lemma finite_cone_carrier: "A \<subseteq> carrier_vec n \<Longrightarrow> finite_cone A \<subseteq> carrier_vec n"
	+ unfolding finite_cone_def nonneg_lincomb_def by auto
	+
	+lemma cone_carrier: "A \<subseteq> carrier_vec n \<Longrightarrow> cone A \<subseteq> carrier_vec n"
	+ using finite_cone_carrier unfolding cone_def by blast
	+
	+lemma cone_iff_finite_cone: assumes A: "A \<subseteq> carrier_vec n"
	+ and fin: "finite A"
	+shows "cone A = finite_cone A"
	+proof
	+ show "finite_cone A \<subseteq> cone A" unfolding cone_def using fin by auto
	+ show "cone A \<subseteq> finite_cone A" unfolding cone_def using fin finite_cone_mono[OF fin A] by auto
	+qed
	+
	+lemma set_in_finite_cone:
	+ assumes Vs: "Vs \<subseteq> carrier_vec n"
	+ and fin: "finite Vs"
	+ shows "Vs \<subseteq> finite_cone Vs"
	+proof
	+ fix x
	+ assume x: "x \<in> Vs"
	+ show "x \<in> finite_cone Vs" unfolding finite_cone_def
	+ proof
	+ let ?c = "\<lambda> y. if x = y then 1 else 0 :: 'a"
	+ have Vsx: "Vs - {x} \<subseteq> carrier_vec n" using Vs by auto
	+ have "lincomb ?c Vs = x + lincomb ?c (Vs - {x})"
	+ using lincomb_del2 x Vs fin by auto
	+ also have "lincomb ?c (Vs - {x}) = 0\<^sub>v n" using lincomb_zero Vsx by auto
	+ also have "x + 0\<^sub>v n = x " using M.r_zero Vs x by auto
	+ finally have "lincomb ?c Vs = x" by auto
	+ moreover have "?c ` Vs \<subseteq> {z. z \<ge> 0}" by auto
	+ ultimately show "\<exists>c. nonneg_lincomb c (if finite Vs then Vs else {}) x"
	+ unfolding nonneg_lincomb_def
	+ using fin by auto
	+ qed
	+qed
	+
	+lemma set_in_cone:
	+ assumes Vs: "Vs \<subseteq> carrier_vec n"
	+ shows "Vs \<subseteq> cone Vs"
	+proof
	+ fix x
	+ assume x: "x \<in> Vs"
	+ show "x \<in> cone Vs" unfolding cone_def
	+ proof (intro CollectI exI)
	+ have "x \<in> carrier_vec n" using Vs x by auto
	+ then have "x \<in> finite_cone {x}" using set_in_finite_cone by auto
	+ then show "finite {x} \<and> {x} \<subseteq> Vs \<and> x \<in> finite_cone {x}" using x by auto
	+ qed
	+qed
	+
	+lemma zero_in_finite_cone:
	+ assumes Vs: "Vs \<subseteq> carrier_vec n"
	+ shows "0\<^sub>v n \<in> finite_cone Vs"
	+proof -
	+ let ?Vs = "(if finite Vs then Vs else {})"
	+ have "lincomb (\<lambda> x. 0 :: 'a) ?Vs = 0\<^sub>v n" using lincomb_zero Vs by auto
	+ moreover have "(\<lambda> x. 0 :: 'a) ` ?Vs \<subseteq> {y. y \<ge> 0}" by auto
	+ ultimately show ?thesis unfolding finite_cone_def nonneg_lincomb_def by blast
	+qed
	+
	+lemma lincomb_in_finite_cone:
	+ assumes "x = lincomb l W"
	+ and "finite W"
	+ and "\<forall>i \<in> W . l i \<ge> 0"
	+ and "W \<subseteq> carrier_vec n"
	+ shows "x \<in> finite_cone W"
	+ using cone_iff_finite_cone assms unfolding finite_cone_def nonneg_lincomb_def by auto
	+
	+lemma lincomb_in_cone:
	+ assumes "x = lincomb l W"
	+ and "finite W"
	+ and "\<forall>i \<in> W . l i \<ge> 0"
	+ and "W \<subseteq> carrier_vec n"
	+ shows "x \<in> cone W"
	+ using cone_iff_finite_cone assms unfolding finite_cone_def nonneg_lincomb_def by auto
	+
	+lemma zero_in_cone: "0\<^sub>v n \<in> cone Vs"
	+proof -
	+ have "finite {}" by auto
	+ moreover have "{} \<subseteq> cone Vs" by auto
	+ moreover have "0\<^sub>v n \<in> finite_cone {}" using zero_in_finite_cone by auto
	+ ultimately show ?thesis unfolding cone_def by blast
	+qed
	+
	+lemma cone_smult:
	+ assumes a: "a \<ge> 0"
	+ and Vs: "Vs \<subseteq> carrier_vec n"
	+ and x: "x \<in> cone Vs"
	+ shows "a \<cdot>\<^sub>v x \<in> cone Vs"
	+proof -
	+ from x Vs obtain Ws c where Ws: "Ws \<subseteq> Vs" and fin: "finite Ws" and
	+ "nonneg_lincomb c Ws x"
	+ unfolding cone_def finite_cone_def by auto
	+ then have "nonneg_lincomb (\<lambda> w. a * c w) Ws (a \<cdot>\<^sub>v x)"
	+ unfolding nonneg_lincomb_def using a lincomb_distrib Vs by auto
	+ then show ?thesis using Ws fin unfolding cone_def finite_cone_def by auto
	+qed
	+
	+lemma finite_cone_empty[simp]: "finite_cone {} = {0\<^sub>v n}"
	+ by (auto simp: finite_cone_def nonneg_lincomb_def)
	+
	+lemma cone_empty[simp]: "cone {} = {0\<^sub>v n}"
	+ unfolding cone_def by simp
	+
	+
	+lemma cone_elem_sum:
	+ assumes Vs: "Vs \<subseteq> carrier_vec n"
	+ and x: "x \<in> cone Vs"
	+ and y: "y \<in> cone Vs"
	+ shows "x + y \<in> cone Vs"
	+proof -
	+ obtain Xs where Xs: "Xs \<subseteq> Vs" and fin_Xs: "finite Xs"
	+ and Xs_cone: "x \<in> finite_cone Xs"
	+ using Vs x unfolding cone_def by auto
	+ obtain Ys where Ys: "Ys \<subseteq> Vs" and fin_Ys: "finite Ys"
	+ and Ys_cone: "y \<in> finite_cone Ys"
	+ using Vs y unfolding cone_def
	+ by auto
	+ have "x \<in> finite_cone (Xs \<union> Ys)" and "y \<in> finite_cone (Xs \<union> Ys)"
	+ using finite_cone_mono fin_Xs fin_Ys Xs Ys Vs Xs_cone Ys_cone
	+ by (blast, blast)
	+ then obtain cx cy where "nonneg_lincomb cx (Xs \<union> Ys) x"
	+ and "nonneg_lincomb cy (Xs \<union> Ys) y"
	+ unfolding finite_cone_def using fin_Xs fin_Ys by auto
	+ hence "nonneg_lincomb (\<lambda> v. cx v + cy v) (Xs \<union> Ys) (x + y)"
	+ unfolding nonneg_lincomb_def
	+ using lincomb_sum[of "Xs \<union> Ys" cx cy] fin_Xs fin_Ys Xs Ys Vs
	+ by fastforce
	+ hence "x + y \<in> finite_cone (Xs \<union> Ys)"
	+ unfolding finite_cone_def using fin_Xs fin_Ys by auto
	+ thus ?thesis unfolding cone_def using fin_Xs fin_Ys Xs Ys by auto
	+qed
	+
	+lemma cone_cone:
	+ assumes Vs: "Vs \<subseteq> carrier_vec n"
	+ shows "cone (cone Vs) = cone Vs"
	+proof
	+ show "cone Vs \<subseteq> cone (cone Vs)"
	+ by (rule set_in_cone[OF cone_carrier[OF Vs]])
	+next
	+ show "cone (cone Vs) \<subseteq> cone Vs"
	+ proof
	+ fix x
	+ assume x: "x \<in> cone (cone Vs)"
	+ then obtain Ws c where Ws: "set Ws \<subseteq> cone Vs"
	+ and c: "nonneg_lincomb_list c Ws x"
	+ using cone_alt_def Vs cone_carrier unfolding cone_list_def by auto
	+
	+ have "set Ws \<subseteq> cone Vs \<Longrightarrow> nonneg_lincomb_list c Ws x \<Longrightarrow> x \<in> cone Vs"
	+ proof (induction Ws arbitrary: x c)
	+ case Nil
	+ hence "x = 0\<^sub>v n" unfolding nonneg_lincomb_list_def by auto
	+ thus "x \<in> cone Vs" using zero_in_cone by auto
	+ next
	+ case (Cons a Ws)
	+ have "a \<in> cone Vs" using Cons.prems(1) by auto
	+ moreover have "c 0 \<ge> 0"
	+ using Cons.prems(2) unfolding nonneg_lincomb_list_def by fastforce
	+ ultimately have "c 0 \<cdot>\<^sub>v a \<in> cone Vs" using cone_smult Vs by auto
	+ moreover have "lincomb_list (c \<circ> Suc) Ws \<in> cone Vs"
	+ using Cons unfolding nonneg_lincomb_list_def by fastforce
	+ moreover have "x = c 0 \<cdot>\<^sub>v a + lincomb_list (c \<circ> Suc) Ws"
	+ using Cons.prems(2) unfolding nonneg_lincomb_list_def
	+ by auto
	+ ultimately show "x \<in> cone Vs" using cone_elem_sum Vs by auto
	+ qed
	+
	+ thus "x \<in> cone Vs" using Ws c by auto
	+ qed
	+qed
	+
	+lemma cone_smult_basis:
	+ assumes Vs: "Vs \<subseteq> carrier_vec n"
	+ and l: "l ` Vs \<subseteq> {x. x > 0}"
	+ shows "cone {l v \<cdot>\<^sub>v v \| v . v \<in> Vs} = cone Vs"
	+proof
	+ have "{l v \<cdot>\<^sub>v v \|v. v \<in> Vs} \<subseteq> cone Vs"
	+ proof
	+ fix x
	+ assume "x \<in> {l v \<cdot>\<^sub>v v \| v. v \<in> Vs}"
	+ then obtain v where "v \<in> Vs" and "x = l v \<cdot>\<^sub>v v" by auto
	+ thus "x \<in> cone Vs" using
	+ set_in_cone[OF Vs] cone_smult[OF _ Vs, of "l v" v] l by fastforce
	+ qed
	+ thus "cone {l v \<cdot>\<^sub>v v \| v. v \<in> Vs} \<subseteq> cone Vs"
	+ using cone_mono cone_cone[OF Vs] by blast
	+next
	+ have lVs: "{l v \<cdot>\<^sub>v v \| v. v \<in> Vs} \<subseteq> carrier_vec n" using Vs by auto
	+ have "Vs \<subseteq> cone {l v \<cdot>\<^sub>v v \| v. v \<in> Vs}"
	+ proof
	+ fix v assume v: "v \<in> Vs"
	+ hence "l v \<cdot>\<^sub>v v \<in> cone {l v \<cdot>\<^sub>v v \| v. v \<in> Vs}" using set_in_cone[OF lVs] by auto
	+ moreover have "1 / l v > 0" using l v by auto
	+ ultimately have "(1 / l v) \<cdot>\<^sub>v (l v \<cdot>\<^sub>v v) \<in> cone {l v \<cdot>\<^sub>v v \| v. v \<in> Vs}"
	+ using cone_smult[OF _ lVs] by auto
	+ also have "(1 / l v) \<cdot>\<^sub>v (l v \<cdot>\<^sub>v v) = v" using l v
	+ by(auto simp add: smult_smult_assoc)
	+ finally show "v \<in> cone {l v \<cdot>\<^sub>v v \| v. v \<in> Vs}" by auto
	+ qed
	+ thus "cone Vs \<subseteq> cone {l v \<cdot>\<^sub>v v \| v. v \<in> Vs}"
	+ using cone_mono cone_cone[OF lVs] by blast
	+qed
	+
	+lemma cone_add_cone:
	+ assumes C: "C \<subseteq> carrier_vec n"
	+ shows "cone C + cone C = cone C"
	+proof
	+ note CC = cone_carrier[OF C]
	+ have "cone C = cone C + {0\<^sub>v n}" by (subst add_0_right_vecset[OF CC], simp)
	+ also have "\<dots> \<subseteq> cone C + cone C"
	+ by (rule set_plus_mono2, insert zero_in_cone, auto)
	+ finally show "cone C \<subseteq> cone C + cone C" by auto
	+ from cone_elem_sum[OF C]
	+ show "cone C + cone C \<subseteq> cone C"
	+ by (auto elim!: set_plus_elim)
	+qed
	+
	+lemma orthogonal_cone:
	+ assumes X: "X \<subseteq> carrier_vec n"
	+ and W: "W \<subseteq> carrier_vec n"
	+ and finX: "finite X"
	+ and spanLW: "span (set Ls \<union> W) = carrier_vec n"
	+ and ortho: "\<And> w x. w \<in> W \<Longrightarrow> x \<in> set Ls \<Longrightarrow> w \<bullet> x = 0"
	+ and WWs: "W = set Ws"
	+ and spanL: "span (set Ls) = span X"
	+ and LX: "set Ls \<subseteq> X"
	+ and lin_Ls_Bs: "lin_indpt_list (Ls @ Bs)"
	+ and len_Ls_Bs: "length (Ls @ Bs) = n"
	+ shows "cone (X \<union> set Bs) \<inter> {x \<in> carrier_vec n. \<forall>w\<in>W. w \<bullet> x = 0} = cone X"
	+ "\<And> x. \<forall>w\<in>W. w \<bullet> x = 0 \<Longrightarrow> Z \<subseteq> X \<Longrightarrow> B \<subseteq> set Bs \<Longrightarrow> x = lincomb c (Z \<union> B)
	+ \<Longrightarrow> x = lincomb c (Z - B)"
	+proof -
	+ from WWs have finW: "finite W" by auto
	+ define Y where "Y = X \<union> set Bs"
	+ from lin_Ls_Bs[unfolded lin_indpt_list_def] have
	+ Ls: "set Ls \<subseteq> carrier_vec n" and
	+ Bs: "set Bs \<subseteq> carrier_vec n" and
	+ distLsBs: "distinct (Ls @ Bs)" and
	+ lin: "lin_indpt (set (Ls @ Bs))" by auto
	+ have LW: "set Ls \<inter> W = {}"
	+ proof (rule ccontr)
	+ assume "\<not> ?thesis"
	+ then obtain x where xX: "x \<in> set Ls" and xW: "x \<in> W" by auto
	+ from ortho[OF xW xX] have "x \<bullet> x = 0" by auto
	+ hence "sq_norm x = 0" by (auto simp: sq_norm_vec_as_cscalar_prod)
	+ with vs_zero_lin_dep[OF _ lin] xX Ls Bs show False by auto
	+ qed
	+ have Y: "Y \<subseteq> carrier_vec n" using X Bs unfolding Y_def by auto
	+ have CLB: "carrier_vec n = span (set (Ls @ Bs))"
	+ using lin_Ls_Bs len_Ls_Bs lin_indpt_list_length_eq_n by blast
	+ also have "\<dots> \<subseteq> span Y"
	+ by (rule span_is_monotone, insert LX, auto simp: Y_def)
	+ finally have span: "span Y = carrier_vec n" using Y by auto
	+ have finY: "finite Y" using finX finW unfolding Y_def by auto
	+ {
	+ fix x Z B d
	+ assume xX: "\<forall>w\<in>W. w \<bullet> x = 0" and ZX: "Z \<subseteq> X" and B: "B \<subseteq> set Bs" and
	+ xd: "x = lincomb d (Z \<union> B)"
	+ from ZX B X Bs have ZB: "Z \<union> B \<subseteq> carrier_vec n" by auto
	+ with xd have x: "x \<in> carrier_vec n" by auto
	+ from xX W have w0: "w \<in> W \<Longrightarrow> w \<bullet> x = 0" for w by auto
	+ from finite_in_span[OF _ _ x[folded spanLW]] Ls X W finW finX
	+ obtain c where xc: "x = lincomb c (set Ls \<union> W)" by auto
	+ have "x = lincomb c (set Ls \<union> W)" unfolding xc by auto
	+ also have "\<dots> = lincomb c (set Ls) + lincomb c W"
	+ by (rule lincomb_union, insert X LX W LW finW, auto)
	+ finally have xsum: "x = lincomb c (set Ls) + lincomb c W" .
	+ {
	+ fix w
	+ assume wW: "w \<in> W"
	+ with W have w: "w \<in> carrier_vec n" by auto
	+ from w0[OF wW, unfolded xsum]
	+ have "0 = w \<bullet> (lincomb c (set Ls) + lincomb c W)" by simp
	+ also have "\<dots> = w \<bullet> lincomb c (set Ls) + w \<bullet> lincomb c W"
	+ by (rule scalar_prod_add_distrib[OF w], insert Ls W, auto)
	+ also have "w \<bullet> lincomb c (set Ls) = 0" using ortho[OF wW]
	+ by (subst lincomb_scalar_prod_right[OF Ls w], auto)
	+ finally have "w \<bullet> lincomb c W = 0" by simp
	+ }
	+ hence "lincomb c W \<bullet> lincomb c W = 0" using W
	+ by (subst lincomb_scalar_prod_left, auto)
	+ hence "sq_norm (lincomb c W) = 0"
	+ by (auto simp: sq_norm_vec_as_cscalar_prod)
	+ hence 0: "lincomb c W = 0\<^sub>v n" using lincomb_closed[OF W, of c] by simp
	+ have xc: "x = lincomb c (set Ls)" unfolding xsum 0 using Ls by auto
	+ hence xL: "x \<in> span (set Ls)" by auto
	+ let ?X = "Z - B"
	+ have "lincomb d ?X \<in> span X" using finite_subset[OF _ finX, of ?X] X ZX by auto
	+ from finite_in_span[OF finite_set Ls this[folded spanL]]
	+ obtain e where ed: "lincomb e (set Ls) = lincomb d ?X" by auto
	+ from B finite_subset[OF B] have finB: "finite B" by auto
	+ from B Bs have BC: "B \<subseteq> carrier_vec n" by auto
	+ define f where "f =
	+ (\<lambda> x. if x \<in> set Bs then if x \<in> B then d x else 0 else if x \<in> set Ls then e x else undefined)"
	+ have "x = lincomb d (?X \<union> B)" unfolding xd by auto
	+ also have "\<dots> = lincomb d ?X + lincomb d B"
	+ by (rule lincomb_union[OF _ _ _ finite_subset[OF _ finX]], insert ZX X finB B Bs, auto)
	+ finally have xd: "x = lincomb d ?X + lincomb d B" .
	+ also have "\<dots> = lincomb e (set Ls) + lincomb d B" unfolding ed by auto
	+ also have "lincomb e (set Ls) = lincomb f (set Ls)"
	+ by (rule lincomb_cong[OF _ Ls], insert distLsBs, auto simp: f_def)
	+ also have "lincomb d B = lincomb f B"
	+ by (rule lincomb_cong[OF _ BC], insert B, auto simp: f_def)
	+ also have "lincomb f B = lincomb f (B \<union> (set Bs - B))"
	+ by (subst lincomb_clean, insert finB Bs B, auto simp: f_def)
	+ also have "B \<union> (set Bs - B) = set Bs" using B by auto
	+ finally have "x = lincomb f (set Ls) + lincomb f (set Bs)" by auto
	+ also have "lincomb f (set Ls) + lincomb f (set Bs) = lincomb f (set (Ls @ Bs))"
	+ by (subst lincomb_union[symmetric], insert Ls distLsBs Bs, auto)
	+ finally have "x = lincomb f (set (Ls @ Bs))" .
	+ hence f: "f \<in> set (Ls @ Bs) \<rightarrow>\<^sub>E UNIV \<and> lincomb f (set (Ls @ Bs)) = x"
	+ by (auto simp: f_def split: if_splits)
	+ from finite_in_span[OF finite_set Ls xL] obtain g where
	+ xg: "x = lincomb g (set Ls)" by auto
	+ define h where "h = (\<lambda> x. if x \<in> set Bs then 0 else if x \<in> set Ls then g x else undefined)"
	+ have "x = lincomb h (set Ls)" unfolding xg
	+ by (rule lincomb_cong[OF _ Ls], insert distLsBs, auto simp: h_def)
	+ also have "\<dots> = lincomb h (set Ls) + 0\<^sub>v n" using Ls by auto
	+ also have "0\<^sub>v n = lincomb h (set Bs)"
	+ by (rule lincomb_zero[symmetric, OF Bs], auto simp: h_def)
	+ also have "lincomb h (set Ls) + lincomb h (set Bs) = lincomb h (set (Ls @ Bs))"
	+ by (subst lincomb_union[symmetric], insert Ls Bs distLsBs, auto)
	+ finally have "x = lincomb h (set (Ls @ Bs))" .
	+ hence h: "h \<in> set (Ls @ Bs) \<rightarrow>\<^sub>E UNIV \<and> lincomb h (set (Ls @ Bs)) = x"
	+ by (auto simp: h_def split: if_splits)
	+ have basis: "basis (set (Ls @ Bs))" using lin_Ls_Bs[unfolded lin_indpt_list_def] len_Ls_Bs
	+ using CLB basis_def by blast
	+ from Ls Bs have "set (Ls @ Bs) \<subseteq> carrier_vec n" by auto
	+ from basis[unfolded basis_criterion[OF finite_set this], rule_format, OF x] f h
	+ have fh: "f = h" by auto
	+ hence "\<And> x. x \<in> set Bs \<Longrightarrow> f x = 0" unfolding h_def by auto
	+ hence "\<And> x. x \<in> B \<Longrightarrow> d x = 0" unfolding f_def using B by force
	+ thus "x = lincomb d ?X" unfolding xd
	+ by (subst (2) lincomb_zero, insert BC ZB X, auto intro!: M.r_zero)
	+ } note main = this
	+ have "cone Y \<inter> {x \<in> carrier_vec n. \<forall>w\<in>W. w \<bullet> x = 0} = cone X" (is "?I = _")
	+ proof
	+ {
	+ fix x
	+ assume xX: "x \<in> cone X"
	+ with cone_carrier[OF X] have x: "x \<in> carrier_vec n" by auto
	+ have "X \<subseteq> Y" unfolding Y_def by auto
	+ from cone_mono[OF this] xX have xY: "x \<in> cone Y" by auto
	+ from cone_iff_finite_cone[OF X finX] xX have "x \<in> finite_cone X" by auto
	+ from this[unfolded finite_cone_def nonneg_lincomb_def] finX obtain c
	+ where "x = lincomb c X" by auto
	+ with finX X have "x \<in> span X" by auto
	+ with spanL have "x \<in> span (set Ls)" by auto
	+ from finite_in_span[OF _ Ls this] obtain c where
	+ xc: "x = lincomb c (set Ls)" by auto
	+ {
	+ fix w
	+ assume wW: "w \<in> W"
	+ hence w: "w \<in> carrier_vec n" using W by auto
	+ have "w \<bullet> x = 0" unfolding xc using ortho[OF wW]
	+ by (subst lincomb_scalar_prod_right[OF Ls w], auto)
	+ }
	+ with xY x have "x \<in> ?I" by blast
	+ }
	+ thus "cone X \<subseteq> ?I" by blast
	+ {
	+ fix x
	+ let ?X = "X - set Bs"
	+ assume "x \<in> ?I"
	+ with cone_carrier[OF Y] cone_iff_finite_cone[OF Y finY]
	+ have xY: "x \<in> finite_cone Y" and x: "x \<in> carrier_vec n"
	+ and w0: "\<And> w. w \<in> W \<Longrightarrow> w \<bullet> x = 0" by auto
	+ from xY[unfolded finite_cone_def nonneg_lincomb_def] finY obtain d
	+ where xd: "x = lincomb d Y" and nonneg: "d ` Y \<subseteq> Collect ((\<le>) 0)" by auto
	+ from main[OF _ _ _ xd[unfolded Y_def]] w0
	+ have "x = lincomb d ?X" by auto
	+ hence "nonneg_lincomb d ?X x" unfolding nonneg_lincomb_def
	+ using nonneg[unfolded Y_def] by auto
	+ hence "x \<in> finite_cone ?X" using finX
	+ unfolding finite_cone_def by auto
	+ hence "x \<in> cone X" using finite_subset[OF _ finX, of ?X] unfolding cone_def by blast
	+ }
	+ then show "?I \<subseteq> cone X" by auto
	+ qed
	+ thus "cone (X \<union> set Bs) \<inter> {x \<in> carrier_vec n. \<forall>w\<in>W. w \<bullet> x = 0} = cone X" unfolding Y_def .
	+qed
	+
	+definition "polyhedral_cone (A :: 'a mat) = { x . x \<in> carrier_vec n \<and> A *\<^sub>v x \<le> 0\<^sub>v (dim_row A)}"
	+
	+lemma polyhedral_cone_carrier: assumes "A \<in> carrier_mat nr n"
	+ shows "polyhedral_cone A \<subseteq> carrier_vec n"
	+ using assms unfolding polyhedral_cone_def by auto
	+
	+lemma cone_in_polyhedral_cone:
	+ assumes CA: "C \<subseteq> polyhedral_cone A"
	+ and A: "A \<in> carrier_mat nr n"
	+ shows "cone C \<subseteq> polyhedral_cone A"
	+proof
	+ interpret nr: gram_schmidt nr "TYPE ('a)".
	+ from polyhedral_cone_carrier[OF A] assms(1)
	+ have C: "C \<subseteq> carrier_vec n" by auto
	+ fix x
	+ assume x: "x \<in> cone C"
	+ then have xn: "x \<in> carrier_vec n"
	+ using cone_carrier[OF C] by auto
	+ from x[unfolded cone_alt_def[OF C] cone_list_def nonneg_lincomb_list_def]
	+ obtain ll Ds where l0: "lincomb_list ll Ds = x" and l1: "\<forall>i<length Ds. 0 \<le> ll i"
	+ and DsC: "set Ds \<subseteq> C"
	+ by auto
	+ from DsC C have Ds: "set Ds \<subseteq> carrier_vec n" by auto
	+
	+ have "A \<^sub>v x = A \<^sub>v (lincomb_list ll Ds)" using l0 by auto
	+ also have "\<dots> = nr.lincomb_list ll (map (\<lambda> d. A *\<^sub>v d) Ds)"
	+ proof -
	+ have one: " \<forall>w\<in>set Ds. dim_vec w = n" using DsC C by auto
	+ have two: "\<forall>w\<in>set (map ((*\<^sub>v) A) Ds). dim_vec w = nr" using A DsC C by auto
	+ show "A \<^sub>v lincomb_list ll Ds = nr.lincomb_list ll (map ((\<^sub>v) A) Ds)"
	+ unfolding lincomb_list_as_mat_mult[OF one] nr.lincomb_list_as_mat_mult[OF two] length_map
	+ proof (subst assoc_mult_mat_vec[symmetric, OF A], force+, rule arg_cong[of _ _ "\<lambda> x. x *\<^sub>v _"])
	+ show "A * mat_of_cols n Ds = mat_of_cols nr (map ((*\<^sub>v) A) Ds)"
	+ unfolding mat_of_cols_def
	+ by (intro eq_matI, insert A Ds[unfolded set_conv_nth],
	+ (force intro!: arg_cong[of _ _ "\<lambda> x. row A _ \<bullet> x"])+)
	+ qed
	+ qed
	+ also have "\<dots> \<le> 0\<^sub>v nr"
	+ proof (intro lesseq_vecI[of _ nr])
	+ have : "set (map ((\<^sub>v) A) Ds) \<subseteq> carrier_vec nr" using A Ds by auto
	+ show Carr: "nr.lincomb_list ll (map ((*\<^sub>v) A) Ds) \<in> carrier_vec nr"
	+ by (intro nr.lincomb_list_carrier[OF *])
	+ fix i
	+ assume i: "i < nr"
	+ from CA[unfolded polyhedral_cone_def] A
	+ have l2: "x \<in> C \<Longrightarrow> A *\<^sub>v x \<le> 0\<^sub>v nr" for x by auto
	+ show "nr.lincomb_list ll (map ((*\<^sub>v) A) Ds) $ i \<le> 0\<^sub>v nr $ i"
	+ unfolding subst nr.lincomb_list_index[OF i *] length_map index_zero_vec(1)[OF i]
	+ proof (intro sum_nonpos mult_nonneg_nonpos)
	+ fix j
	+ assume "j \<in> {0..<length Ds}"
	+ hence j: "j < length Ds" by auto
	+ from j show "0 \<le> ll j" using l1 by auto
	+ from j have "Ds ! j \<in> C" using DsC by auto
	+ from l2[OF this] have l2: "A *\<^sub>v Ds ! j \<le> 0\<^sub>v nr" by auto
	+ from lesseq_vecD[OF _ this i] i have "(A *\<^sub>v Ds ! j) $ i \<le> 0" by auto
	+ thus "map ((*\<^sub>v) A) Ds ! j $ i \<le> 0" using j i by auto
	+ qed
	+ qed auto
	+ finally show "x \<in> polyhedral_cone A"
	+ unfolding polyhedral_cone_def using A xn by auto
	+qed
	+
	+lemma bounded_cone_is_zero:
	+ assumes Ccarr: "C \<subseteq> carrier_vec n" and bnd: "cone C \<subseteq> Bounded_vec bnd"
	+ shows "cone C = {0\<^sub>v n}"
	+proof(rule ccontr)
	+ assume "\<not> ?thesis"
	+ then obtain v where vC: "v \<in> cone C" and vnz: "v \<noteq> 0\<^sub>v n"
	+ using zero_in_cone assms by auto
	+ have vcarr: "v \<in> carrier_vec n" using vC Ccarr cone_carrier by blast
	+ from vnz vcarr obtain i where i_le_n: "i < dim_vec v" and vinz: "v $ i \<noteq> 0" by force
	+ define M where "M = (1 / (v $ i) * (bnd + 1))"
	+ have abs_ge_bnd: "abs (M * (v $ i)) > bnd" unfolding M_def by (simp add: vinz)
	+ have aMvC: "(abs M) \<cdot>\<^sub>v v \<in> cone C" using cone_smult[OF _ Ccarr vC] abs_ge_bnd by simp
	+ have "\<not>(abs (abs M * (v $ i)) \<le> bnd)" using abs_ge_bnd by simp
	+ hence "(abs M) \<cdot>\<^sub>v v \<notin> Bounded_vec bnd" unfolding Bounded_vec_def using i_le_n aMvC by auto
	+ thus False using aMvC bnd by auto
	+qed
	+
	+lemma cone_of_cols: fixes A :: "'a mat" and b :: "'a vec"
	+ assumes A: "A \<in> carrier_mat n nr" and b: "b \<in> carrier_vec n"
	+ shows "b \<in> cone (set (cols A)) \<longleftrightarrow> (\<exists> x. x \<ge> 0\<^sub>v nr \<and> A *\<^sub>v x = b)"
	+proof -
	+ let ?C = "set (cols A)"
	+ from A have C: "?C \<subseteq> carrier_vec n" and C': " \<forall>w\<in>set (cols A). dim_vec w = n"
	+ unfolding cols_def by auto
	+ have id: "finite ?C = True" "length (cols A) = nr" using A by auto
	+ have Aid: "mat_of_cols n (cols A) = A" using A unfolding mat_of_cols_def
	+ by (intro eq_matI, auto)
	+ show ?thesis
	+ unfolding cone_iff_finite_cone[OF C finite_set] finite_cone_iff_cone_list[OF C refl]
	+ unfolding cone_list_def nonneg_lincomb_list_def mem_Collect_eq id
	+ unfolding lincomb_list_as_mat_mult[OF C'] id Aid
	+ proof -
	+ {
	+ fix x
	+ assume "x\<ge>0\<^sub>v nr" "A *\<^sub>v x = b"
	+ hence "\<exists>c. A *\<^sub>v vec nr c = b \<and> (\<forall>i<nr. 0 \<le> c i)" using A b
	+ by (intro exI[of _ "\<lambda> i. x $ i"], auto simp: less_eq_vec_def intro!: arg_cong[of _ _ "(*\<^sub>v) A"])
	+ }
	+ moreover
	+ {
	+ fix c
	+ assume "A *\<^sub>v vec nr c = b" "(\<forall>i<nr. 0 \<le> c i)"
	+ hence "\<exists> x. x\<ge>0\<^sub>v nr \<and> A *\<^sub>v x = b"
	+ by (intro exI[of _ "vec nr c"], auto simp: less_eq_vec_def)
	+ }
	+ ultimately show "(\<exists>c. A \<^sub>v vec nr c = b \<and> (\<forall>i<nr. 0 \<le> c i)) = (\<exists>x\<ge>0\<^sub>v nr. A \<^sub>v x = b)" by blast
	+ qed
	+qed
	+
	+end
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Convex_Hull.thy b/thys/Linear_Inequalities/Convex_Hull.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Convex_Hull.thy
	@@ -0,0 +1,616 @@
	+section \<open>Convex Hulls\<close>
	+
	+text \<open>We define the notion of convex hull of a set or list of vectors and derive basic
	+ properties thereof.\<close>
	+
	+theory Convex_Hull
	+ imports Cone
	+begin
	+
	+context gram_schmidt
	+begin
	+
	+definition "convex_lincomb c Vs b = (nonneg_lincomb c Vs b \<and> sum c Vs = 1)"
	+
	+definition "convex_lincomb_list c Vs b = (nonneg_lincomb_list c Vs b \<and> sum c {0..<length Vs} = 1)"
	+
	+definition "convex_hull Vs = {x. \<exists> Ws c. finite Ws \<and> Ws \<subseteq> Vs \<and> convex_lincomb c Ws x}"
	+
	+lemma convex_hull_carrier[intro]: "Vs \<subseteq> carrier_vec n \<Longrightarrow> convex_hull Vs \<subseteq> carrier_vec n"
	+ unfolding convex_hull_def convex_lincomb_def nonneg_lincomb_def by auto
	+
	+lemma convex_hull_mono: "Vs \<subseteq> Ws \<Longrightarrow> convex_hull Vs \<subseteq> convex_hull Ws"
	+ unfolding convex_hull_def by auto
	+
	+lemma convex_lincomb_empty[simp]: "\<not> (convex_lincomb c {} x)"
	+ unfolding convex_lincomb_def by simp
	+
	+lemma set_in_convex_hull:
	+ assumes "A \<subseteq> carrier_vec n"
	+ shows "A \<subseteq> convex_hull A"
	+proof
	+ fix a
	+ assume "a \<in> A"
	+ hence acarr: "a \<in> carrier_vec n" using assms by auto
	+ hence "convex_lincomb (\<lambda> x. 1) {a} a " unfolding convex_lincomb_def
	+ by (auto simp: nonneg_lincomb_def lincomb_def)
	+ then show "a \<in> convex_hull A" using \<open>a \<in> A\<close> unfolding convex_hull_def by auto
	+qed
	+
	+lemma convex_hull_empty[simp]:
	+ "convex_hull {} = {}"
	+ "A \<subseteq> carrier_vec n \<Longrightarrow> convex_hull A = {} \<longleftrightarrow> A = {}"
	+proof -
	+ show "convex_hull {} = {}" unfolding convex_hull_def by auto
	+ then show "A \<subseteq> carrier_vec n \<Longrightarrow> convex_hull A = {} \<longleftrightarrow> A = {}"
	+ using set_in_convex_hull[of A] by auto
	+qed
	+
	+lemma convex_hull_bound: assumes XBnd: "X \<subseteq> Bounded_vec Bnd"
	+ and X: "X \<subseteq> carrier_vec n"
	+shows "convex_hull X \<subseteq> Bounded_vec Bnd"
	+proof
	+ fix x
	+ assume "x \<in> convex_hull X"
	+ from this[unfolded convex_hull_def]
	+ obtain Y c where fin: "finite Y" and YX: "Y \<subseteq> X" and cx: "convex_lincomb c Y x" by auto
	+ from cx[unfolded convex_lincomb_def nonneg_lincomb_def]
	+ have x: "x = lincomb c Y" and sum: "sum c Y = 1" and c0: "\<And> y. y \<in> Y \<Longrightarrow> c y \<ge> 0" by auto
	+ from YX X XBnd have Y: "Y \<subseteq> carrier_vec n" and YBnd: "Y \<subseteq> Bounded_vec Bnd" by auto
	+ from x Y have dim: "dim_vec x = n" by auto
	+ show "x \<in> Bounded_vec Bnd" unfolding Bounded_vec_def mem_Collect_eq dim
	+ proof (intro allI impI)
	+ fix i
	+ assume i: "i < n"
	+ have "abs (x $ i) = abs (\<Sum>x\<in>Y. c x * x $ i)" unfolding x
	+ by (subst lincomb_index[OF i Y], auto)
	+ also have "\<dots> \<le> (\<Sum>x\<in>Y. abs (c x * x $ i))" by auto
	+ also have "\<dots> = (\<Sum>x\<in>Y. abs (c x) * abs (x $ i))" by (simp add: abs_mult)
	+ also have "\<dots> \<le> (\<Sum>x\<in>Y. abs (c x) * Bnd)"
	+ by (intro sum_mono mult_left_mono, insert YBnd[unfolded Bounded_vec_def] i Y, force+)
	+ also have "\<dots> = (\<Sum>x\<in>Y. abs (c x)) * Bnd"
	+ by (simp add: sum_distrib_right)
	+ also have "(\<Sum>x\<in>Y. abs (c x)) = (\<Sum>x\<in>Y. c x)"
	+ by (rule sum.cong, insert c0, auto)
	+ also have "\<dots> = 1" by fact
	+ finally show "\<bar>x $ i\<bar> \<le> Bnd" by auto
	+ qed
	+qed
	+
	+definition "convex_hull_list Vs = {x. \<exists> c. convex_lincomb_list c Vs x}"
	+
	+lemma lincomb_list_elem:
	+ "set Vs \<subseteq> carrier_vec n \<Longrightarrow>
	+ lincomb_list (\<lambda> j. if i=j then 1 else 0) Vs = (if i < length Vs then Vs ! i else 0\<^sub>v n)"
	+proof (induction Vs rule: rev_induct)
	+ case (snoc x Vs)
	+ have x: "x \<in> carrier_vec n" and Vs: "set Vs \<subseteq> carrier_vec n" using snoc.prems by auto
	+ let ?f = "\<lambda> j. if i = j then 1 else 0"
	+ have "lincomb_list ?f (Vs @ [x]) = lincomb_list ?f Vs + ?f (length Vs) \<cdot>\<^sub>v x"
	+ using x Vs by simp
	+ also have "\<dots> = (if i < length (Vs @ [x]) then (Vs @ [x]) ! i else 0\<^sub>v n)" (is ?goal)
	+ using less_linear[of i "length Vs"]
	+ proof (elim disjE)
	+ assume i: "i < length Vs"
	+ have "lincomb_list (\<lambda>j. if i = j then 1 else 0) Vs = Vs ! i"
	+ using snoc.IH[OF Vs] i by auto
	+ moreover have "(if i = length Vs then 1 else 0) \<cdot>\<^sub>v x = 0\<^sub>v n" using i x by auto
	+ moreover have "(if i < length (Vs @ [x]) then (Vs @ [x]) ! i else 0\<^sub>v n) = Vs ! i"
	+ using i append_Cons_nth_left by fastforce
	+ ultimately show ?goal using Vs i lincomb_list_carrier M.r_zero by metis
	+ next
	+ assume i: "i = length Vs"
	+ have "lincomb_list (\<lambda>j. if i = j then 1 else 0) Vs = 0\<^sub>v n"
	+ using snoc.IH[OF Vs] i by auto
	+ moreover have "(if i = length Vs then 1 else 0) \<cdot>\<^sub>v x = x" using i x by auto
	+ moreover have "(if i < length (Vs @ [x]) then (Vs @ [x]) ! i else 0\<^sub>v n) = x"
	+ using i append_Cons_nth_left by simp
	+ ultimately show ?goal using x by simp
	+ next
	+ assume i: "i > length Vs"
	+ have "lincomb_list (\<lambda>j. if i = j then 1 else 0) Vs = 0\<^sub>v n"
	+ using snoc.IH[OF Vs] i by auto
	+ moreover have "(if i = length Vs then 1 else 0) \<cdot>\<^sub>v x = 0\<^sub>v n" using i x by auto
	+ moreover have "(if i < length (Vs @ [x]) then (Vs @ [x]) ! i else 0\<^sub>v n) = 0\<^sub>v n"
	+ using i by simp
	+ ultimately show ?goal by simp
	+ qed
	+ finally show ?case by auto
	+qed simp
	+
	+lemma set_in_convex_hull_list: fixes Vs :: "'a vec list"
	+ assumes "set Vs \<subseteq> carrier_vec n"
	+ shows "set Vs \<subseteq> convex_hull_list Vs"
	+proof
	+ fix x assume "x \<in> set Vs"
	+ then obtain i where i: "i < length Vs"
	+ and x: "x = Vs ! i" using set_conv_nth[of Vs] by auto
	+ let ?f = "\<lambda> j. if i = j then 1 else 0 :: 'a"
	+ have "lincomb_list ?f Vs = x" using i x lincomb_list_elem[OF assms] by auto
	+ moreover have "\<forall> j < length Vs. ?f j \<ge> 0" by auto
	+ moreover have "sum ?f {0..<length Vs} = 1" using i by simp
	+ ultimately show "x \<in> convex_hull_list Vs"
	+ unfolding convex_hull_list_def convex_lincomb_list_def nonneg_lincomb_list_def
	+ by auto
	+qed
	+
	+lemma convex_hull_list_combination:
	+ assumes Vs: "set Vs \<subseteq> carrier_vec n"
	+ and x: "x \<in> convex_hull_list Vs"
	+ and y: "y \<in> convex_hull_list Vs"
	+ and l0: "0 \<le> l" and l1: "l \<le> 1"
	+ shows "l \<cdot>\<^sub>v x + (1 - l) \<cdot>\<^sub>v y \<in> convex_hull_list Vs"
	+proof -
	+ from x obtain cx where x: "lincomb_list cx Vs = x" and cx0: "\<forall> i < length Vs. cx i \<ge> 0"
	+ and cx1: "sum cx {0..<length Vs} = 1"
	+ unfolding convex_hull_list_def convex_lincomb_list_def nonneg_lincomb_list_def
	+ by auto
	+ from y obtain cy where y: "lincomb_list cy Vs = y" and cy0: "\<forall> i < length Vs. cy i \<ge> 0"
	+ and cy1: "sum cy {0..<length Vs} = 1"
	+ unfolding convex_hull_list_def convex_lincomb_list_def nonneg_lincomb_list_def
	+ by auto
	+ let ?c = "\<lambda> i. l * cx i + (1 - l) * cy i"
	+ have "set Vs \<subseteq> carrier_vec n \<Longrightarrow>
	+ lincomb_list ?c Vs = l \<cdot>\<^sub>v lincomb_list cx Vs + (1 - l) \<cdot>\<^sub>v lincomb_list cy Vs"
	+ proof (induction Vs rule: rev_induct)
	+ case (snoc v Vs)
	+ have v: "v \<in> carrier_vec n" and Vs: "set Vs \<subseteq> carrier_vec n"
	+ using snoc.prems by auto
	+ have "lincomb_list ?c (Vs @ [v]) = lincomb_list ?c Vs + ?c (length Vs) \<cdot>\<^sub>v v"
	+ using snoc.prems by auto
	+ also have "lincomb_list ?c Vs =
	+ l \<cdot>\<^sub>v lincomb_list cx Vs + (1 - l) \<cdot>\<^sub>v lincomb_list cy Vs"
	+ by (rule snoc.IH[OF Vs])
	+ also have "?c (length Vs) \<cdot>\<^sub>v v =
	+ l \<cdot>\<^sub>v (cx (length Vs) \<cdot>\<^sub>v v) + (1 - l) \<cdot>\<^sub>v (cy (length Vs) \<cdot>\<^sub>v v)"
	+ using add_smult_distrib_vec smult_smult_assoc by metis
	+ also have "l \<cdot>\<^sub>v lincomb_list cx Vs + (1 - l) \<cdot>\<^sub>v lincomb_list cy Vs + \<dots> =
	+ l \<cdot>\<^sub>v (lincomb_list cx Vs + cx (length Vs) \<cdot>\<^sub>v v) +
	+ (1 - l) \<cdot>\<^sub>v (lincomb_list cy Vs + cy (length Vs) \<cdot>\<^sub>v v)"
	+ using lincomb_list_carrier[OF Vs] v
	+ by (simp add: M.add.m_assoc M.add.m_lcomm smult_r_distr)
	+ finally show ?case using Vs v by simp
	+ qed simp
	+ hence "lincomb_list ?c Vs = l \<cdot>\<^sub>v x + (1 - l) \<cdot>\<^sub>v y" using Vs x y by simp
	+ moreover have "\<forall> i < length Vs. ?c i \<ge> 0" using cx0 cy0 l0 l1 by simp
	+ moreover have "sum ?c {0..<length Vs} = 1"
	+ proof(simp add: sum.distrib)
	+ have "(\<Sum>i = 0..<length Vs. (1 - l) * cy i) = (1 - l) * sum cy {0..<length Vs}"
	+ using sum_distrib_left by metis
	+ moreover have "(\<Sum>i = 0..<length Vs. l * cx i) = l * sum cx {0..<length Vs}"
	+ using sum_distrib_left by metis
	+ ultimately show "(\<Sum>i = 0..<length Vs. l * cx i) + (\<Sum>i = 0..<length Vs. (1 - l) * cy i) = 1"
	+ using cx1 cy1 by simp
	+ qed
	+ ultimately show ?thesis
	+ unfolding convex_hull_list_def convex_lincomb_list_def nonneg_lincomb_list_def
	+ by auto
	+qed
	+
	+lemma convex_hull_list_mono:
	+ assumes "set Ws \<subseteq> carrier_vec n"
	+ shows "set Vs \<subseteq> set Ws \<Longrightarrow> convex_hull_list Vs \<subseteq> convex_hull_list Ws"
	+proof (standard, induction Vs)
	+ case Nil
	+ from Nil(2) show ?case unfolding convex_hull_list_def convex_lincomb_list_def by auto
	+next
	+ case (Cons v Vs)
	+ have v: "v \<in> set Ws" and Vs: "set Vs \<subseteq> set Ws" using Cons.prems(1) by auto
	+ hence v1: "v \<in> convex_hull_list Ws" using set_in_convex_hull_list[OF assms] by auto
	+ from Cons.prems(2) obtain c
	+ where x: "lincomb_list c (v # Vs) = x" and c0: "\<forall> i < length Vs + 1. c i \<ge> 0"
	+ and c1: "sum c {0..<length Vs + 1} = 1"
	+ unfolding convex_hull_list_def convex_lincomb_list_def nonneg_lincomb_list_def
	+ by auto
	+ have x: "x = c 0 \<cdot>\<^sub>v v + lincomb_list (c \<circ> Suc) Vs" using Vs v assms x by auto
	+
	+ show ?case proof (cases)
	+ assume P: "c 0 = 1"
	+ hence "sum (c \<circ> Suc) {0..<length Vs} = 0"
	+ using sum.atLeast0_lessThan_Suc_shift c1
	+ by (metis One_nat_def R.show_r_zero add.right_neutral add_Suc_right)
	+ moreover have "\<And> i. i \<in> {0..<length Vs} \<Longrightarrow> (c \<circ> Suc) i \<ge> 0"
	+ using c0 by simp
	+ ultimately have "\<forall> i \<in> {0..<length Vs}. (c \<circ> Suc) i = 0"
	+ using sum_nonneg_eq_0_iff by blast
	+ hence "\<And> i. i < length Vs \<Longrightarrow> (c \<circ> Suc) i \<cdot>\<^sub>v Vs ! i = 0\<^sub>v n"
	+ using Vs assms by (simp add: subset_code(1))
	+ hence "lincomb_list (c \<circ> Suc) Vs = 0\<^sub>v n"
	+ using lincomb_list_eq_0 by simp
	+ hence "x = v" using P x v assms by auto
	+ thus ?case using v1 by auto
	+
	+ next
	+
	+ assume P: "c 0 \<noteq> 1"
	+ have c1: "c 0 + sum (c \<circ> Suc) {0..<length Vs} = 1"
	+ using sum.atLeast0_lessThan_Suc_shift[of c] c1 by simp
	+ have "sum (c \<circ> Suc) {0..<length Vs} \<ge> 0" by (rule sum_nonneg, insert c0, simp)
	+ hence "c 0 < 1" using P c1 by auto
	+ let ?c' = "\<lambda> i. 1 / (1 - c 0) * (c \<circ> Suc) i"
	+ have "sum ?c' {0..<length Vs} = 1 / (1 - c 0) * sum (c \<circ> Suc) {0..<length Vs}"
	+ using c1 P sum_distrib_left by metis
	+ hence "sum ?c' {0..<length Vs} = 1" using P c1 by simp
	+ moreover have "\<forall> i < length Vs. ?c' i \<ge> 0" using c0 `c 0 < 1` by simp
	+ ultimately have c': "lincomb_list ?c' Vs \<in> convex_hull_list Ws"
	+ using Cons.IH[OF Vs]
	+ convex_hull_list_def convex_lincomb_list_def nonneg_lincomb_list_def
	+ by blast
	+ have "lincomb_list ?c' Vs = 1 / (1 - c 0) \<cdot>\<^sub>v lincomb_list (c \<circ> Suc) Vs"
	+ by(rule lincomb_list_smult, insert Vs assms, auto)
	+ hence "(1 - c 0) \<cdot>\<^sub>v lincomb_list ?c' Vs = lincomb_list (c \<circ> Suc) Vs"
	+ using P by auto
	+ hence "x = c 0 \<cdot>\<^sub>v v + (1 - c 0) \<cdot>\<^sub>v lincomb_list ?c' Vs" using x by auto
	+ thus "x \<in> convex_hull_list Ws"
	+ using convex_hull_list_combination[OF assms v1 c'] c0 `c 0 < 1`
	+ by simp
	+ qed
	+qed
	+
	+lemma convex_hull_list_eq_set:
	+ "set Vs \<subseteq> carrier_vec n \<Longrightarrow> set Vs = set Ws \<Longrightarrow> convex_hull_list Vs = convex_hull_list Ws"
	+ using convex_hull_list_mono by blast
	+
	+lemma find_indices_empty: "(find_indices x Vs = []) = (x \<notin> set Vs)"
	+proof (induction Vs rule: rev_induct)
	+ case (snoc v Vs)
	+ show ?case
	+ proof
	+ assume "find_indices x (Vs @ [v]) = []"
	+ hence "x \<noteq> v \<and> find_indices x Vs = []" by auto
	+ thus "x \<notin> set (Vs @ [v])" using snoc by simp
	+ next
	+ assume "x \<notin> set (Vs @ [v])"
	+ hence "x \<noteq> v \<and> find_indices x Vs = []" using snoc by auto
	+ thus "find_indices x (Vs @ [v]) = []" by simp
	+ qed
	+qed simp
	+
	+lemma distinct_list_find_indices:
	+ shows "\<lbrakk> i < length Vs; Vs ! i = x; distinct Vs \<rbrakk> \<Longrightarrow> find_indices x Vs = [i]"
	+proof (induction Vs rule: rev_induct)
	+ case (snoc v Vs)
	+ have dist: "distinct Vs" and xVs: "v \<notin> set Vs" using snoc.prems(3) by(simp_all)
	+ show ?case
	+ proof (cases)
	+ assume i: "i = length Vs"
	+ hence "x = v" using snoc.prems(2) by auto
	+ thus ?case using xVs find_indices_empty i
	+ by fastforce
	+ next
	+ assume "i \<noteq> length Vs"
	+ hence i: "i < length Vs" using snoc.prems(1) by simp
	+ hence Vsi: "Vs ! i = x" using snoc.prems(2) append_Cons_nth_left by fastforce
	+ hence "x \<noteq> v" using snoc.prems(3) i by auto
	+ thus ?case using snoc.IH[OF i Vsi dist] by simp
	+ qed
	+qed auto
	+
	+lemma finite_convex_hull_iff_convex_hull_list: assumes Vs: "Vs \<subseteq> carrier_vec n"
	+ and id': "Vs = set Vsl'"
	+shows "convex_hull Vs = convex_hull_list Vsl'"
	+proof -
	+ have fin: "finite Vs" unfolding id' by auto
	+ from finite_distinct_list fin obtain Vsl
	+ where id: "Vs = set Vsl" and dist: "distinct Vsl" by auto
	+ from Vs id have Vsl: "set Vsl \<subseteq> carrier_vec n" by auto
	+ {
	+ fix c :: "nat \<Rightarrow> 'a"
	+ have "distinct Vsl \<Longrightarrow>(\<Sum>x\<in>set Vsl. sum_list (map c (find_indices x Vsl))) =
	+ sum c {0..<length Vsl}"
	+ proof (induction Vsl rule: rev_induct)
	+ case (snoc v Vsl)
	+ let ?coef = "\<lambda> x. sum_list (map c (find_indices x (Vsl @ [v])))"
	+ let ?coef' = "\<lambda> x. sum_list (map c (find_indices x Vsl))"
	+ have dist: "distinct Vsl" using snoc.prems by simp
	+ have "sum ?coef (set (Vsl @ [v])) = sum_list (map ?coef (Vsl @ [v]))"
	+ by (rule sum.distinct_set_conv_list[OF snoc.prems, of ?coef])
	+ also have "\<dots> = sum_list (map ?coef Vsl) + ?coef v" by simp
	+ also have "sum_list (map ?coef Vsl) = sum ?coef (set Vsl)"
	+ using sum.distinct_set_conv_list[OF dist, of ?coef] by auto
	+ also have "\<dots> = sum ?coef' (set Vsl)"
	+ proof (intro R.finsum_restrict[of ?coef] restrict_ext, standard)
	+ fix x
	+ assume "x \<in> set Vsl"
	+ then obtain i where i: "i < length Vsl" and x: "x = Vsl ! i"
	+ using in_set_conv_nth[of x Vsl] by blast
	+ hence "(Vsl @ [v]) ! i = x" by (simp add: append_Cons_nth_left)
	+ hence "?coef x = c i"
	+ using distinct_list_find_indices[OF _ _ snoc.prems] i by fastforce
	+ also have "c i = ?coef' x"
	+ using distinct_list_find_indices[OF i _ dist] x by simp
	+ finally show "?coef x = ?coef' x" by auto
	+ qed
	+ also have "\<dots> = sum c {0..<length Vsl}" by (rule snoc.IH[OF dist])
	+ also have "?coef v = c (length Vsl)"
	+ using distinct_list_find_indices[OF _ _ snoc.prems, of "length Vsl" v]
	+ nth_append_length by simp
	+ finally show ?case using sum.atLeast0_lessThan_Suc by simp
	+ qed simp
	+ } note sum_sumlist = this
	+ {
	+ fix b
	+ assume "b \<in> convex_hull_list Vsl"
	+ then obtain c where b: "lincomb_list c Vsl = b" and c: "(\<forall> i < length Vsl. c i \<ge> 0)"
	+ and c1: "sum c {0..<length Vsl} = 1"
	+ unfolding convex_hull_list_def convex_lincomb_list_def nonneg_lincomb_list_def
	+ by auto
	+ have "convex_lincomb (mk_coeff Vsl c) Vs b"
	+ unfolding b[symmetric] convex_lincomb_def nonneg_lincomb_def
	+ apply (subst lincomb_list_as_lincomb[OF Vsl])
	+ by (insert c c1, auto simp: id mk_coeff_def dist sum_sumlist intro!: sum_list_nonneg)
	+ hence "b \<in> convex_hull Vs"
	+ unfolding convex_hull_def convex_lincomb_def using fin by blast
	+ }
	+ moreover
	+ {
	+ fix b
	+ assume "b \<in> convex_hull Vs"
	+ then obtain c Ws where Ws: "Ws \<subseteq> Vs" and b: "lincomb c Ws = b"
	+ and c: "c ` Ws \<subseteq> {x. x \<ge> 0}" and c1: "sum c Ws = 1"
	+ unfolding convex_hull_def convex_lincomb_def nonneg_lincomb_def by auto
	+ let ?d = "\<lambda> x. if x \<in> Ws then c x else 0"
	+ have "lincomb ?d Vs = lincomb c Ws + lincomb (\<lambda> x. 0) (Vs - Ws)"
	+ using lincomb_union2[OF _ _ Diff_disjoint[of Ws Vs], of c "\<lambda> x. 0"]
	+ fin Vs Diff_partition[OF Ws] by metis
	+ also have "lincomb (\<lambda> x. 0) (Vs - Ws) = 0\<^sub>v n"
	+ using lincomb_zero[of "Vs - Ws" "\<lambda> x. 0"] Vs by auto
	+ finally have "lincomb ?d Vs = b" using b lincomb_closed Vs Ws by auto
	+ moreover have "?d ` Vs \<subseteq> {t. t \<ge> 0}" using c by auto
	+ moreover have "sum ?d Vs = 1" using c1 R.extend_sum[OF fin Ws] by auto
	+ ultimately have "\<exists> c. convex_lincomb c Vs b"
	+ unfolding convex_lincomb_def nonneg_lincomb_def by blast
	+ }
	+ moreover
	+ {
	+ fix b
	+ assume "\<exists> c. convex_lincomb c Vs b"
	+ then obtain c where b: "lincomb c Vs = b" and c: "c ` Vs \<subseteq> {x. x \<ge> 0}"
	+ and c1: "sum c Vs = 1"
	+ unfolding convex_lincomb_def nonneg_lincomb_def by auto
	+ from lincomb_as_lincomb_list_distinct[OF Vsl dist, of c]
	+ have b: "lincomb_list (\<lambda>i. c (Vsl ! i)) Vsl = b"
	+ unfolding b[symmetric] id by simp
	+ have "1 = sum c (set Vsl)" using c1 id by auto
	+ also have "\<dots> = sum_list (map c Vsl)" by(rule sum.distinct_set_conv_list[OF dist])
	+ also have "\<dots> = sum ((!) (map c Vsl)) {0..<length Vsl}"
	+ using sum_list_sum_nth length_map by metis
	+ also have "\<dots> = sum (\<lambda> i. c (Vsl ! i)) {0..<length Vsl}" by simp
	+ finally have sum_1: "(\<Sum>i = 0..<length Vsl. c (Vsl ! i)) = 1" by simp
	+
	+ have "\<exists> c. convex_lincomb_list c Vsl b"
	+ unfolding convex_lincomb_list_def nonneg_lincomb_list_def
	+ by (intro exI[of _ "\<lambda>i. c (Vsl ! i)"] conjI b sum_1)
	+ (insert c, force simp: set_conv_nth id)
	+ hence "b \<in> convex_hull_list Vsl" unfolding convex_hull_list_def by auto
	+ }
	+ ultimately have "convex_hull Vs = convex_hull_list Vsl" by auto
	+ also have "convex_hull_list Vsl = convex_hull_list Vsl'"
	+ using convex_hull_list_eq_set[OF Vsl, of Vsl'] id id' by simp
	+ finally show ?thesis by simp
	+qed
	+
	+definition "convex S = (convex_hull S = S)"
	+
	+lemma convex_convex_hull: "convex S \<Longrightarrow> convex_hull S = S"
	+ unfolding convex_def by auto
	+
	+lemma convex_hull_convex_hull_listD: assumes A: "A \<subseteq> carrier_vec n"
	+ and x: "x \<in> convex_hull A"
	+shows "\<exists> as. set as \<subseteq> A \<and> x \<in> convex_hull_list as"
	+proof -
	+ from x[unfolded convex_hull_def]
	+ obtain X c where finX: "finite X" and XA: "X \<subseteq> A" and "convex_lincomb c X x" by auto
	+ hence x: "x \<in> convex_hull X" unfolding convex_hull_def by auto
	+ from finite_list[OF finX] obtain xs where X: "X = set xs" by auto
	+ from finite_convex_hull_iff_convex_hull_list[OF _ this] x XA A have x: "x \<in> convex_hull_list xs" by auto
	+ thus ?thesis using XA unfolding X by auto
	+qed
	+
	+lemma convex_hull_convex_sum: assumes A: "A \<subseteq> carrier_vec n"
	+ and x: "x \<in> convex_hull A"
	+ and y: "y \<in> convex_hull A"
	+ and a: "0 \<le> a" "a \<le> 1"
	+shows "a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y \<in> convex_hull A"
	+proof -
	+ from convex_hull_convex_hull_listD[OF A x] obtain xs where xs: "set xs \<subseteq> A"
	+ and x: "x \<in> convex_hull_list xs" by auto
	+ from convex_hull_convex_hull_listD[OF A y] obtain ys where ys: "set ys \<subseteq> A"
	+ and y: "y \<in> convex_hull_list ys" by auto
	+ have fin: "finite (set (xs @ ys))" by auto
	+ have sub: "set (xs @ ys) \<subseteq> A" using xs ys by auto
	+ from convex_hull_list_mono[of "xs @ ys" xs] x sub A have x: "x \<in> convex_hull_list (xs @ ys)" by auto
	+ from convex_hull_list_mono[of "xs @ ys" ys] y sub A have y: "y \<in> convex_hull_list (xs @ ys)" by auto
	+ from convex_hull_list_combination[OF _ x y a]
	+ have "a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y \<in> convex_hull_list (xs @ ys)" using sub A by auto
	+ from finite_convex_hull_iff_convex_hull_list[of _ "xs @ ys"] this sub A
	+ have "a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y \<in> convex_hull (set (xs @ ys))" by auto
	+ with convex_hull_mono[OF sub]
	+ show "a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y \<in> convex_hull A" by auto
	+qed
	+
	+lemma convexI: assumes S: "S \<subseteq> carrier_vec n"
	+ and step: "\<And> a x y. x \<in> S \<Longrightarrow> y \<in> S \<Longrightarrow> 0 \<le> a \<Longrightarrow> a \<le> 1 \<Longrightarrow> a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y \<in> S"
	+shows "convex S"
	+ unfolding convex_def
	+proof (standard, standard)
	+ fix z
	+ assume "z \<in> convex_hull S"
	+ from this[unfolded convex_hull_def] obtain W c where "finite W" and WS: "W \<subseteq> S"
	+ and "convex_lincomb c W z" by auto
	+ then show "z \<in> S"
	+ proof (induct W arbitrary: c z)
	+ case empty
	+ thus ?case unfolding convex_lincomb_def by auto
	+ next
	+ case (insert w W c z)
	+ have "convex_lincomb c (insert w W) z" by fact
	+ hence zl: "z = lincomb c (insert w W)" and nonneg: "\<And> w. w \<in> W \<Longrightarrow> 0 \<le> c w"
	+ and cw: "c w \<ge> 0"
	+ and sum: "sum c (insert w W) = 1"
	+ unfolding convex_lincomb_def nonneg_lincomb_def by auto
	+ have zl: "z = c w \<cdot>\<^sub>v w + lincomb c W" unfolding zl
	+ by (rule lincomb_insert2, insert insert S, auto)
	+ have sum: "c w + sum c W = 1" unfolding sum[symmetric]
	+ by (subst sum.insert, insert insert, auto)
	+ have W: "W \<subseteq> carrier_vec n" and w: "w \<in> carrier_vec n" using S insert by auto
	+ show ?case
	+ proof (cases "sum c W = 0")
	+ case True
	+ with nonneg have c0: "\<And> w. w \<in> W \<Longrightarrow> c w = 0"
	+ using insert(1) sum_nonneg_eq_0_iff by auto
	+ with sum have cw: "c w = 1" by auto
	+ have lin0: "lincomb c W = 0\<^sub>v n"
	+ by (intro lincomb_zero W, insert c0, auto)
	+ have "z = w" unfolding zl cw lin0 using w by simp
	+ with insert(4) show ?thesis by simp
	+ next
	+ case False
	+ have "sum c W \<ge> 0" using nonneg by (metis sum_nonneg)
	+ with False have pos: "sum c W > 0" by auto
	+ define b where "b = (\<lambda> w. inverse (sum c W) * c w)"
	+ have "convex_lincomb b W (lincomb b W)"
	+ unfolding convex_lincomb_def nonneg_lincomb_def b_def
	+ proof (intro conjI refl)
	+ show "(\<lambda>w. inverse (sum c W) * c w) ` W \<subseteq> Collect ((\<le>) 0)" using nonneg pos by auto
	+ show "(\<Sum>w\<in>W. inverse (sum c W) * c w) = 1" unfolding sum_distrib_left[symmetric] using False by auto
	+ qed
	+ from insert(3)[OF _ this] insert
	+ have IH: "lincomb b W \<in> S" by auto
	+ have lin: "lincomb c W = sum c W \<cdot>\<^sub>v lincomb b W"
	+ unfolding b_def
	+ by (subst lincomb_smult[symmetric, OF W], rule lincomb_cong[OF _ W], insert False, auto)
	+ from sum cw pos have sum: "sum c W = 1 - c w" and cw1: "c w \<le> 1" by auto
	+ show ?thesis unfolding zl lin unfolding sum
	+ by (rule step[OF _ IH cw cw1], insert insert, auto)
	+ qed
	+ qed
	+next
	+ show "S \<subseteq> convex_hull S" using S by (rule set_in_convex_hull)
	+qed
	+
	+lemma convex_hulls_are_convex: assumes "A \<subseteq> carrier_vec n"
	+ shows "convex (convex_hull A)"
	+ by (intro convexI convex_hull_convex_sum convex_hull_carrier assms)
	+
	+lemma convex_hull_sum: assumes A: "A \<subseteq> carrier_vec n" and B: "B \<subseteq> carrier_vec n"
	+ shows "convex_hull (A + B) = convex_hull A + convex_hull B"
	+proof
	+ note cA = convex_hull_carrier[OF A]
	+ note cB = convex_hull_carrier[OF B]
	+ have "convex (convex_hull A + convex_hull B)"
	+ proof (intro convexI sum_carrier_vec convex_hull_carrier A B)
	+ fix a :: 'a and x1 x2
	+ assume "x1 \<in> convex_hull A + convex_hull B" "x2 \<in> convex_hull A + convex_hull B"
	+ then obtain y1 y2 z1 z2 where
	+ x12: "x1 = y1 + z1" "x2 = y2 + z2" and
	+ y12: "y1 \<in> convex_hull A" "y2 \<in> convex_hull A" and
	+ z12: "z1 \<in> convex_hull B" "z2 \<in> convex_hull B"
	+ unfolding set_plus_def by auto
	+ from y12 z12 cA cB have carr:
	+ "y1 \<in> carrier_vec n" "y2 \<in> carrier_vec n"
	+ "z1 \<in> carrier_vec n" "z2 \<in> carrier_vec n"
	+ by auto
	+ assume a: "0 \<le> a" "a \<le> 1"
	+ have A: "a \<cdot>\<^sub>v y1 + (1 - a) \<cdot>\<^sub>v y2 \<in> convex_hull A" using y12 a A by (metis convex_hull_convex_sum)
	+ have B: "a \<cdot>\<^sub>v z1 + (1 - a) \<cdot>\<^sub>v z2 \<in> convex_hull B" using z12 a B by (metis convex_hull_convex_sum)
	+ have "a \<cdot>\<^sub>v x1 + (1 - a) \<cdot>\<^sub>v x2 = (a \<cdot>\<^sub>v y1 + a \<cdot>\<^sub>v z1) + ((1 - a) \<cdot>\<^sub>v y2 + (1 - a) \<cdot>\<^sub>v z2)" unfolding x12
	+ using carr by (auto simp: smult_add_distrib_vec)
	+ also have "\<dots> = (a \<cdot>\<^sub>v y1 + (1 - a) \<cdot>\<^sub>v y2) + (a \<cdot>\<^sub>v z1 + (1 - a) \<cdot>\<^sub>v z2)" using carr
	+ by (intro eq_vecI, auto)
	+ finally show "a \<cdot>\<^sub>v x1 + (1 - a) \<cdot>\<^sub>v x2 \<in> convex_hull A + convex_hull B"
	+ using A B by auto
	+ qed
	+ from convex_convex_hull[OF this]
	+ have id: "convex_hull (convex_hull A + convex_hull B) = convex_hull A + convex_hull B" .
	+ show "convex_hull (A + B) \<subseteq> convex_hull A + convex_hull B"
	+ by (subst id[symmetric], rule convex_hull_mono[OF set_plus_mono2]; intro set_in_convex_hull A B)
	+ show "convex_hull A + convex_hull B \<subseteq> convex_hull (A + B)"
	+ proof
	+ fix x
	+ assume "x \<in> convex_hull A + convex_hull B"
	+ then obtain y z where x: "x = y + z" and y: "y \<in> convex_hull A" and z: "z \<in> convex_hull B"
	+ by (auto simp: set_plus_def)
	+ from convex_hull_convex_hull_listD[OF A y] obtain ys where ysA: "set ys \<subseteq> A" and
	+ y: "y \<in> convex_hull_list ys" by auto
	+ from convex_hull_convex_hull_listD[OF B z] obtain zs where zsB: "set zs \<subseteq> B" and
	+ z: "z \<in> convex_hull_list zs" by auto
	+ from y[unfolded convex_hull_list_def convex_lincomb_list_def nonneg_lincomb_list_def]
	+ obtain c where yid: "y = lincomb_list c ys"
	+ and conv_c: "(\<forall>i<length ys. 0 \<le> c i) \<and> sum c {0..<length ys} = 1"
	+ by auto
	+ from z[unfolded convex_hull_list_def convex_lincomb_list_def nonneg_lincomb_list_def]
	+ obtain d where zid: "z = lincomb_list d zs"
	+ and conv_d: "(\<forall>i<length zs. 0 \<le> d i) \<and> sum d {0..<length zs} = 1"
	+ by auto
	+ from ysA A have ys: "set ys \<subseteq> carrier_vec n" by auto
	+ from zsB B have zs: "set zs \<subseteq> carrier_vec n" by auto
	+ have [intro, simp]: "lincomb_list x ys \<in> carrier_vec n" for x using lincomb_list_carrier[OF ys] .
	+ have [intro, simp]: "lincomb_list x zs \<in> carrier_vec n" for x using lincomb_list_carrier[OF zs] .
	+ have dim[simp]: "dim_vec (lincomb_list d zs) = n" by auto
	+ from yid have y: "y \<in> carrier_vec n" by auto
	+ from zid have z: "z \<in> carrier_vec n" by auto
	+ {
	+ fix x
	+ assume "x \<in> set (map ((+) y) zs)"
	+ then obtain z where "x = y + z" and "z \<in> set zs" by auto
	+ then obtain j where j: "j < length zs" and x: "x = y + zs ! j" unfolding set_conv_nth by auto
	+ hence mem: "zs ! j \<in> set zs" by auto
	+ hence zsj: "zs ! j \<in> carrier_vec n" using zs by auto
	+ let ?list = "(map (\<lambda> y. y + zs ! j) ys)"
	+ let ?set = "set ?list"
	+ have set: "?set \<subseteq> carrier_vec n" using ys A zsj by auto
	+ have lin_map: "lincomb_list c ?list \<in> carrier_vec n"
	+ by (intro lincomb_list_carrier[OF set])
	+ have "y + (zs ! j) = lincomb_list c ?list"
	+ unfolding yid using zsj lin_map lincomb_list_index[OF _ set] lincomb_list_index[OF _ ys]
	+ by (intro eq_vecI, auto simp: field_simps sum_distrib_right[symmetric] conv_c)
	+ hence "convex_lincomb_list c ?list (y + (zs ! j))"
	+ unfolding convex_lincomb_list_def nonneg_lincomb_list_def using conv_c by auto
	+ hence "y + (zs ! j) \<in> convex_hull_list ?list" unfolding convex_hull_list_def by auto
	+ with finite_convex_hull_iff_convex_hull_list[OF set refl]
	+ have "(y + zs ! j) \<in> convex_hull ?set" by auto
	+ also have "\<dots> \<subseteq> convex_hull (A + B)"
	+ by (rule convex_hull_mono, insert mem ys ysA zsB, force simp: set_plus_def)
	+ finally have "x \<in> convex_hull (A + B)" unfolding x .
	+ } note step1 = this
	+ {
	+ let ?list = "map ((+) y) zs"
	+ let ?set = "set ?list"
	+ have set: "?set \<subseteq> carrier_vec n" using zs B y by auto
	+ have lin_map: "lincomb_list d ?list \<in> carrier_vec n"
	+ by (intro lincomb_list_carrier[OF set])
	+ have [simp]: "i < n \<Longrightarrow> (\<Sum>j = 0..<length zs. d j * (y + zs ! j) $ i) =
	+ (\<Sum>j = 0..<length zs. d j * (y $ i + zs ! j $ i))" for i
	+ by (rule sum.cong, insert zs[unfolded set_conv_nth] y, auto)
	+ have "y + z = lincomb_list d ?list"
	+ unfolding zid using y zs lin_map lincomb_list_index[OF _ set] lincomb_list_index[OF _ zs]
	+ set lincomb_list_carrier[OF zs, of d] zs[unfolded set_conv_nth]
	+ by (intro eq_vecI, auto simp: field_simps sum_distrib_right[symmetric] conv_d)
	+ hence "convex_lincomb_list d ?list x" unfolding x
	+ unfolding convex_lincomb_list_def nonneg_lincomb_list_def using conv_d by auto
	+ hence "x \<in> convex_hull_list ?list" unfolding convex_hull_list_def by auto
	+ with finite_convex_hull_iff_convex_hull_list[OF set refl]
	+ have "x \<in> convex_hull ?set" by auto
	+ also have "\<dots> \<subseteq> convex_hull (convex_hull (A + B))"
	+ by (rule convex_hull_mono, insert step1, auto)
	+ also have "\<dots> = convex_hull (A + B)"
	+ by (rule convex_convex_hull[OF convex_hulls_are_convex], intro sum_carrier_vec A B)
	+ finally show "x \<in> convex_hull (A + B)" .
	+ }
	+ qed
	+qed
	+
	+lemma convex_hull_in_cone:
	+ "convex_hull C \<subseteq> cone C"
	+ unfolding convex_hull_def cone_def convex_lincomb_def finite_cone_def by auto
	+
	+lemma convex_cone:
	+ assumes C: "C \<subseteq> carrier_vec n"
	+ shows "convex (cone C)"
	+ unfolding convex_def
	+ using convex_hull_in_cone set_in_convex_hull[OF cone_carrier[OF C]] cone_cone[OF C]
	+ by blast
	+
	+end
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Decomposition_Theorem.thy b/thys/Linear_Inequalities/Decomposition_Theorem.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Decomposition_Theorem.thy
	@@ -0,0 +1,805 @@
	+section \<open>The Decomposition Theorem\<close>
	+
	+text \<open>This theory contains a proof of the fact, that every polyhedron can be decomposed
	+ into a convex hull of a finite set of points + a finitely generated cone, including bounds
	+ on the numbers that are required in the decomposition.
	+ We further prove the inverse direction of this theorem (without bounds) and
	+ as a corollary, we derive that a polyhedron is bounded iff it is the convex hull
	+ of finitely many points, i.e., a polytope.\<close>
	+
	+theory Decomposition_Theorem
	+ imports
	+ Farkas_Minkowsky_Weyl
	+ Convex_Hull
	+begin
	+
	+context gram_schmidt
	+begin
	+
	+definition "polytope P = (\<exists> V. V \<subseteq> carrier_vec n \<and> finite V \<and> P = convex_hull V)"
	+
	+definition "polyhedron A b = {x \<in> carrier_vec n. A *\<^sub>v x \<le> b}"
	+
	+lemma polyhedra_are_convex:
	+ assumes A: "A \<in> carrier_mat nr n"
	+ and b: "b \<in> carrier_vec nr"
	+ and P: "P = polyhedron A b"
	+ shows "convex P"
	+proof (intro convexI)
	+ show Pcarr: "P \<subseteq> carrier_vec n" using assms unfolding polyhedron_def by auto
	+ fix a :: 'a and x y
	+ assume xy: "x \<in> P" "y \<in> P" and a: "0 \<le> a" "a \<le> 1"
	+ from xy[unfolded P polyhedron_def]
	+ have x: "x \<in> carrier_vec n" and y: "y \<in> carrier_vec n" and le: "A \<^sub>v x \<le> b" "A \<^sub>v y \<le> b" by auto
	+ show "a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y \<in> P" unfolding P polyhedron_def
	+ proof (intro CollectI conjI)
	+ from x have ax: "a \<cdot>\<^sub>v x \<in> carrier_vec n" by auto
	+ from y have ay: "(1 - a) \<cdot>\<^sub>v y \<in> carrier_vec n" by auto
	+ show "a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y \<in> carrier_vec n" using ax ay by auto
	+ show "A *\<^sub>v (a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y) \<le> b"
	+ proof (intro lesseq_vecI[OF _ b])
	+ show "A *\<^sub>v (a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y) \<in> carrier_vec nr" using A x y by auto
	+ fix i
	+ assume i: "i < nr"
	+ from lesseq_vecD[OF b le(1) i] lesseq_vecD[OF b le(2) i]
	+ have le: "(A \<^sub>v x) $ i \<le> b $ i" "(A \<^sub>v y) $ i \<le> b $ i" by auto
	+ have "(A \<^sub>v (a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y)) $ i = a (A \<^sub>v x) $ i + (1 - a) (A *\<^sub>v y) $ i"
	+ using A x y i by (auto simp: scalar_prod_add_distrib[of _ n])
	+ also have "\<dots> \<le> a * b $ i + (1 - a) * b $ i"
	+ by (rule add_mono; rule mult_left_mono, insert le a, auto)
	+ also have "\<dots> = b $ i" by (auto simp: field_simps)
	+ finally show "(A *\<^sub>v (a \<cdot>\<^sub>v x + (1 - a) \<cdot>\<^sub>v y)) $ i \<le> b $ i" .
	+ qed
	+ qed
	+qed
	+
	+end
	+
	+
	+
	+locale gram_schmidt_m = n: gram_schmidt n f_ty + m: gram_schmidt m f_ty
	+ for n m :: nat and f_ty
	+begin
	+
	+lemma vec_first_lincomb_list:
	+ assumes Xs: "set Xs \<subseteq> carrier_vec n"
	+ and nm: "m \<le> n"
	+ shows "vec_first (n.lincomb_list c Xs) m =
	+ m.lincomb_list c (map (\<lambda> v. vec_first v m) Xs)"
	+ using Xs
	+proof (induction Xs arbitrary: c)
	+ case Nil
	+ show ?case by (simp add: nm)
	+next
	+ case (Cons x Xs)
	+ from Cons.prems have x: "x \<in> carrier_vec n" and Xs: "set Xs \<subseteq> carrier_vec n" by auto
	+
	+ have "vec_first (n.lincomb_list c (x # Xs)) m =
	+ vec_first (c 0 \<cdot>\<^sub>v x + n.lincomb_list (c \<circ> Suc) Xs) m" by auto
	+ also have "\<dots> = vec_first (c 0 \<cdot>\<^sub>v x) m + vec_first (n.lincomb_list (c \<circ> Suc) Xs) m"
	+ using vec_first_add[of m "c 0 \<cdot>\<^sub>v x"] x n.lincomb_list_carrier[OF Xs, of "c \<circ> Suc"] nm
	+ by simp
	+ also have "vec_first (c 0 \<cdot>\<^sub>v x) m = c 0 \<cdot>\<^sub>v vec_first x m"
	+ using vec_first_smult[OF nm, of x "c 0"] Cons.prems by auto
	+ also have "vec_first (n.lincomb_list (c \<circ> Suc) Xs) m =
	+ m.lincomb_list (c \<circ> Suc) (map (\<lambda> v. vec_first v m) Xs)"
	+ using Cons by simp
	+ also have "c 0 \<cdot>\<^sub>v vec_first x m + \<dots> =
	+ m.lincomb_list c (map (\<lambda> v. vec_first v m) (x # Xs))"
	+ by simp
	+ finally show ?case by auto
	+qed
	+
	+lemma convex_hull_next_dim:
	+ assumes "n = m + 1"
	+ and X: "X \<subseteq> carrier_vec n"
	+ and "finite X"
	+ and Xm1: "\<forall> y \<in> X. y $ m = 1"
	+ and y_dim: "y \<in> carrier_vec n"
	+ and y: "y $ m = 1"
	+ shows "(vec_first y m \<in> m.convex_hull {vec_first y m \| y. y \<in> X}) = (y \<in> n.cone X)"
	+proof -
	+ from `finite X` obtain Xs where Xs: "X = set Xs" using finite_list by auto
	+ let ?Y = "{vec_first y m \| y. y \<in> X}"
	+ let ?Ys = "map (\<lambda> y. vec_first y m) Xs"
	+ have Ys: "?Y = set ?Ys" using Xs by auto
	+
	+ define x where "x = vec_first y m"
	+ {
	+ have "y = vec_first y m @\<^sub>v vec_last y 1"
	+ using `n = m + 1` vec_first_last_append y_dim by auto
	+ also have "vec_last y 1 = vec_of_scal (vec_last y 1 $ 0)"
	+ using vec_of_scal_dim_1[of "vec_last y 1"] by simp
	+ also have "vec_last y 1 $ 0 = y $ m"
	+ using y_dim `n = m + 1` vec_last_index[of y m 1 0] by auto
	+ finally have "y = x @\<^sub>v vec_of_scal 1" unfolding x_def using y by simp
	+ } note xy = this
	+ {
	+ assume "y \<in> n.cone X"
	+ then obtain c where x: "n.nonneg_lincomb c X y"
	+ using n.cone_iff_finite_cone[OF X] `finite X`
	+ unfolding n.finite_cone_def by auto
	+
	+ have "1 = y $ m" by (simp add: y)
	+ also have "y = n.lincomb c X"
	+ using x unfolding n.nonneg_lincomb_def by simp
	+ also have "\<dots> $ m = (\<Sum>x\<in>X. c x * x $ m)"
	+ using n.lincomb_index[OF _ X] `n = m + 1` by simp
	+ also have "\<dots> = sum c X"
	+ by (rule n.R.finsum_restrict, auto, rule restrict_ext, simp add: Xm1)
	+ finally have "y \<in> n.convex_hull X"
	+ unfolding n.convex_hull_def n.convex_lincomb_def
	+ using `finite X` x by auto
	+ }
	+ moreover have "n.convex_hull X \<subseteq> n.cone X"
	+ unfolding n.convex_hull_def n.convex_lincomb_def n.finite_cone_def n.cone_def
	+ using `finite X` by auto
	+ moreover have "n.convex_hull X = n.convex_hull_list Xs"
	+ by (rule n.finite_convex_hull_iff_convex_hull_list[OF X Xs])
	+ moreover {
	+ assume "y \<in> n.convex_hull_list Xs"
	+ then obtain c where c: "n.lincomb_list c Xs = y"
	+ and c0: "\<forall> i < length Xs. c i \<ge> 0" and c1: "sum c {0..<length Xs} = 1"
	+ unfolding n.convex_hull_list_def n.convex_lincomb_list_def
	+ n.nonneg_lincomb_list_def by fast
	+ have "m.lincomb_list c ?Ys = vec_first y m"
	+ using c vec_first_lincomb_list[of Xs c] X Xs `n = m + 1` by simp
	+ hence "x \<in> m.convex_hull_list ?Ys"
	+ unfolding m.convex_hull_list_def m.convex_lincomb_list_def
	+ m.nonneg_lincomb_list_def
	+ using x_def c0 c1 x_def by auto
	+ } moreover {
	+ assume "x \<in> m.convex_hull_list ?Ys"
	+ then obtain c where x: "m.lincomb_list c ?Ys = x"
	+ and c0: "\<forall> i < length Xs. c i \<ge> 0"
	+ and c1: "sum c {0..<length Xs} = 1"
	+ unfolding m.convex_hull_list_def m.convex_lincomb_list_def
	+ m.nonneg_lincomb_list_def by auto
	+
	+ have "n.lincomb_list c Xs $ m = (\<Sum>j = 0..<length Xs. c j * Xs ! j $ m)"
	+ using n.lincomb_list_index[of m Xs c] `n = m + 1` Xs X by fastforce
	+ also have "\<dots> = sum c {0..<length Xs}"
	+ apply(rule n.R.finsum_restrict, auto, rule restrict_ext)
	+ by (simp add: Xm1 Xs)
	+ also have "\<dots> = 1" by (rule c1)
	+ finally have "vec_last (n.lincomb_list c Xs) 1 $ 0 = 1"
	+ using vec_of_scal_dim_1 vec_last_index[of "n.lincomb_list c Xs" m 1 0]
	+ n.lincomb_list_carrier Xs X `n = m + 1` by simp
	+ hence "vec_last (n.lincomb_list c Xs) 1 = vec_of_scal 1"
	+ using vec_of_scal_dim_1 by auto
	+
	+ moreover have "vec_first (n.lincomb_list c Xs) m = x"
	+ using vec_first_lincomb_list `n = m + 1` Xs X x by auto
	+
	+ moreover have "n.lincomb_list c Xs =
	+ vec_first (n.lincomb_list c Xs) m @\<^sub>v vec_last (n.lincomb_list c Xs) 1"
	+ using vec_first_last_append Xs X n.lincomb_list_carrier `n = m + 1` by auto
	+
	+ ultimately have "n.lincomb_list c Xs = y" using xy by simp
	+
	+ hence "y \<in> n.convex_hull_list Xs"
	+ unfolding n.convex_hull_list_def n.convex_lincomb_list_def
	+ n.nonneg_lincomb_list_def using c0 c1 by blast
	+ }
	+ moreover have "m.convex_hull ?Y = m.convex_hull_list ?Ys"
	+ using m.finite_convex_hull_iff_convex_hull_list[OF _ Ys] by fastforce
	+ ultimately show ?thesis unfolding x_def by blast
	+qed
	+
	+lemma cone_next_dim:
	+ assumes "n = m + 1"
	+ and X: "X \<subseteq> carrier_vec n"
	+ and "finite X"
	+ and Xm0: "\<forall> y \<in> X. y $ m = 0"
	+ and y_dim: "y \<in> carrier_vec n"
	+ and y: "y $ m = 0"
	+ shows "(vec_first y m \<in> m.cone {vec_first y m \| y. y \<in> X}) = (y \<in> n.cone X)"
	+proof -
	+ from `finite X` obtain Xs where Xs: "X = set Xs" using finite_list by auto
	+ let ?Y = "{vec_first y m \| y. y \<in> X}"
	+ let ?Ys = "map (\<lambda> y. vec_first y m) Xs"
	+ have Ys: "?Y = set ?Ys" using Xs by auto
	+
	+ define x where "x = vec_first y m"
	+ {
	+ have "y = vec_first y m @\<^sub>v vec_last y 1"
	+ using `n = m + 1` vec_first_last_append y_dim by auto
	+ also have "vec_last y 1 = vec_of_scal (vec_last y 1 $ 0)"
	+ using vec_of_scal_dim_1[of "vec_last y 1"] by simp
	+ also have "vec_last y 1 $ 0 = y $ m"
	+ using y_dim `n = m + 1` vec_last_index[of y m 1 0] by auto
	+ finally have "y = x @\<^sub>v vec_of_scal 0" unfolding x_def using y by simp
	+ } note xy = this
	+
	+ have "n.cone X = n.cone_list Xs"
	+ using n.cone_iff_finite_cone[OF X `finite X`] n.finite_cone_iff_cone_list[OF X Xs]
	+ by simp
	+ moreover {
	+ assume "y \<in> n.cone_list Xs"
	+ then obtain c where y: "n.lincomb_list c Xs = y" and c: "\<forall> i < length Xs. c i \<ge> 0"
	+ unfolding n.cone_list_def n.nonneg_lincomb_list_def by blast
	+ from y have "m.lincomb_list c ?Ys = x"
	+ unfolding x_def
	+ using vec_first_lincomb_list Xs X `n = m + 1` by auto
	+ hence "x \<in> m.cone_list ?Ys" using c
	+ unfolding m.cone_list_def m.nonneg_lincomb_list_def by auto
	+ } moreover {
	+ assume "x \<in> m.cone_list ?Ys"
	+ then obtain c where x: "m.lincomb_list c ?Ys = x" and c: "\<forall> i < length Xs. c i \<ge> 0"
	+ unfolding m.cone_list_def m.nonneg_lincomb_list_def by auto
	+
	+ have "vec_last (n.lincomb_list c Xs) 1 $ 0 = n.lincomb_list c Xs $ m"
	+ using `n = m + 1` n.lincomb_list_carrier X Xs vec_last_index[of _ m 1 0]
	+ by auto
	+ also have "\<dots> = 0"
	+ using n.lincomb_list_index[of m Xs c] Xs X `n = m + 1` Xm0 by simp
	+ also have "\<dots> = vec_last y 1 $ 0"
	+ using y y_dim `n = m + 1` vec_last_index[of y m 1 0] by auto
	+ finally have "vec_last (n.lincomb_list c Xs) 1 = vec_last y 1" by fastforce
	+
	+ moreover have "vec_first (n.lincomb_list c Xs) m = x"
	+ using vec_first_lincomb_list[of Xs c] x X Xs `n = m + 1`
	+ unfolding x_def by simp
	+
	+ ultimately have "n.lincomb_list c Xs = y" unfolding x_def
	+ using vec_first_last_append[of _ m 1] `n = m + 1` y_dim
	+ n.lincomb_list_carrier[of Xs c] Xs X
	+ by metis
	+ hence "y \<in> n.cone_list Xs"
	+ unfolding n.cone_list_def n.nonneg_lincomb_list_def using c by blast
	+ }
	+ moreover have "m.cone_list ?Ys = m.cone ?Y"
	+ using m.finite_cone_iff_cone_list[OF _ Ys] m.cone_iff_finite_cone[of ?Y]
	+ `finite X` by force
	+ ultimately show ?thesis unfolding x_def by blast
	+qed
	+
	+end
	+
	+context gram_schmidt
	+begin
	+
	+lemma decomposition_theorem_polyhedra_1:
	+ assumes A: "A \<in> carrier_mat nr n"
	+ and b: "b \<in> carrier_vec nr"
	+ and P: "P = polyhedron A b"
	+ shows "\<exists> Q X. X \<subseteq> carrier_vec n \<and> finite X \<and>
	+ Q \<subseteq> carrier_vec n \<and> finite Q \<and>
	+ P = convex_hull Q + cone X \<and>
	+ (A \<in> \<int>\<^sub>m \<inter> Bounded_mat Bnd \<longrightarrow> b \<in> \<int>\<^sub>v \<inter> Bounded_vec Bnd \<longrightarrow>
	+ X \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (det_bound n (max 1 Bnd))
	+ \<and> Q \<subseteq> Bounded_vec (det_bound n (max 1 Bnd)))"
	+proof -
	+ interpret next_dim: gram_schmidt "n + 1" "TYPE ('a)".
	+ interpret gram_schmidt_m "n + 1" n "TYPE('a)".
	+
	+ from P[unfolded polyhedron_def] have "P \<subseteq> carrier_vec n" by auto
	+
	+ have mcb: "mat_of_col (-b) \<in> carrier_mat nr 1" using b by auto
	+ define M where "M = (A @\<^sub>c mat_of_col (-b)) @\<^sub>r (0\<^sub>m 1 n @\<^sub>c -1\<^sub>m 1)"
	+ have M_top: "A @\<^sub>c mat_of_col (- b) \<in> carrier_mat nr (n + 1)"
	+ by (rule carrier_append_cols[OF A mcb])
	+ have M_bottom: "(0\<^sub>m 1 n @\<^sub>c -1\<^sub>m 1) \<in> carrier_mat 1 (n + 1)"
	+ by (rule carrier_append_cols, auto)
	+ have M_dim: "M \<in> carrier_mat (nr + 1) (n + 1)"
	+ unfolding M_def
	+ by (rule carrier_append_rows[OF M_top M_bottom])
	+
	+ {
	+ fix x :: "'a vec" fix t assume x: "x \<in> carrier_vec n"
	+ have "x @\<^sub>v vec_of_scal t \<in> next_dim.polyhedral_cone M =
	+ (A *\<^sub>v x - t \<cdot>\<^sub>v b \<le> 0\<^sub>v nr \<and> t \<ge> 0)"
	+ proof -
	+ let ?y = "x @\<^sub>v vec_of_scal t"
	+ have y: "?y \<in> carrier_vec (n + 1)" using x by(simp del: One_nat_def)
	+ have "?y \<in> next_dim.polyhedral_cone M =
	+ (M *\<^sub>v ?y \<le> 0\<^sub>v (nr + 1))"
	+ unfolding next_dim.polyhedral_cone_def using y M_dim by auto
	+ also have "0\<^sub>v (nr + 1) = 0\<^sub>v nr @\<^sub>v 0\<^sub>v 1" by auto
	+ also have "M *\<^sub>v ?y \<le> 0\<^sub>v nr @\<^sub>v 0\<^sub>v 1 =
	+ ((A @\<^sub>c mat_of_col (-b)) *\<^sub>v ?y \<le> 0\<^sub>v nr \<and>
	+ (0\<^sub>m 1 n @\<^sub>c -1\<^sub>m 1) *\<^sub>v ?y \<le> 0\<^sub>v 1)"
	+ unfolding M_def
	+ by (intro append_rows_le[OF M_top M_bottom _ y], auto)
	+ also have "(A @\<^sub>c mat_of_col(-b)) *\<^sub>v ?y =
	+ A \<^sub>v x + mat_of_col(-b) \<^sub>v vec_of_scal t"
	+ by (rule mat_mult_append_cols[OF A _ x],
	+ auto simp add: b simp del: One_nat_def)
	+ also have "mat_of_col(-b) *\<^sub>v vec_of_scal t = t \<cdot>\<^sub>v (-b)"
	+ by(rule mult_mat_of_row_vec_of_scal)
	+ also have "A \<^sub>v x + t \<cdot>\<^sub>v (-b) = A \<^sub>v x - t \<cdot>\<^sub>v b" by auto
	+ also have "(0\<^sub>m 1 n @\<^sub>c - 1\<^sub>m 1) *\<^sub>v (x @\<^sub>v vec_of_scal t) =
	+ 0\<^sub>m 1 n \<^sub>v x + - 1\<^sub>m 1 \<^sub>v vec_of_scal t"
	+ by(rule mat_mult_append_cols, auto simp add: x simp del: One_nat_def)
	+ also have "\<dots> = - vec_of_scal t" using x by (auto simp del: One_nat_def)
	+ also have "(\<dots> \<le> 0\<^sub>v 1) = (t \<ge> 0)" unfolding less_eq_vec_def by auto
	+ finally show "(?y \<in> next_dim.polyhedral_cone M) =
	+ (A *\<^sub>v x - t \<cdot>\<^sub>v b \<le> 0\<^sub>v nr \<and> t \<ge> 0)" by auto
	+ qed
	+ } note M_cone_car = this
	+ from next_dim.farkas_minkowsky_weyl_theorem_2[OF M_dim, of "max 1 Bnd"]
	+ obtain X where X: "next_dim.polyhedral_cone M = next_dim.cone X" and
	+ fin_X: "finite X" and X_carrier: "X \<subseteq> carrier_vec (n+1)"
	+ and Bnd: "M \<in> \<int>\<^sub>m \<inter> Bounded_mat (max 1 Bnd) \<Longrightarrow>
	+ X \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (det_bound n (max 1 Bnd))"
	+ by auto
	+ let ?f = "\<lambda> x. if x $ n = 0 then 1 else 1 / (x $ n)"
	+ define Y where "Y = {?f x \<cdot>\<^sub>v x \| x. x \<in> X}"
	+ have "finite Y" unfolding Y_def using fin_X by auto
	+ have Y_carrier: "Y \<subseteq> carrier_vec (n+1)" unfolding Y_def using X_carrier by auto
	+ have "?f ` X \<subseteq> {y. y > 0}"
	+ proof
	+ fix y
	+ assume "y \<in> ?f ` X"
	+ then obtain x where x: "x \<in> X" and y: "y = ?f x" by auto
	+ show "y \<in> {y. y > 0}"
	+ proof cases
	+ assume "x $ n = 0"
	+ thus "y \<in> {y. y > 0}" using y by auto
	+ next
	+ assume P: "x $ n \<noteq> 0"
	+ have "x = vec_first x n @\<^sub>v vec_last x 1"
	+ using x X_carrier vec_first_last_append by auto
	+ also have "vec_last x 1 = vec_of_scal (vec_last x 1 $ 0)" by auto
	+ also have "vec_last x 1 $ 0 = x $ n"
	+ using x X_carrier unfolding vec_last_def by auto
	+ finally have "x = vec_first x n @\<^sub>v vec_of_scal (x $ n)" by auto
	+ moreover have "x \<in> next_dim.polyhedral_cone M"
	+ using x X X_carrier next_dim.set_in_cone by auto
	+ ultimately have "x $ n \<ge> 0" using M_cone_car vec_first_carrier by metis
	+ hence "x $ n > 0" using P by auto
	+ thus "y \<in> {y. y > 0}" using y by auto
	+ qed
	+ qed
	+ hence Y: "next_dim.cone Y = next_dim.polyhedral_cone M" unfolding Y_def
	+ using next_dim.cone_smult_basis[OF X_carrier] X by auto
	+ define Y0 where "Y0 = {v \<in> Y. v $ n = 0}"
	+ define Y1 where "Y1 = Y - Y0"
	+ have Y0_carrier: "Y0 \<subseteq> carrier_vec (n + 1)" and Y1_carrier: "Y1 \<subseteq> carrier_vec (n + 1)"
	+ unfolding Y0_def Y1_def using Y_carrier by auto
	+ have "finite Y0" and "finite Y1"
	+ unfolding Y0_def Y1_def using `finite Y` by auto
	+
	+ have Y1: "\<And> y. y \<in> Y1 \<Longrightarrow> y $ n = 1"
	+ proof -
	+ fix y assume y: "y \<in> Y1"
	+ hence "y \<in> Y" unfolding Y1_def by auto
	+ then obtain x where "x \<in> X" and x: "y = ?f x \<cdot>\<^sub>v x" unfolding Y_def by auto
	+ then have "x $ n \<noteq> 0" using x y Y1_def Y0_def by auto
	+ then have "y = 1 / (x $ n) \<cdot>\<^sub>v x" using x by auto
	+ then have "y $ n = 1 / (x $ n) * x $ n" using X_carrier `x \<in> X` by auto
	+ thus "y $ n = 1" using `x $ n \<noteq> 0` by auto
	+ qed
	+
	+ let ?Z0 = "{vec_first y n \| y. y \<in> Y0}"
	+ let ?Z1 = "{vec_first y n \| y. y \<in> Y1}"
	+ show ?thesis
	+ proof (intro exI conjI impI)
	+ show "?Z0 \<subseteq> carrier_vec n" by auto
	+ show "?Z1 \<subseteq> carrier_vec n" by auto
	+ show "finite ?Z0" using `finite Y0` by auto
	+ show "finite ?Z1" using `finite Y1` by auto
	+ show "P = convex_hull ?Z1 + cone ?Z0"
	+ proof -
	+ {
	+ fix x
	+ assume "x \<in> P"
	+ hence xn: "x \<in> carrier_vec n" and "A *\<^sub>v x \<le> b"
	+ using P unfolding polyhedron_def by auto
	+ hence "A *\<^sub>v x - 1 \<cdot>\<^sub>v b \<le> 0\<^sub>v nr"
	+ using vec_le_iff_diff_le_0 A b carrier_vecD mult_mat_vec_carrier one_smult_vec
	+ by metis
	+ hence "x @\<^sub>v vec_of_scal 1 \<in> next_dim.polyhedral_cone M"
	+ using M_cone_car[OF xn] by auto
	+ hence "x @\<^sub>v vec_of_scal 1 \<in> next_dim.cone Y" using Y by auto
	+ hence "x @\<^sub>v vec_of_scal 1 \<in> next_dim.finite_cone Y"
	+ using next_dim.cone_iff_finite_cone[OF Y_carrier `finite Y`] by auto
	+ then obtain c where c: "next_dim.nonneg_lincomb c Y (x @\<^sub>v vec_of_scal 1)"
	+ unfolding next_dim.finite_cone_def using `finite Y` by auto
	+ let ?y = "next_dim.lincomb c Y1"
	+ let ?z = "next_dim.lincomb c Y0"
	+ have y_dim: "?y \<in> carrier_vec (n + 1)" and z_dim: "?z \<in> carrier_vec (n + 1)"
	+ unfolding next_dim.nonneg_lincomb_def
	+ using Y0_carrier Y1_carrier next_dim.lincomb_closed by simp_all
	+ hence yz_dim: "?y + ?z \<in> carrier_vec (n + 1)" by auto
	+ have "x @\<^sub>v vec_of_scal 1 = next_dim.lincomb c Y"
	+ using c unfolding next_dim.nonneg_lincomb_def by auto
	+ also have "Y = Y1 \<union> Y0" unfolding Y1_def using Y0_def by blast
	+ also have "next_dim.lincomb c (Y1 \<union> Y0) = ?y + ?z"
	+ using next_dim.lincomb_union2[of Y1 Y0]
	+ `finite Y0` `finite Y` Y0_carrier Y_carrier
	+ unfolding Y1_def by fastforce
	+ also have "?y + ?z = vec_first (?y + ?z) n @\<^sub>v vec_last (?y + ?z) 1"
	+ using vec_first_last_append[of "?y + ?z" n 1] add_carrier_vec yz_dim
	+ by simp
	+ also have "vec_last (?y + ?z) 1 = vec_of_scal ((?y + ?z) $ n)"
	+ using vec_of_scal_dim_1 vec_last_index[OF yz_dim, of 0] by auto
	+ finally have "x @\<^sub>v vec_of_scal 1 =
	+ vec_first (?y + ?z) n @\<^sub>v vec_of_scal ((?y + ?z) $ n)" by auto
	+ hence "x = vec_first (?y + ?z) n" and
	+ yz_last: "vec_of_scal 1 = vec_of_scal ((?y + ?z) $ n)"
	+ using append_vec_eq yz_dim xn by auto
	+ hence xyz: "x = vec_first ?y n + vec_first ?z n"
	+ using vec_first_add[of n ?y ?z] y_dim z_dim by simp
	+
	+ have "1 = ((?y + ?z) $ n)" using yz_last index_vec_of_scal
	+ by (metis (no_types, lifting))
	+ hence "1 = ?y $ n + ?z $ n" using y_dim z_dim by auto
	+ moreover have zn0: "?z $ n = 0"
	+ using next_dim.lincomb_index[OF _ Y0_carrier] Y0_def by auto
	+ ultimately have yn1: "1 = ?y $ n" by auto
	+ have "next_dim.nonneg_lincomb c Y1 ?y"
	+ using c Y1_def
	+ unfolding next_dim.nonneg_lincomb_def by auto
	+ hence "?y \<in> next_dim.cone Y1"
	+ using next_dim.cone_iff_finite_cone[OF Y1_carrier] `finite Y1`
	+ unfolding next_dim.finite_cone_def by auto
	+ hence y: "vec_first ?y n \<in> convex_hull ?Z1"
	+ using convex_hull_next_dim[OF _ Y1_carrier `finite Y1` _ y_dim] Y1 yn1
	+ by simp
	+
	+ have "next_dim.nonneg_lincomb c Y0 ?z" using c Y0_def
	+ unfolding next_dim.nonneg_lincomb_def by blast
	+ hence "?z \<in> next_dim.cone Y0"
	+ using `finite Y0` next_dim.cone_iff_finite_cone[OF Y0_carrier `finite Y0`]
	+ unfolding next_dim.finite_cone_def
	+ by fastforce
	+ hence z: "vec_first ?z n \<in> cone ?Z0"
	+ using cone_next_dim[OF _ Y0_carrier `finite Y0` _ _ zn0] Y0_def
	+ next_dim.lincomb_closed[OF Y0_carrier] by blast
	+
	+ from xyz y z have "x \<in> convex_hull ?Z1 + cone ?Z0" by blast
	+ } moreover {
	+ fix x
	+ assume "x \<in> convex_hull ?Z1 + cone ?Z0"
	+ then obtain y z where "x = y + z" and y: "y \<in> convex_hull ?Z1"
	+ and z: "z \<in> cone ?Z0" by (auto elim: set_plus_elim)
	+
	+ have yn: "y \<in> carrier_vec n"
	+ using y convex_hull_carrier[OF `?Z1 \<subseteq> carrier_vec n`] by blast
	+ hence "y @\<^sub>v vec_of_scal 1 \<in> carrier_vec (n + 1)"
	+ using vec_of_scal_dim(2) by fast
	+ moreover have "vec_first (y @\<^sub>v vec_of_scal 1) n \<in> convex_hull ?Z1"
	+ using vec_first_append[OF yn] y by auto
	+ moreover have "(y @\<^sub>v vec_of_scal 1) $ n = 1" using yn by simp
	+ ultimately have "y @\<^sub>v vec_of_scal 1 \<in> next_dim.cone Y1"
	+ using convex_hull_next_dim[OF _ Y1_carrier `finite Y1`] Y1 by blast
	+ hence y_cone: "y @\<^sub>v vec_of_scal 1 \<in> next_dim.cone Y"
	+ using next_dim.cone_mono[of Y1 Y] Y1_def by blast
	+
	+ have zn: "z \<in> carrier_vec n" using z cone_carrier[of ?Z0] by fastforce
	+ hence "z @\<^sub>v vec_of_scal 0 \<in> carrier_vec (n + 1)"
	+ using vec_of_scal_dim(2) by fast
	+ moreover have "vec_first (z @\<^sub>v vec_of_scal 0) n \<in> cone ?Z0"
	+ using vec_first_append[OF zn] z by auto
	+ moreover have "(z @\<^sub>v vec_of_scal 0) $ n = 0" using zn by simp
	+ ultimately have "z @\<^sub>v vec_of_scal 0 \<in> next_dim.cone Y0"
	+ using cone_next_dim[OF _ Y0_carrier `finite Y0`] Y0_def by blast
	+ hence z_cone: "z @\<^sub>v vec_of_scal 0 \<in> next_dim.cone Y"
	+ using Y0_def next_dim.cone_mono[of Y0 Y] by blast
	+
	+ have xn: "x \<in> carrier_vec n" using `x = y + z` yn zn by blast
	+ have "x @\<^sub>v vec_of_scal 1 = (y @\<^sub>v vec_of_scal 1) + (z @\<^sub>v vec_of_scal 0)"
	+ using `x = y + z` append_vec_add[OF yn zn]
	+ unfolding vec_of_scal_def by auto
	+ hence "x @\<^sub>v vec_of_scal 1 \<in> next_dim.cone Y"
	+ using next_dim.cone_elem_sum[OF Y_carrier y_cone z_cone] by simp
	+ hence "A *\<^sub>v x - b \<le> 0\<^sub>v nr" using M_cone_car[OF xn] Y by simp
	+ hence "A \<^sub>v x \<le> b" using vec_le_iff_diff_le_0[of "A \<^sub>v x" b]
	+ dim_mult_mat_vec[of A x] A by simp
	+ hence "x \<in> P" using P xn unfolding polyhedron_def by blast
	+ }
	+ ultimately show "P = convex_hull ?Z1 + cone ?Z0" by blast
	+ qed
	+
	+ let ?Bnd = "det_bound n (max 1 Bnd)"
	+ assume "A \<in> \<int>\<^sub>m \<inter> Bounded_mat Bnd"
	+ "b \<in> \<int>\<^sub>v \<inter> Bounded_vec Bnd"
	+ hence *: "A \<in> \<int>\<^sub>m" "A \<in> Bounded_mat Bnd" "b \<in> \<int>\<^sub>v" "b \<in> Bounded_vec Bnd" by auto
	+ have "elements_mat M \<subseteq> elements_mat A \<union> vec_set (-b) \<union> {0,-1}"
	+ unfolding M_def
	+ unfolding elements_mat_append_rows[OF M_top M_bottom]
	+ unfolding elements_mat_append_cols[OF A mcb]
	+ by (subst elements_mat_append_cols, auto)
	+ also have "\<dots> \<subseteq> \<int> \<inter> ({x. abs x \<le> Bnd} \<union> {0,-1})"
	+ using *[unfolded Bounded_mat_elements_mat Ints_mat_elements_mat
	+ Bounded_vec_vec_set Ints_vec_vec_set] by auto
	+ also have "\<dots> \<subseteq> \<int> \<inter> ({x. abs x \<le> max 1 Bnd})" by auto
	+ finally have "M \<in> \<int>\<^sub>m" "M \<in> Bounded_mat (max 1 Bnd)"
	+ unfolding Bounded_mat_elements_mat Ints_mat_elements_mat by auto
	+ hence "M \<in> \<int>\<^sub>m \<inter> Bounded_mat (max 1 Bnd)" by blast
	+ from Bnd[OF this]
	+ have XBnd: "X \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec ?Bnd" .
	+ {
	+ fix y
	+ assume y: "y \<in> Y"
	+ then obtain x where y: "y = ?f x \<cdot>\<^sub>v x" and xX: "x \<in> X" unfolding Y_def by auto
	+ with \<open>X \<subseteq> carrier_vec (n+1)\<close> have x: "x \<in> carrier_vec (n+1)" by auto
	+ from XBnd xX have xI: "x \<in> \<int>\<^sub>v" and xB: "x \<in> Bounded_vec ?Bnd" by auto
	+ {
	+ assume "y $ n = 0"
	+ hence "y = x" unfolding y using x by auto
	+ hence "y \<in> \<int>\<^sub>v \<inter> Bounded_vec ?Bnd" using xI xB by auto
	+ } note y0 = this
	+ {
	+ assume "y $ n \<noteq> 0"
	+ hence x0: "x $ n \<noteq> 0" using x unfolding y by auto
	+ from x xI have "x $ n \<in> \<int>" unfolding Ints_vec_def by auto
	+ with x0 have "abs (x $ n) \<ge> 1" by (meson Ints_nonzero_abs_ge1)
	+ hence abs: "abs (1 / (x $ n)) \<le> 1" by simp
	+ {
	+ fix a
	+ have "abs ((1 / (x $ n)) * a) = abs (1 / (x $ n)) * abs a"
	+ by simp
	+ also have "\<dots> \<le> 1 * abs a"
	+ by (rule mult_right_mono[OF abs], auto)
	+ finally have "abs ((1 / (x $ n)) * a) \<le> abs a" by auto
	+ } note abs = this
	+ from x0 have y: "y = (1 / (x $ n)) \<cdot>\<^sub>v x" unfolding y by auto
	+ have vy: "vec_set y = (\<lambda> a. (1 / (x $ n)) * a) ` vec_set x"
	+ unfolding y by (auto simp: vec_set_def)
	+ have "y \<in> Bounded_vec ?Bnd" using xB abs
	+ unfolding Bounded_vec_vec_set vy
	+ by (smt imageE max.absorb2 max.bounded_iff)
	+ } note yn0 = this
	+ note y0 yn0
	+ } note BndY = this
	+ from \<open>Y \<subseteq> carrier_vec (n+1)\<close>
	+ have setvY: "y \<in> Y \<Longrightarrow> set\<^sub>v (vec_first y n) \<subseteq> set\<^sub>v y" for y
	+ unfolding vec_first_def vec_set_def by auto
	+ from BndY(1) setvY
	+ show "?Z0 \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (det_bound n (max 1 Bnd))"
	+ by (force simp: Bounded_vec_vec_set Ints_vec_vec_set Y0_def)
	+ from BndY(2) setvY
	+ show "?Z1 \<subseteq> Bounded_vec (det_bound n (max 1 Bnd))"
	+ by (force simp: Bounded_vec_vec_set Ints_vec_vec_set Y0_def Y1_def)
	+ qed
	+qed
	+
	+lemma decomposition_theorem_polyhedra_2:
	+ assumes Q: "Q \<subseteq> carrier_vec n" and fin_Q: "finite Q"
	+ and X: "X \<subseteq> carrier_vec n" and fin_X: "finite X"
	+ and P: "P = convex_hull Q + cone X"
	+ shows "\<exists>A b nr. A \<in> carrier_mat nr n \<and> b \<in> carrier_vec nr \<and> P = polyhedron A b"
	+proof -
	+ interpret next_dim: gram_schmidt "n + 1" "TYPE ('a)".
	+ interpret gram_schmidt_m "n + 1" n "TYPE('a)".
	+
	+ from fin_Q obtain Qs where Qs: "Q = set Qs" using finite_list by auto
	+ from fin_X obtain Xs where Xs: "X = set Xs" using finite_list by auto
	+ define Y where "Y = {x @\<^sub>v vec_of_scal 1 \| x. x \<in> Q}"
	+ define Z where "Z = {x @\<^sub>v vec_of_scal 0 \| x. x \<in> X}"
	+ have fin_Y: "finite Y" unfolding Y_def using fin_Q by simp
	+ have fin_Z: "finite Z" unfolding Z_def using fin_X by simp
	+ have Y_dim: "Y \<subseteq> carrier_vec (n + 1)"
	+ unfolding Y_def using Q append_carrier_vec[OF _ vec_of_scal_dim(2)[of 1]]
	+ by blast
	+ have Z_dim: "Z \<subseteq> carrier_vec (n + 1)"
	+ unfolding Z_def using X append_carrier_vec[OF _ vec_of_scal_dim(2)[of 0]]
	+ by blast
	+ have Y_car: "Q = {vec_first x n \| x. x \<in> Y}"
	+ proof (intro equalityI subsetI)
	+ fix x assume x: "x \<in> Q"
	+ hence "x @\<^sub>v vec_of_scal 1 \<in> Y" unfolding Y_def by blast
	+ thus "x \<in> {vec_first x n \| x. x \<in> Y}"
	+ using Q vec_first_append[of x n "vec_of_scal 1"] x by force
	+ next
	+ fix x assume "x \<in> {vec_first x n \| x. x \<in> Y}"
	+ then obtain y where "y \<in> Q" and "x = vec_first (y @\<^sub>v vec_of_scal 1) n"
	+ unfolding Y_def by blast
	+ thus "x \<in> Q" using Q vec_first_append[of y] by auto
	+ qed
	+ have Z_car: "X = {vec_first x n \| x. x \<in> Z}"
	+ proof (intro equalityI subsetI)
	+ fix x assume x: "x \<in> X"
	+ hence "x @\<^sub>v vec_of_scal 0 \<in> Z" unfolding Z_def by blast
	+ thus "x \<in> {vec_first x n \| x. x \<in> Z}"
	+ using X vec_first_append[of x n "vec_of_scal 0"] x by force
	+ next
	+ fix x assume "x \<in> {vec_first x n \| x. x \<in> Z}"
	+ then obtain y where "y \<in> X" and "x = vec_first (y @\<^sub>v vec_of_scal 0) n"
	+ unfolding Z_def by blast
	+ thus "x \<in> X" using X vec_first_append[of y] by auto
	+ qed
	+ have Y_last: "\<forall> x \<in> Y. x $ n = 1" unfolding Y_def using Q by auto
	+ have Z_last: "\<forall> x \<in> Z. x $ n = 0" unfolding Z_def using X by auto
	+
	+ have "finite (Y \<union> Z)" using fin_Y fin_Z by blast
	+ moreover have "Y \<union> Z \<subseteq> carrier_vec (n + 1)" using Y_dim Z_dim by blast
	+ ultimately obtain B nr
	+ where B: "next_dim.cone (Y \<union> Z) = next_dim.polyhedral_cone B"
	+ and B_carrier: "B \<in> carrier_mat nr (n + 1)"
	+ using next_dim.farkas_minkowsky_weyl_theorem[of "next_dim.cone (Y \<union> Z)"]
	+ by blast
	+ define A where "A = mat_col_first B n"
	+ define b where "b = col B n"
	+ have B_blocks: "B = A @\<^sub>c mat_of_col b"
	+ unfolding A_def b_def
	+ using mat_col_first_last_append[of B n 1] B_carrier
	+ mat_of_col_dim_col_1[of "mat_col_last B 1"] by auto
	+ have A_carrier: "A \<in> carrier_mat nr n" unfolding A_def using B_carrier by force
	+ have b_carrier: "b \<in> carrier_vec nr" unfolding b_def using B_carrier by force
	+
	+ {
	+ fix x assume "x \<in> P"
	+ then obtain y z where x: "x = y + z" and y: "y \<in> convex_hull Q" and z: "z \<in> cone X"
	+ using P by (auto elim: set_plus_elim)
	+
	+ have yn: "y \<in> carrier_vec n" using y convex_hull_carrier[OF Q] by blast
	+ moreover have zn: "z \<in> carrier_vec n" using z cone_carrier[OF X] by blast
	+ ultimately have xn: "x \<in> carrier_vec n" using x by blast
	+
	+ have yn1: "y @\<^sub>v vec_of_scal 1 \<in> carrier_vec (n + 1)"
	+ using append_carrier_vec[OF yn] vec_of_scal_dim by fast
	+ have y_last: "(y @\<^sub>v vec_of_scal 1) $ n = 1" using yn by force
	+ have "vec_first (y @\<^sub>v vec_of_scal 1) n = y"
	+ using vec_first_append[OF yn] by simp
	+ hence "y @\<^sub>v vec_of_scal 1 \<in> next_dim.cone Y"
	+ using convex_hull_next_dim[OF _ Y_dim fin_Y Y_last yn1 y_last] Y_car y by argo
	+ hence y_cone: "y @\<^sub>v vec_of_scal 1 \<in> next_dim.cone (Y \<union> Z)"
	+ using next_dim.cone_mono[of Y "Y \<union> Z"] by blast
	+
	+ have zn1: "z @\<^sub>v vec_of_scal 0 \<in> carrier_vec (n + 1)"
	+ using append_carrier_vec[OF zn] vec_of_scal_dim by fast
	+ have z_last: "(z @\<^sub>v vec_of_scal 0) $ n = 0" using zn by force
	+ have "vec_first (z @\<^sub>v vec_of_scal 0) n = z"
	+ using vec_first_append[OF zn] by simp
	+ hence "z @\<^sub>v vec_of_scal 0 \<in> next_dim.cone Z"
	+ using cone_next_dim[OF _ Z_dim fin_Z Z_last zn1 z_last] Z_car z by argo
	+ hence z_cone: "z @\<^sub>v vec_of_scal 0 \<in> next_dim.cone (Y \<union> Z)"
	+ using next_dim.cone_mono[of Z "Y \<union> Z"] by blast
	+
	+ from `x = y + z`
	+ have "x @\<^sub>v vec_of_scal 1 = (y @\<^sub>v vec_of_scal 1) + (z @\<^sub>v vec_of_scal 0)"
	+ using append_vec_add[OF yn zn] vec_of_scal_dim_1
	+ unfolding vec_of_scal_def by auto
	+ hence "x @\<^sub>v vec_of_scal 1 \<in> next_dim.cone (Y \<union> Z) \<and> x \<in> carrier_vec n"
	+ using next_dim.cone_elem_sum[OF _ y_cone z_cone] Y_dim Z_dim xn by auto
	+ } moreover {
	+ fix x assume "x @\<^sub>v vec_of_scal 1 \<in> next_dim.cone (Y \<union> Z)"
	+ then obtain c where x: "next_dim.lincomb c (Y \<union> Z) = x @\<^sub>v vec_of_scal 1"
	+ and c: "c ` (Y \<union> Z) \<subseteq> {t. t \<ge> 0}"
	+ using next_dim.cone_iff_finite_cone Y_dim Z_dim fin_Y fin_Z
	+ unfolding next_dim.finite_cone_def next_dim.nonneg_lincomb_def by auto
	+
	+ let ?y = "next_dim.lincomb c Y"
	+ let ?z = "next_dim.lincomb c Z"
	+ have xyz: "x @\<^sub>v vec_of_scal 1 = ?y + ?z"
	+ using x next_dim.lincomb_union[OF Y_dim Z_dim _ fin_Y fin_Z] Y_last Z_last
	+ by fastforce
	+
	+ have y_dim: "?y \<in> carrier_vec (n + 1)" using next_dim.lincomb_closed[OF Y_dim]
	+ by blast
	+ have z_dim: "?z \<in> carrier_vec (n + 1)" using next_dim.lincomb_closed[OF Z_dim]
	+ by blast
	+ have "x @\<^sub>v vec_of_scal 1 \<in> carrier_vec (n + 1)"
	+ using xyz add_carrier_vec[OF y_dim z_dim] by argo
	+ hence x_dim: "x \<in> carrier_vec n"
	+ using carrier_dim_vec[of x n] carrier_dim_vec[of _ "n + 1"]
	+ by force
	+
	+ have z_last: "?z $ n = 0" using Z_last next_dim.lincomb_index[OF _ Z_dim, of n]
	+ by force
	+ have "?y $ n + ?z $ n = (x @\<^sub>v vec_of_scal 1) $ n"
	+ using xyz index_add_vec(1) z_dim by simp
	+ also have "\<dots> = 1" using x_dim by auto
	+ finally have y_last: "?y $ n = 1" using z_last by algebra
	+
	+ have "?y \<in> next_dim.cone Y"
	+ using next_dim.cone_iff_finite_cone[OF Y_dim] fin_Y c
	+ unfolding next_dim.finite_cone_def next_dim.nonneg_lincomb_def by auto
	+ hence y_cone: "vec_first ?y n \<in> convex_hull Q"
	+ using convex_hull_next_dim[OF _ Y_dim fin_Y Y_last y_dim y_last] Y_car
	+ by blast
	+
	+ have "?z \<in> next_dim.cone Z"
	+ using next_dim.cone_iff_finite_cone[OF Z_dim] fin_Z c
	+ unfolding next_dim.finite_cone_def next_dim.nonneg_lincomb_def by auto
	+ hence z_cone: "vec_first ?z n \<in> cone X"
	+ using cone_next_dim[OF _ Z_dim fin_Z Z_last z_dim z_last] Z_car
	+ by blast
	+
	+ have "x = vec_first (x @\<^sub>v vec_of_scal 1) n" using vec_first_append[OF x_dim] by simp
	+ also have "\<dots> = vec_first ?y n + vec_first ?z n"
	+ using xyz vec_first_add[of n ?y ?z] y_dim z_dim carrier_dim_vec by auto
	+ finally have "x \<in> P"
	+ using y_cone z_cone P by blast
	+ } moreover {
	+ fix x :: "'a vec"
	+ assume xn: "x \<in> carrier_vec n"
	+ hence "(x @\<^sub>v vec_of_scal 1 \<in> next_dim.polyhedral_cone B) =
	+ (B *\<^sub>v (x @\<^sub>v vec_of_scal 1) \<le> 0\<^sub>v nr)"
	+ unfolding next_dim.polyhedral_cone_def using B_carrier
	+ using append_carrier_vec[OF _ vec_of_scal_dim(2)[of 1]] by auto
	+ also have "\<dots> = ((A @\<^sub>c mat_of_col b) *\<^sub>v (x @\<^sub>v vec_of_scal 1) \<le> 0\<^sub>v nr)"
	+ using B_blocks by blast
	+ also have "(A @\<^sub>c mat_of_col b) *\<^sub>v (x @\<^sub>v vec_of_scal 1) =
	+ A \<^sub>v x + mat_of_col b \<^sub>v vec_of_scal 1"
	+ by (rule mat_mult_append_cols, insert A_carrier b_carrier xn, auto simp del: One_nat_def)
	+ also have "mat_of_col b *\<^sub>v vec_of_scal 1 = b"
	+ using mult_mat_of_row_vec_of_scal[of b 1] by simp
	+ also have "A \<^sub>v x + b = A \<^sub>v x - -b" by auto
	+ finally have "(x @\<^sub>v vec_of_scal 1 \<in> next_dim.polyhedral_cone B) = (A *\<^sub>v x \<le> -b)"
	+ using vec_le_iff_diff_le_0[of "A *\<^sub>v x" "-b"] A_carrier by simp
	+ }
	+ ultimately have "P = polyhedron A (-b)"
	+ unfolding polyhedron_def using B by blast
	+ moreover have "-b \<in> carrier_vec nr" using b_carrier by simp
	+ ultimately show ?thesis using A_carrier by blast
	+qed
	+
	+lemma decomposition_theorem_polyhedra:
	+ "(\<exists> A b nr. A \<in> carrier_mat nr n \<and> b \<in> carrier_vec nr \<and> P = polyhedron A b) \<longleftrightarrow>
	+ (\<exists> Q X. Q \<union> X \<subseteq> carrier_vec n \<and> finite (Q \<union> X) \<and> P = convex_hull Q + cone X)" (is "?l = ?r")
	+proof
	+ assume ?l
	+ then obtain A b nr where A: "A \<in> carrier_mat nr n"
	+ and b: "b \<in> carrier_vec nr" and P: "P = polyhedron A b" by auto
	+ from decomposition_theorem_polyhedra_1[OF this] obtain Q X
	+ where *: "X \<subseteq> carrier_vec n" "finite X" "Q \<subseteq> carrier_vec n" "finite Q" "P = convex_hull Q + cone X"
	+ by meson
	+ show ?r
	+ by (rule exI[of _ Q], rule exI[of _ X], insert *, auto simp: polytope_def)
	+next
	+ assume ?r
	+ then obtain Q X where QX_carrier: "Q \<union> X \<subseteq> carrier_vec n"
	+ and QX_fin: "finite (Q \<union> X)"
	+ and P: "P = convex_hull Q + cone X" by blast
	+ from QX_carrier have Q: "Q \<subseteq> carrier_vec n" and X: "X \<subseteq> carrier_vec n" by simp_all
	+ from QX_fin have fin_Q: "finite Q" and fin_X: "finite X" by simp_all
	+ show ?l using decomposition_theorem_polyhedra_2[OF Q fin_Q X fin_X P] by blast
	+qed
	+
	+lemma polytope_equiv_bounded_polyhedron:
	+ "polytope P \<longleftrightarrow>
	+ (\<exists>A b nr bnd. A \<in> carrier_mat nr n \<and> b \<in> carrier_vec nr \<and> P = polyhedron A b \<and> P \<subseteq> Bounded_vec bnd)"
	+proof
	+ assume polyP: "polytope P"
	+ from this obtain Q where Qcarr: "Q \<subseteq> carrier_vec n" and finQ: "finite Q"
	+ and PconvhQ: "P = convex_hull Q" unfolding polytope_def by auto
	+ let ?X = "{}"
	+ have "convex_hull Q + {0\<^sub>v n} = convex_hull Q" using Qcarr add_0_right_vecset[of "convex_hull Q"]
	+ by (simp add: convex_hull_carrier)
	+ hence "P = convex_hull Q + cone ?X" using PconvhQ by simp
	+ hence "Q \<union> ?X \<subseteq> carrier_vec n \<and> finite (Q \<union> ?X) \<and> P = convex_hull Q + cone ?X"
	+ using Qcarr finQ PconvhQ by simp
	+ hence "\<exists> A b nr. A \<in> carrier_mat nr n \<and> b \<in> carrier_vec nr \<and> P = polyhedron A b"
	+ using decomposition_theorem_polyhedra by blast
	+ hence Ppolyh: "\<exists>A b nr. A \<in> carrier_mat nr n \<and> b \<in> carrier_vec nr \<and> P = polyhedron A b" by blast
	+ from finite_Bounded_vec_Max[OF Qcarr finQ] obtain bnd where "Q \<subseteq> Bounded_vec bnd" by auto
	+ hence Pbnd: "P \<subseteq> Bounded_vec bnd" using convex_hull_bound PconvhQ Qcarr by auto
	+ from Ppolyh Pbnd show "\<exists>A b nr bnd. A \<in> carrier_mat nr n \<and> b \<in> carrier_vec nr
	+ \<and> P = polyhedron A b \<and> P \<subseteq> Bounded_vec bnd" by auto
	+next
	+ assume "\<exists>A b nr bnd. A \<in> carrier_mat nr n \<and> b \<in> carrier_vec nr \<and> P = polyhedron A b
	+ \<and> P \<subseteq> Bounded_vec bnd"
	+ from this obtain A b nr bnd where Adim: "A \<in> carrier_mat nr n" and bdim: "b \<in> carrier_vec nr"
	+ and Ppolyh: "P = polyhedron A b" and Pbnd: "P \<subseteq> Bounded_vec bnd" by auto
	+ have "\<exists> A b nr. A \<in> carrier_mat nr n \<and> b \<in> carrier_vec nr \<and> P = polyhedron A b"
	+ using Adim bdim Ppolyh by blast
	+ hence "\<exists> Q X. Q \<union> X \<subseteq> carrier_vec n \<and> finite (Q \<union> X) \<and> P = convex_hull Q + cone X"
	+ using decomposition_theorem_polyhedra by simp
	+ from this obtain Q X where QXcarr: "Q \<union> X \<subseteq> carrier_vec n"
	+ and finQX: "finite (Q \<union> X)" and Psum: "P = convex_hull Q + cone X" by auto
	+ from QXcarr have Qcarr: "convex_hull Q \<subseteq> carrier_vec n" by (simp add: convex_hull_carrier)
	+ from QXcarr have Xcarr: "cone X \<subseteq> carrier_vec n" by (simp add: gram_schmidt.cone_carrier)
	+ from Pbnd have Pcarr: "P \<subseteq> carrier_vec n" using Ppolyh unfolding polyhedron_def by simp
	+ have "P = convex_hull Q"
	+ proof(cases "Q = {}")
	+ case True
	+ then show "P = convex_hull Q" unfolding Psum by (auto simp: set_plus_def)
	+ next
	+ case False
	+ hence convnotempty: "convex_hull Q \<noteq> {}" using QXcarr by simp
	+ have Pbndex: "\<exists>bnd. P \<subseteq> Bounded_vec bnd" using Pbnd
	+ using QXcarr by auto
	+ from False have "(\<exists> bndc. cone X \<subseteq> Bounded_vec bndc)"
	+ using bounded_vecset_sum[OF Qcarr Xcarr Psum Pbndex] False convnotempty by blast
	+ hence "cone X = {0\<^sub>v n}" using bounded_cone_is_zero QXcarr by auto
	+ thus ?thesis unfolding Psum using Qcarr by (auto simp: add_0_right_vecset)
	+ qed
	+ thus "polytope P" using finQX QXcarr unfolding polytope_def by auto
	+qed
	+end
	+
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Dim_Span.thy b/thys/Linear_Inequalities/Dim_Span.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Dim_Span.thy
	@@ -0,0 +1,144 @@
	+section \<open>Dimension of Spans\<close>
	+
	+text \<open>We define the notion of dimension of a span of vectors and prove some natural results about them.
	+ The definition is made as a function, so that no interpretation of locales like subspace is required.\<close>
	+theory Dim_Span
	+ imports Missing_VS_Connect
	+begin
	+
	+context vec_space
	+begin
	+definition "dim_span W = Max (card ` {V. V \<subseteq> carrier_vec n \<and> V \<subseteq> span W \<and> lin_indpt V})"
	+
	+lemma fixes V W :: "'a vec set"
	+ shows
	+ card_le_dim_span:
	+ "V \<subseteq> carrier_vec n \<Longrightarrow> V \<subseteq> span W \<Longrightarrow> lin_indpt V \<Longrightarrow> card V \<le> dim_span W" and
	+ card_eq_dim_span_imp_same_span:
	+ "W \<subseteq> carrier_vec n \<Longrightarrow> V \<subseteq> span W \<Longrightarrow> lin_indpt V \<Longrightarrow> card V = dim_span W \<Longrightarrow> span V = span W" and
	+ same_span_imp_card_eq_dim_span:
	+ "V \<subseteq> carrier_vec n \<Longrightarrow> W \<subseteq> carrier_vec n \<Longrightarrow> span V = span W \<Longrightarrow> lin_indpt V \<Longrightarrow> card V = dim_span W" and
	+ dim_span_cong:
	+ "span V = span W \<Longrightarrow> dim_span V = dim_span W" and
	+ ex_basis_span:
	+ "V \<subseteq> carrier_vec n \<Longrightarrow> \<exists> W. W \<subseteq> carrier_vec n \<and> lin_indpt W \<and> span V = span W \<and> dim_span V = card W"
	+proof -
	+ show cong: "\<And> V W. span V = span W \<Longrightarrow> dim_span V = dim_span W" unfolding dim_span_def by auto
	+ {
	+ fix W :: "'a vec set"
	+ let ?M = "{V. V \<subseteq> carrier_vec n \<and> V \<subseteq> span W \<and> lin_indpt V}"
	+ have "card ` ?M \<subseteq> {0 .. n}"
	+ proof
	+ fix k
	+ assume "k \<in> card ` ?M"
	+ then obtain V where V: "V \<subseteq> carrier_vec n \<and> V \<subseteq> span W \<and> lin_indpt V"
	+ and k: "k = card V"
	+ by auto
	+ from V have "card V \<le> n" using dim_is_n li_le_dim by auto
	+ with k show "k \<in> {0 .. n}" by auto
	+ qed
	+ from finite_subset[OF this]
	+ have fin: "finite (card ` ?M)" by auto
	+ have "{} \<in> ?M" by (auto simp: span_empty span_zero)
	+ from imageI[OF this, of card]
	+ have "0 \<in> card ` ?M" by auto
	+ hence Mempty: "card ` ?M \<noteq> {}" by auto
	+ from Max_ge[OF fin, folded dim_span_def]
	+ show "\<And> V :: 'a vec set. V \<subseteq> carrier_vec n \<Longrightarrow> V \<subseteq> span W \<Longrightarrow> lin_indpt V \<Longrightarrow> card V \<le> dim_span W"
	+ by auto
	+ note this fin Mempty
	+ } note part1 = this
	+ {
	+ fix V W :: "'a vec set"
	+ assume W: "W \<subseteq> carrier_vec n"
	+ and VsW: "V \<subseteq> span W" and linV: "lin_indpt V" and card: "card V = dim_span W"
	+ from W VsW have V: "V \<subseteq> carrier_vec n" using span_mem[OF W] by auto
	+ from Max_in[OF part1(2,3), folded dim_span_def, of W]
	+ obtain WW where WW: "WW \<subseteq> carrier_vec n" "WW \<subseteq> span W" "lin_indpt WW"
	+ and id: "dim_span W = card WW" by auto
	+ show "span V = span W"
	+ proof (rule ccontr)
	+ from VsW V W have sub: "span V \<subseteq> span W" using span_subsetI by metis
	+ assume "span V \<noteq> span W"
	+ with sub obtain w where wW: "w \<in> span W" and wsV: "w \<notin> span V" by auto
	+ from wW W have w: "w \<in> carrier_vec n" by auto
	+ from linV V have finV: "finite V" using fin_dim fin_dim_li_fin by blast
	+ from wsV span_mem[OF V, of w] have wV: "w \<notin> V" by auto
	+ let ?X = "insert w V"
	+ have "card ?X = Suc (card V)" using wV finV by simp
	+ hence gt: "card ?X > dim_span W" unfolding card by simp
	+ have linX: "lin_indpt ?X" using lin_dep_iff_in_span[OF V linV w wV] wsV by auto
	+ have XW: "?X \<subseteq> span W" using wW VsW by auto
	+ from part1(1)[OF _ XW linX] w V have "card ?X \<le> dim_span W" by auto
	+ with gt show False by auto
	+ qed
	+ } note card_dim_span = this
	+ {
	+ fix V :: "'a vec set"
	+ assume V: "V \<subseteq> carrier_vec n"
	+ from Max_in[OF part1(2,3), folded dim_span_def, of V]
	+ obtain W where W: "W \<subseteq> carrier_vec n" "W \<subseteq> span V" "lin_indpt W"
	+ and idW: "card W = dim_span V" by auto
	+ show "\<exists> W. W \<subseteq> carrier_vec n \<and> lin_indpt W \<and> span V = span W \<and> dim_span V = card W"
	+ proof (intro exI[of _ W] conjI W idW[symmetric])
	+ from card_dim_span[OF V(1) W(2-3) idW] show "span V = span W" by auto
	+ qed
	+ }
	+ {
	+ fix V W
	+ assume V: "V \<subseteq> carrier_vec n"
	+ and W: "W \<subseteq> carrier_vec n"
	+ and span: "span V = span W"
	+ and lin: "lin_indpt V"
	+ from Max_in[OF part1(2,3), folded dim_span_def, of W]
	+ obtain WW where WW: "WW \<subseteq> carrier_vec n" "WW \<subseteq> span W" "lin_indpt WW"
	+ and idWW: "card WW = dim_span W" by auto
	+ from card_dim_span[OF W WW(2-3) idWW] span
	+ have spanWW: "span WW = span V" by auto
	+ from span have "V \<subseteq> span W" using span_mem[OF V] by auto
	+ from part1(1)[OF V this lin] have VW: "card V \<le> dim_span W" .
	+ have finWW: "finite WW" using WW by (simp add: fin_dim_li_fin)
	+ have finV: "finite V" using lin V by (simp add: fin_dim_li_fin)
	+ from replacement[OF finWW finV V WW(3) WW(2)[folded span], unfolded idWW]
	+ obtain C :: "'a vec set"
	+ where le: "int (card C) \<le> int (card V) - int (dim_span W)" by auto
	+ from le have "int (dim_span W) + int (card C) \<le> int (card V)" by linarith
	+ hence "dim_span W + card C \<le> card V" by linarith
	+ with VW show "card V = dim_span W" by auto
	+ }
	+qed
	+
	+lemma dim_span_le_n: assumes W: "W \<subseteq> carrier_vec n" shows "dim_span W \<le> n"
	+proof -
	+ from ex_basis_span[OF W] obtain V where
	+ V: "V \<subseteq> carrier_vec n"
	+ and lin: "lin_indpt V"
	+ and dim: "dim_span W = card V"
	+ by auto
	+ show ?thesis unfolding dim using lin V
	+ using dim_is_n li_le_dim by auto
	+qed
	+
	+lemma dim_span_insert: assumes W: "W \<subseteq> carrier_vec n"
	+ and v: "v \<in> carrier_vec n" and vs: "v \<notin> span W"
	+shows "dim_span (insert v W) = Suc (dim_span W)"
	+proof -
	+ from ex_basis_span[OF W] obtain V where
	+ V: "V \<subseteq> carrier_vec n"
	+ and lin: "lin_indpt V"
	+ and span: "span W = span V"
	+ and dim: "dim_span W = card V"
	+ by auto
	+ from V vs[unfolded span] have vV: "v \<notin> V" using span_mem[OF V] by blast
	+ from lin_dep_iff_in_span[OF V lin v vV] vs span
	+ have lin': "lin_indpt (insert v V)" by auto
	+ have finV: "finite V" using lin V using fin_dim fin_dim_li_fin by blast
	+ have "card (insert v V) = Suc (card V)" using finV vV by auto
	+ hence cvV: "card (insert v V) = Suc (dim_span W)" using dim by auto
	+ have "span (insert v V) = span (insert v W)"
	+ using span V W v by (metis bot_least insert_subset insert_union span_union_is_sum)
	+ from same_span_imp_card_eq_dim_span[OF _ _ this lin'] cvV v V W
	+ show ?thesis by auto
	+qed
	+end
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Farkas_Lemma.thy b/thys/Linear_Inequalities/Farkas_Lemma.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Farkas_Lemma.thy
	@@ -0,0 +1,162 @@
	+section \<open>Farkas' Lemma\<close>
	+
	+text \<open>We prove two variants of Farkas' lemma. Note that type here is more general than in the versions
	+ of Farkas' Lemma which are in the AFP-entry Farkas-Lemma, which is restricted to rational matrices.
	+ However, there $\delta$-rationals are supported, which are not present here.\<close>
	+
	+theory Farkas_Lemma
	+ imports Fundamental_Theorem_Linear_Inequalities
	+begin
	+
	+context gram_schmidt
	+begin
	+
	+lemma Farkas_Lemma: fixes A :: "'a mat" and b :: "'a vec"
	+ assumes A: "A \<in> carrier_mat n nr" and b: "b \<in> carrier_vec n"
	+ shows "(\<exists> x. x \<ge> 0\<^sub>v nr \<and> A \<^sub>v x = b) \<longleftrightarrow> (\<forall> y. y \<in> carrier_vec n \<longrightarrow> A\<^sup>T \<^sub>v y \<ge> 0\<^sub>v nr \<longrightarrow> y \<bullet> b \<ge> 0)"
	+proof -
	+ let ?C = "set (cols A)"
	+ from A have C: "?C \<subseteq> carrier_vec n" and C': " \<forall>w\<in>set (cols A). dim_vec w = n"
	+ unfolding cols_def by auto
	+ have "(\<exists> x. x \<ge> 0\<^sub>v nr \<and> A *\<^sub>v x = b) = (b \<in> cone ?C)"
	+ using cone_of_cols[OF A b] by simp
	+ also have "\<dots> = (\<nexists>y. y \<in> carrier_vec n \<and> (\<forall>a\<^sub>i\<in>?C. 0 \<le> y \<bullet> a\<^sub>i) \<and> y \<bullet> b < 0)"
	+ unfolding fundamental_theorem_of_linear_inequalities(3)[OF C finite_set] mem_Collect_eq
	+ using b by auto
	+ also have "\<dots> = (\<forall>y. y \<in> carrier_vec n \<longrightarrow> (\<forall>a\<^sub>i\<in>?C. 0 \<le> y \<bullet> a\<^sub>i) \<longrightarrow> y \<bullet> b \<ge> 0)"
	+ by auto
	+ also have "\<dots> = (\<forall> y. y \<in> carrier_vec n \<longrightarrow> A\<^sup>T *\<^sub>v y \<ge> 0\<^sub>v nr \<longrightarrow> y \<bullet> b \<ge> 0)"
	+ proof (intro all_cong imp_cong refl)
	+ fix y :: "'a vec"
	+ assume y: "y \<in> carrier_vec n"
	+ have "(\<forall>a\<^sub>i\<in> ?C. 0 \<le> y \<bullet> a\<^sub>i) = (\<forall>a\<^sub>i\<in> ?C. 0 \<le> a\<^sub>i \<bullet> y)"
	+ by (intro ball_cong[OF refl], subst comm_scalar_prod[OF y], insert C, auto)
	+ also have "\<dots> = (0\<^sub>v nr \<le> A\<^sup>T *\<^sub>v y)"
	+ unfolding less_eq_vec_def using C A y by (auto simp: cols_def)
	+ finally show "(\<forall>a\<^sub>i\<in>set (cols A). 0 \<le> y \<bullet> a\<^sub>i) = (0\<^sub>v nr \<le> A\<^sup>T *\<^sub>v y)" .
	+ qed
	+ finally show ?thesis .
	+qed
	+
	+lemma Farkas_Lemma':
	+ fixes A :: "'a mat" and b :: "'a vec"
	+ assumes A: "A \<in> carrier_mat nr nc" and b: "b\<in> carrier_vec nr"
	+ shows "(\<exists>x. x\<in> carrier_vec nc \<and> A *\<^sub>v x \<le> b)
	+ \<longleftrightarrow> (\<forall>y. y \<ge> 0\<^sub>v nr \<and> A\<^sup>T *\<^sub>v y = 0\<^sub>v nc \<longrightarrow> y \<bullet> b \<ge> 0)"
	+proof -
	+ define B where "B = (1\<^sub>m nr) @\<^sub>c (A @\<^sub>c -A)"
	+ define b' where "b' = 0\<^sub>v nc @\<^sub>v (b @\<^sub>v -b)"
	+ define n where "n = nr + (nc + nc)"
	+ have id0: "0\<^sub>v (nr + (nc + nc)) = 0\<^sub>v nr @\<^sub>v (0\<^sub>v nc @\<^sub>v 0\<^sub>v nc)" by (intro eq_vecI, auto)
	+ have idcarr: "(1\<^sub>m nr) \<in> carrier_mat nr nr" by auto
	+ have B: "B \<in> carrier_mat nr n" unfolding B_def n_def using A by auto
	+ have "(\<exists>x \<in> carrier_vec nc. A *\<^sub>v x \<le> b) =
	+ (\<exists>x1 \<in> carrier_vec nr. \<exists>x2 \<in> carrier_vec nc. \<exists>x3 \<in> carrier_vec nc.
	+ x1 \<ge> 0\<^sub>v nr \<and> x2 \<ge> 0\<^sub>v nc \<and> x3 \<ge> 0\<^sub>v nc \<and> B *\<^sub>v (x1 @\<^sub>v (x2 @\<^sub>v x3)) = b)"
	+ proof
	+ assume "\<exists>x\<in>carrier_vec nc. A *\<^sub>v x \<le> b"
	+ from this obtain x where Axb: "A *\<^sub>v x \<le> b" and xcarr: "x \<in> carrier_vec nc" by auto
	+ have bmAx: "b - A *\<^sub>v x \<in> carrier_vec nr" using A b xcarr by simp
	+ define x1 where "x1 = b - A *\<^sub>v x"
	+ have x1: "x1 \<in> carrier_vec nr" using bmAx unfolding x1_def by (simp add: xcarr)
	+ define x2 where "x2 = vec (dim_vec x) (\<lambda>i. if x $ i \<ge> 0 then x $ i else 0)"
	+ have x2: "x2 \<in> carrier_vec nc" using xcarr unfolding x2_def by simp
	+ define x3 where "x3 = vec (dim_vec x) (\<lambda>i. if x $ i < 0 then -x $ i else 0)"
	+ have x3: "x3 \<in> carrier_vec nc" using xcarr unfolding x3_def by simp
	+ have x2x3carr: "x2 @\<^sub>v x3 \<in> carrier_vec (nc + nc)" using x2 x3 by simp
	+ have x2x3x: "x2 - x3 = x" unfolding x2_def x3_def by auto
	+ have "A *\<^sub>v x -b \<le> 0\<^sub>v nr" using vec_le_iff_diff_le_0 b
	+ by (metis A Axb carrier_matD(1) dim_mult_mat_vec)
	+ hence x1lez: "x1 \<ge> 0\<^sub>v nr" using x1 unfolding x1_def
	+ by (smt A Axb carrier_matD(1) carrier_vecD diff_ge_0_iff_ge dim_mult_mat_vec
	+ index_minus_vec(1) index_zero_vec(1) index_zero_vec(2) less_eq_vec_def)
	+ have x2lez: "x2 \<ge> 0\<^sub>v nc" using x2 less_eq_vec_def unfolding x2_def by fastforce
	+ have x3lez: "x3 \<ge> 0\<^sub>v nc" using x3 less_eq_vec_def unfolding x3_def by fastforce
	+ have B1: "(1\<^sub>m nr) \<^sub>v x1 = b - A \<^sub>v x" using xcarr x1 unfolding x1_def by simp
	+ have "A \<^sub>v x2 + (-A) \<^sub>v x3 = A \<^sub>v x2 + A \<^sub>v (-x3)" using x2 x3 A by auto
	+ also have "\<dots> = A *\<^sub>v (x2 + (-x3))" using A x2 x3
	+ by (metis mult_add_distrib_mat_vec uminus_carrier_vec)
	+ also have "\<dots> = A *\<^sub>v x" using x2x3x minus_add_uminus_vec x2 x3 by fastforce
	+ finally have B2:"A \<^sub>v x2 + (-A) \<^sub>v x3 = A *\<^sub>v x" by auto
	+ have "B \<^sub>v (x1 @\<^sub>v (x2 @\<^sub>v x3)) = (1\<^sub>m nr) \<^sub>v x1 + (A \<^sub>v x2 + (-A) \<^sub>v x3)" (is "\<dots> = ?p1 + ?p2")
	+ using x1 x2 x3 A mat_mult_append_cols unfolding B_def
	+ by (subst mat_mult_append_cols[OF _ _ x1 x2x3carr], auto simp add: mat_mult_append_cols)
	+ also have "?p1 = b - A *\<^sub>v x" using B1 unfolding x1_def by auto
	+ also have "?p2 = A *\<^sub>v x" using B2 by simp
	+ finally have res: "B *\<^sub>v (x1 @\<^sub>v (x2 @\<^sub>v x3)) = b" using A xcarr b by auto
	+ show "\<exists>x\<in>carrier_vec nc. A *\<^sub>v x \<le> b \<Longrightarrow> \<exists>x1\<in>carrier_vec nr. \<exists>x2\<in>carrier_vec nc. \<exists>x3\<in>carrier_vec nc.
	+ 0\<^sub>v nr \<le> x1 \<and> 0\<^sub>v nc \<le> x2 \<and> 0\<^sub>v nc \<le> x3 \<and> B *\<^sub>v (x1 @\<^sub>v x2 @\<^sub>v x3) = b"
	+ using x1 x2 x3 x1lez x2lez x3lez res by auto
	+ next
	+ assume "\<exists>x1 \<in> carrier_vec nr. \<exists>x2 \<in> carrier_vec nc. \<exists>x3 \<in> carrier_vec nc.
	+ x1 \<ge> 0\<^sub>v nr \<and> x2 \<ge> 0\<^sub>v nc \<and> x3 \<ge> 0\<^sub>v nc \<and> B *\<^sub>v (x1 @\<^sub>v (x2 @\<^sub>v x3)) = b"
	+ from this obtain x1 x2 x3 where x1: "x1 \<in> carrier_vec nr" and x1lez: "x1 \<ge> 0\<^sub>v nr"
	+ and x2: "x2 \<in> carrier_vec nc" and x2lez: "x2 \<ge> 0\<^sub>v nc"
	+ and x3: "x3 \<in> carrier_vec nc" and x3lez: "x3 \<ge> 0\<^sub>v nc"
	+ and clc: "B *\<^sub>v (x1 @\<^sub>v (x2 @\<^sub>v x3)) = b" by auto
	+ have x2x3carr: "x2 @\<^sub>v x3 \<in> carrier_vec (nc + nc)" using x2 x3 by simp
	+ define x where "x = x2 - x3"
	+ have xcarr: "x \<in> carrier_vec nc" using x2 x3 unfolding x_def by simp
	+ have "A \<^sub>v x2 + (-A) \<^sub>v x3 = A \<^sub>v x2 + A \<^sub>v (-x3)" using x2 x3 A by auto
	+ also have "\<dots> = A *\<^sub>v (x2 + (-x3))" using A x2 x3
	+ by (metis mult_add_distrib_mat_vec uminus_carrier_vec)
	+ also have "\<dots> = A *\<^sub>v x" using minus_add_uminus_vec x2 x3 unfolding x_def by fastforce
	+ finally have B2:"A \<^sub>v x2 + (-A) \<^sub>v x3 = A *\<^sub>v x" by auto
	+ have Axcarr: "A *\<^sub>v x \<in> carrier_vec nr" using A xcarr by auto
	+ have "b = B *\<^sub>v (x1 @\<^sub>v (x2 @\<^sub>v x3))" using clc by auto
	+ also have "\<dots> = (1\<^sub>m nr) \<^sub>v x1 + (A \<^sub>v x2 + (-A) *\<^sub>v x3)" (is "\<dots> = ?p1 + ?p2")
	+ using x1 x2 x3 A mat_mult_append_cols unfolding B_def
	+ by (subst mat_mult_append_cols[OF _ _ x1 x2x3carr], auto simp add: mat_mult_append_cols)
	+ also have "?p2 = A *\<^sub>v x" using B2 by simp
	+ finally have res: "b = (1\<^sub>m nr) \<^sub>v x1 + A \<^sub>v x" using A xcarr b by auto
	+ hence "b = x1 + A *\<^sub>v x" using x1 A b by simp
	+ hence "b - A *\<^sub>v x = x1" using x1 A b by auto
	+ hence "b - A *\<^sub>v x \<ge> 0\<^sub>v nr" using x1lez by auto
	+ hence "A *\<^sub>v x \<le> b" using Axcarr
	+ by (smt \<open>b - A \<^sub>v x = x1\<close> \<open>b = x1 + A \<^sub>v x\<close> carrier_vecD comm_add_vec index_zero_vec(2)
	+ minus_add_minus_vec minus_cancel_vec vec_le_iff_diff_le_0 x1)
	+ then show "\<exists>x1\<in>carrier_vec nr. \<exists>x2\<in>carrier_vec nc. \<exists>x3\<in>carrier_vec nc.
	+ 0\<^sub>v nr \<le> x1 \<and> 0\<^sub>v nc \<le> x2 \<and> 0\<^sub>v nc \<le> x3 \<and> B *\<^sub>v (x1 @\<^sub>v x2 @\<^sub>v x3) = b \<Longrightarrow>
	+ \<exists>x\<in>carrier_vec nc. A *\<^sub>v x \<le> b" using xcarr by blast
	+ qed
	+ also have "\<dots> = (\<exists>x1 \<in> carrier_vec nr. \<exists>x2 \<in> carrier_vec nc. \<exists>x3 \<in> carrier_vec nc.
	+ (x1 @\<^sub>v (x2 @\<^sub>v x3)) \<ge> 0\<^sub>v n \<and> B *\<^sub>v (x1 @\<^sub>v (x2 @\<^sub>v x3)) = b)"
	+ by (metis append_vec_le id0 n_def zero_carrier_vec)
	+ also have "\<dots> = (\<exists>x \<in> carrier_vec n. x \<ge> 0\<^sub>v n \<and> B *\<^sub>v x = b)"
	+ unfolding n_def exists_vec_append by auto
	+ also have "\<dots> = (\<exists>x \<ge> 0\<^sub>v n. B *\<^sub>v x = b)" unfolding less_eq_vec_def by fastforce
	+ also have "\<dots> = (\<forall> y. y \<in> carrier_vec nr \<longrightarrow> B\<^sup>T *\<^sub>v y \<ge> 0\<^sub>v n \<longrightarrow> y \<bullet> b \<ge> 0)"
	+ by (rule gram_schmidt.Farkas_Lemma[OF B b])
	+ also have "\<dots> = (\<forall> y. y \<in> carrier_vec nr \<longrightarrow> (y \<ge> 0\<^sub>v nr \<and> A\<^sup>T *\<^sub>v y = 0\<^sub>v nc) \<longrightarrow> y \<bullet> b \<ge> 0)"
	+ proof (intro all_cong imp_cong refl)
	+ fix y :: "'a vec"
	+ assume y: "y \<in> carrier_vec nr"
	+ have idtcarr: "(1\<^sub>m nr)\<^sup>T \<in> carrier_mat nr nr" by auto
	+ have Atcarr: "A\<^sup>T \<in> carrier_mat nc nr" using A by auto
	+ have mAtcarr: "(-A)\<^sup>T \<in> carrier_mat nc nr" using A by auto
	+ have AtAtcarr: "A\<^sup>T @\<^sub>r (-A)\<^sup>T \<in> carrier_mat (nc + nc) nr" using A by auto
	+ have "B\<^sup>T \<^sub>v y = ((1\<^sub>m nr)\<^sup>T @\<^sub>r A\<^sup>T @\<^sub>r (-A)\<^sup>T) \<^sub>v y" unfolding B_def
	+ by (simp add: append_cols_def)
	+ also have "\<dots> = ((1\<^sub>m nr)\<^sup>T \<^sub>v y) @\<^sub>v (A\<^sup>T \<^sub>v y) @\<^sub>v ((-A)\<^sup>T *\<^sub>v y)"
	+ using mat_mult_append[OF Atcarr mAtcarr y] mat_mult_append y Atcarr idtcarr mAtcarr
	+ by (metis AtAtcarr)
	+ finally have eq: "B\<^sup>T \<^sub>v y = ((1\<^sub>m nr)\<^sup>T \<^sub>v y) @\<^sub>v (A\<^sup>T \<^sub>v y) @\<^sub>v ((-A)\<^sup>T \<^sub>v y)" by auto
	+ have "(B\<^sup>T \<^sub>v y \<ge> 0\<^sub>v n) = (0\<^sub>v n \<le> (1\<^sub>m nr)\<^sup>T \<^sub>v y @\<^sub>v A\<^sup>T \<^sub>v y @\<^sub>v (- A)\<^sup>T \<^sub>v y)" unfolding eq by simp
	+ also have "\<dots> = (((1\<^sub>m nr)\<^sup>T \<^sub>v y) @\<^sub>v (A\<^sup>T \<^sub>v y) @\<^sub>v ((-A)\<^sup>T *\<^sub>v y) \<ge> 0\<^sub>v nr @\<^sub>v 0\<^sub>v nc @\<^sub>v 0\<^sub>v nc)"
	+ using id0 by (metis eq n_def)
	+ also have "\<dots> = (y \<ge> 0\<^sub>v nr \<and> A\<^sup>T \<^sub>v y \<ge> 0\<^sub>v nc \<and> ((-A)\<^sup>T \<^sub>v y) \<ge> 0\<^sub>v nc)"
	+ by (metis Atcarr append_vec_le mult_mat_vec_carrier one_mult_mat_vec transpose_one y zero_carrier_vec)
	+ also have "\<dots> = (y \<ge> 0\<^sub>v nr \<and>A\<^sup>T \<^sub>v y \<ge> 0\<^sub>v nc \<and> -(A\<^sup>T \<^sub>v y) \<ge> 0\<^sub>v nc)"
	+ by (metis A Atcarr carrier_matD(2) carrier_vecD transpose_uminus uminus_mult_mat_vec y)
	+ also have "\<dots> = (y \<ge> 0\<^sub>v nr \<and>A\<^sup>T \<^sub>v y \<ge> 0\<^sub>v nc \<and> (A\<^sup>T \<^sub>v y) \<le> 0\<^sub>v nc)"
	+ by (metis (mono_tags, lifting) A Atcarr carrier_matD(2) carrier_vecD index_zero_vec(2)
	+ mAtcarr mult_mat_vec_carrier transpose_uminus uminus_mult_mat_vec uminus_uminus_vec
	+ vec_le_iff_diff_le_0 y zero_minus_vec)
	+ also have "\<dots> = (y \<ge> 0\<^sub>v nr \<and> A\<^sup>T *\<^sub>v y = 0\<^sub>v nc)" by auto
	+ finally show "(B\<^sup>T \<^sub>v y \<ge> 0\<^sub>v n) = (y \<ge> 0\<^sub>v nr \<and> A\<^sup>T \<^sub>v y = 0\<^sub>v nc)" .
	+ qed
	+ finally show ?thesis by (auto simp: less_eq_vec_def)
	+qed
	+
	+end
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Farkas_Minkowsky_Weyl.thy b/thys/Linear_Inequalities/Farkas_Minkowsky_Weyl.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Farkas_Minkowsky_Weyl.thy
	@@ -0,0 +1,323 @@
	+section \<open>The Theorem of Farkas, Minkowsky and Weyl\<close>
	+
	+text \<open>We prove the theorem of Farkas, Minkowsky and Weyl that a cone is finitely generated
	+ iff it is polyhedral. Moreover, we provide quantative bounds.\<close>
	+
	+theory Farkas_Minkowsky_Weyl
	+ imports Fundamental_Theorem_Linear_Inequalities
	+begin
	+
	+context gram_schmidt
	+begin
	+
	+text \<open>We first prove the one direction of the theorem
	+ for the case that the span of the vectors is the full n-dimensional space.\<close>
	+
	+lemma farkas_minkowsky_weyl_theorem_1_full_dim:
	+ assumes X: "X \<subseteq> carrier_vec n"
	+ and fin: "finite X"
	+ and span: "span X = carrier_vec n"
	+ shows "\<exists> nr A. A \<in> carrier_mat nr n \<and> cone X = polyhedral_cone A
	+ \<and> (X \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd \<longrightarrow> A \<in> \<int>\<^sub>m \<inter> Bounded_mat (det_bound (n-1) Bnd))"
	+proof -
	+ define cond where "cond = (\<lambda> W. Suc (card W) = n \<and> lin_indpt W \<and> W \<subseteq> X)"
	+ {
	+ fix W
	+ assume "cond W"
	+ hence *: "finite W" "Suc (card W) = n" "lin_indpt W" "W \<subseteq> carrier_vec n" and WX: "W \<subseteq> X" unfolding cond_def
	+ using finite_subset[OF _ fin] X by auto
	+ note nv = normal_vector[OF *]
	+ hence "normal_vector W \<in> carrier_vec n" "\<And> w. w \<in> W \<Longrightarrow> normal_vector W \<bullet> w = 0"
	+ "normal_vector W \<noteq> 0\<^sub>v n" "X \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd \<Longrightarrow> normal_vector W \<in> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n - 1) Bnd)"
	+ using WX by blast+
	+ } note condD = this
	+ define Ns where "Ns = { normal_vector W \| W. cond W \<and> (\<forall> w \<in> X. normal_vector W \<bullet> w \<ge> 0) }
	+ \<union> { - normal_vector W \| W. cond W \<and> (\<forall> w \<in> X. (- normal_vector W) \<bullet> w \<ge> 0)}"
	+ have "Ns \<subseteq> normal_vector ` {W . W \<subseteq> X} \<union> (\<lambda> W. - normal_vector W) ` {W. W \<subseteq> X}" unfolding Ns_def cond_def by blast
	+ moreover have "finite \<dots>" using \<open>finite X\<close> by auto
	+ ultimately have "finite Ns" by (metis finite_subset)
	+ from finite_list[OF this] obtain ns where ns: "set ns = Ns" by auto
	+ have Ns: "Ns \<subseteq> carrier_vec n" unfolding Ns_def using condD by auto
	+ define A where "A = mat_of_rows n ns"
	+ define nr where "nr = length ns"
	+ have A: "- A \<in> carrier_mat nr n" unfolding A_def nr_def by auto
	+ show ?thesis
	+ proof (intro exI conjI impI, rule A)
	+ have not_conj: "\<not> (a \<and> b) \<longleftrightarrow> (a \<longrightarrow> \<not> b)" for a b by auto
	+ have id: "Ns = { nv . \<exists> W. W \<subseteq> X \<and> nv \<in> {normal_vector W, - normal_vector W} \<and>
	+ Suc (card W) = n \<and> lin_indpt W \<and> (\<forall>a\<^sub>i\<in>X. 0 \<le> nv \<bullet> a\<^sub>i)}"
	+ unfolding Ns_def cond_def by auto
	+ have "polyhedral_cone (- A) = { b. b \<in> carrier_vec n \<and> (- A) *\<^sub>v b \<le> 0\<^sub>v nr}" unfolding polyhedral_cone_def
	+ using A by auto
	+ also have "\<dots> = {b. b \<in> carrier_vec n \<and> (\<forall> i < nr. row (- A) i \<bullet> b \<le> 0)}"
	+ unfolding less_eq_vec_def using A by auto
	+ also have "\<dots> = {b. b \<in> carrier_vec n \<and> (\<forall> i < nr. - (ns ! i) \<bullet> b \<le> 0)}" using A Ns[folded ns]
	+ by (intro Collect_cong conj_cong refl all_cong arg_cong[of _ _ "\<lambda> x. x \<bullet> _ \<le> _"],
	+ force simp: A_def mat_of_rows_def nr_def set_conv_nth)
	+ also have "\<dots> = {b. b \<in> carrier_vec n \<and> (\<forall> n \<in> Ns. - n \<bullet> b \<le> 0)}"
	+ unfolding ns[symmetric] nr_def by (auto simp: set_conv_nth)
	+ also have "\<dots> = {b. b \<in> carrier_vec n \<and> (\<forall> n \<in> Ns. n \<bullet> b \<ge> 0)}"
	+ by (intro Collect_cong conj_cong refl ball_cong, insert Ns, auto)
	+ also have "\<dots> = cone X"
	+ unfolding fundamental_theorem_of_linear_inequalities_full_dim(2)[OF X fin span]
	+ by (intro Collect_cong conj_cong refl, unfold not_le[symmetric] not_ex not_conj not_not id, blast)
	+ finally show "cone X = polyhedral_cone (- A)" ..
	+ {
	+ assume XI: "X \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd"
	+ {
	+ fix v
	+ assume "v \<in> set (rows (- A))"
	+ hence "-v \<in> set (rows A)" unfolding rows_def by auto
	+ hence "-v \<in> Ns" unfolding A_def using ns Ns by auto
	+ from this[unfolded Ns_def] obtain W where cW: "cond W"
	+ and v: "-v = normal_vector W \<or> v = normal_vector W" by auto
	+ from cW[unfolded cond_def] have WX: "W \<subseteq> X" by auto
	+ from v have v: "v = normal_vector W \<or> v = - normal_vector W"
	+ by (metis uminus_uminus_vec)
	+ from condD(4)[OF cW XI]
	+ have "normal_vector W \<in> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n - 1) Bnd)" by auto
	+ hence "v \<in> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n - 1) Bnd)" using v by auto
	+ }
	+ hence "set (rows (- A)) \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n - 1) Bnd)" by blast
	+ thus "- A \<in> \<int>\<^sub>m \<inter> Bounded_mat (det_bound (n - 1) Bnd)" by simp
	+ }
	+ qed
	+qed
	+
	+text \<open>We next generalize the theorem to the case where X does not span the full space.
	+ To this end, we extend X by unit-vectors until the full space is spanned, and then
	+ add the normal-vectors of these unit-vectors which are orthogonal to span X as additional
	+ constraints to the resulting matrix.\<close>
	+lemma farkas_minkowsky_weyl_theorem_1:
	+ assumes X: "X \<subseteq> carrier_vec n"
	+ and finX: "finite X"
	+ shows "\<exists> nr A. A \<in> carrier_mat nr n \<and> cone X = polyhedral_cone A \<and>
	+ (X \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd \<longrightarrow> A \<in> \<int>\<^sub>m \<inter> Bounded_mat (det_bound (n-1) (max 1 Bnd)))"
	+proof -
	+ from exists_lin_indpt_sublist[OF X]
	+ obtain Ls where lin_Ls: "lin_indpt_list Ls" and
	+ spanL: "span (set Ls) = span X" and LX: "set Ls \<subseteq> X" by auto
	+ define Ns where "Ns = normal_vectors Ls"
	+ define Bs where "Bs = basis_extension Ls"
	+ from basis_extension[OF lin_Ls, folded Bs_def]
	+ have BU: "set Bs \<subseteq> set (unit_vecs n)"
	+ and lin_Ls_Bs: "lin_indpt_list (Ls @ Bs)"
	+ and len_Ls_Bs: "length (Ls @ Bs) = n"
	+ by auto
	+ note nv = normal_vectors[OF lin_Ls, folded Ns_def]
	+ from nv(1-6) nv(7)[of Bnd]
	+ have N: "set Ns \<subseteq> carrier_vec n"
	+ and LN': "lin_indpt_list (Ls @ Ns)" "length (Ls @ Ns) = n"
	+ and ortho: "\<And> l w. l \<in> set Ls \<Longrightarrow> w \<in> set Ns \<Longrightarrow> w \<bullet> l = 0"
	+ and Ns_bnd: "set Ls \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd
	+ \<Longrightarrow> set Ns \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n-1) (max 1 Bnd))"
	+ by auto
	+ from lin_indpt_list_length_eq_n[OF LN']
	+ have spanLN: "span (set Ls \<union> set Ns) = carrier_vec n" by auto
	+ let ?Bnd = "Bounded_vec (det_bound (n-1) (max 1 Bnd))"
	+ let ?Bndm = "Bounded_mat (det_bound (n-1) (max 1 Bnd))"
	+ define Y where "Y = X \<union> set Bs"
	+ from lin_Ls_Bs[unfolded lin_indpt_list_def] have
	+ Ls: "set Ls \<subseteq> carrier_vec n" and
	+ Bs: "set Bs \<subseteq> carrier_vec n" and
	+ distLsBs: "distinct (Ls @ Bs)" and
	+ lin': "lin_indpt (set (Ls @ Bs))" by auto
	+ have LN: "set Ls \<inter> set Ns = {}"
	+ proof (rule ccontr)
	+ assume "\<not> ?thesis"
	+ then obtain x where xX: "x \<in> set Ls" and xW: "x \<in> set Ns" by auto
	+ from ortho[OF xX xW] have "x \<bullet> x = 0" by auto
	+ hence "sq_norm x = 0" by (auto simp: sq_norm_vec_as_cscalar_prod)
	+ with xX LX X have "x = 0\<^sub>v n" by auto
	+ with vs_zero_lin_dep[OF _ lin'] Ls Bs xX show False by auto
	+ qed
	+ have Y: "Y \<subseteq> carrier_vec n" using X Bs unfolding Y_def by auto
	+ have CLB: "carrier_vec n = span (set (Ls @ Bs))"
	+ using lin_Ls_Bs len_Ls_Bs lin_indpt_list_length_eq_n by blast
	+ also have "\<dots> \<subseteq> span Y"
	+ by (rule span_is_monotone, insert LX, auto simp: Y_def)
	+ finally have span: "span Y = carrier_vec n" using Y by auto
	+ have finY: "finite Y" using finX unfolding Y_def by auto
	+ from farkas_minkowsky_weyl_theorem_1_full_dim[OF Y finY span]
	+ obtain A nr where A: "A \<in> carrier_mat nr n" and YA: "cone Y = polyhedral_cone A"
	+ and Y_Ints: "Y \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (max 1 Bnd) \<Longrightarrow> A \<in> \<int>\<^sub>m \<inter> ?Bndm" by blast
	+ have fin: "finite ({row A i \| i. i < nr} \<union> set Ns \<union> uminus ` set Ns)" by auto
	+ from finite_list[OF this] obtain rs where rs_def: "set rs = {row A i \|i. i < nr} \<union> set Ns \<union> uminus ` set Ns" by auto
	+ from A N have rs: "set rs \<subseteq> carrier_vec n" unfolding rs_def by auto
	+ let ?m = "length rs"
	+ define B where "B = mat_of_rows n rs"
	+ have B: "B \<in> carrier_mat ?m n" unfolding B_def by auto
	+ show ?thesis
	+ proof (intro exI conjI impI, rule B)
	+ have id: "(\<forall>r\<in>{rs ! i \|i. i < ?m}. P r) = (\<forall> r < ?m. P (rs ! r))" for P by auto
	+ have "polyhedral_cone B = { x \<in> carrier_vec n. B *\<^sub>v x \<le> 0\<^sub>v ?m}" unfolding polyhedral_cone_def
	+ using B by auto
	+ also have "\<dots> = { x \<in> carrier_vec n. \<forall> i < ?m. row B i \<bullet> x \<le> 0}"
	+ unfolding less_eq_vec_def using B by auto
	+ also have "\<dots> = { x \<in> carrier_vec n. \<forall> r \<in> set rs. r \<bullet> x \<le> 0}" using rs unfolding set_conv_nth id
	+ by (intro Collect_cong conj_cong refl all_cong arg_cong[of _ _ "\<lambda> x. x \<bullet> _ \<le> 0"], auto simp: B_def)
	+ also have "\<dots> = {x \<in> carrier_vec n. \<forall> i < nr. row A i \<bullet> x \<le> 0}
	+ \<inter> {x \<in> carrier_vec n. \<forall> w \<in> set Ns \<union> uminus ` set Ns. w \<bullet> x \<le> 0}"
	+ unfolding rs_def by blast
	+ also have "{x \<in> carrier_vec n. \<forall> i < nr. row A i \<bullet> x \<le> 0} = polyhedral_cone A"
	+ unfolding polyhedral_cone_def using A by (auto simp: less_eq_vec_def)
	+ also have "\<dots> = cone Y" unfolding YA ..
	+ also have "{x \<in> carrier_vec n. \<forall> w \<in> set Ns \<union> uminus ` set Ns. w \<bullet> x \<le> 0}
	+ = {x \<in> carrier_vec n. \<forall> w \<in> set Ns. w \<bullet> x = 0}"
	+ (is "?l = ?r")
	+ proof
	+ show "?r \<subseteq> ?l" using N by auto
	+ {
	+ fix x w
	+ assume "x \<in> ?l" "w \<in> set Ns"
	+ with N have x: "x \<in> carrier_vec n" and w: "w \<in> carrier_vec n"
	+ and one: "w \<bullet> x \<le> 0" and two: "(-w) \<bullet> x \<le> 0" by auto
	+ from two have "w \<bullet> x \<ge> 0"
	+ by (subst (asm) scalar_prod_uminus_left, insert w x, auto)
	+ with one have "w \<bullet> x = 0" by auto
	+ }
	+ thus "?l \<subseteq> ?r" by blast
	+ qed
	+ finally have "polyhedral_cone B = cone Y \<inter> {x \<in> carrier_vec n. \<forall>w\<in>set Ns. w \<bullet> x = 0}" .
	+ also have "\<dots> = cone X" unfolding Y_def
	+ by (rule orthogonal_cone(1)[OF X N finX spanLN ortho refl spanL LX lin_Ls_Bs len_Ls_Bs])
	+ finally show "cone X = polyhedral_cone B" ..
	+ assume X_I: "X \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd"
	+ with LX have "set Ls \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd" by auto
	+ from Ns_bnd[OF this] have N_I_Bnd: "set Ns \<subseteq> \<int>\<^sub>v \<inter> ?Bnd" by auto
	+ from lin_Ls_Bs have linLs: "lin_indpt_list Ls" unfolding lin_indpt_list_def
	+ using subset_li_is_li[of _ "set Ls"] by auto
	+ from X_I LX have L_I: "set Ls \<subseteq> \<int>\<^sub>v" by auto
	+ have Y_I: "Y \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (max 1 Bnd)" unfolding Y_def using X_I BU
	+ Bounded_vec_mono[of Bnd "max 1 Bnd"] by (auto simp: unit_vecs_def Ints_vec_def)
	+ from Y_Ints[OF Y_I]
	+ have A_I_Bnd: "set (rows A) \<subseteq> \<int>\<^sub>v \<inter> ?Bnd" by auto
	+ have "set (rows B) = set (rows (mat_of_rows n rs))" unfolding B_def by auto
	+ also have "\<dots> = set rs" using rs by auto
	+ also have "\<dots> = set (rows A) \<union> set Ns \<union> uminus ` set Ns" unfolding rs_def rows_def using A by auto
	+ also have "\<dots> \<subseteq> \<int>\<^sub>v \<inter> ?Bnd" using A_I_Bnd N_I_Bnd by auto
	+ finally show "B \<in> \<int>\<^sub>m \<inter> ?Bndm" by simp
	+ qed
	+qed
	+
	+text \<open>Now for the other direction.\<close>
	+
	+lemma farkas_minkowsky_weyl_theorem_2:
	+ assumes A: "A \<in> carrier_mat nr n"
	+ shows "\<exists> X. X \<subseteq> carrier_vec n \<and> finite X \<and> polyhedral_cone A = cone X
	+ \<and> (A \<in> \<int>\<^sub>m \<inter> Bounded_mat Bnd \<longrightarrow> X \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n-1) (max 1 Bnd)))"
	+proof -
	+ let ?rows_A = "{row A i \| i. i < nr}"
	+ let ?Bnd = "Bounded_vec (det_bound (n-1) (max 1 Bnd))"
	+ have rows_A_n: "?rows_A \<subseteq> carrier_vec n" using row_carrier_vec A by auto
	+ hence "\<exists> mr B. B \<in> carrier_mat mr n \<and> cone ?rows_A = polyhedral_cone B
	+ \<and> (?rows_A \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd \<longrightarrow> set (rows B) \<subseteq> \<int>\<^sub>v \<inter> ?Bnd)"
	+ using farkas_minkowsky_weyl_theorem_1[of ?rows_A] by auto
	+ then obtain mr B
	+ where mr: "B \<in> carrier_mat mr n" and B: "cone ?rows_A = polyhedral_cone B"
	+ and Bnd: "?rows_A \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd \<Longrightarrow> set (rows B) \<subseteq> \<int>\<^sub>v \<inter> ?Bnd"
	+ by blast
	+ let ?rows_B = "{row B i \| i. i < mr}"
	+ have rows_B: "?rows_B \<subseteq> carrier_vec n" using mr by auto
	+ have "cone ?rows_B = polyhedral_cone A"
	+ proof
	+ have "?rows_B \<subseteq> polyhedral_cone A"
	+ proof
	+ fix r
	+ assume "r \<in> ?rows_B"
	+ then obtain j where r: "r = row B j" and j: "j < mr" by auto
	+ then have rn: "r \<in> carrier_vec n" using mr row_carrier by auto
	+ moreover have "A *\<^sub>v r \<le> 0\<^sub>v nr" unfolding less_eq_vec_def
	+ proof (standard, unfold index_zero_vec)
	+ show "dim_vec (A *\<^sub>v r) = nr" using A by auto
	+ next
	+ show "\<forall>i< nr. (A *\<^sub>v r) $ i \<le> 0\<^sub>v nr $ i"
	+ proof (standard, rule impI)
	+ fix i
	+ assume i: "i < nr"
	+ then have "row A i \<in> ?rows_A" by auto
	+ then have "row A i \<in> cone ?rows_A"
	+ using set_in_cone rows_A_n by blast
	+ then have "row A i \<in> polyhedral_cone B" using B by auto
	+ then have Br: "B *\<^sub>v (row A i) \<le> 0\<^sub>v mr"
	+ unfolding polyhedral_cone_def using rows_A_n mr by auto
	+
	+ then have "(A *\<^sub>v r) $ i = (row A i) \<bullet> r" using A i index_mult_mat_vec by auto
	+ also have "\<dots> = r \<bullet> (row A i)"
	+ using comm_scalar_prod[OF _ rn] row_carrier A by auto
	+ also have "\<dots> = (row B j) \<bullet> (row A i)" using r by auto
	+ also have "\<dots> = (B *\<^sub>v (row A i)) $ j" using index_mult_mat_vec mr j by auto
	+ also have "\<dots> \<le> 0" using Br j unfolding less_eq_vec_def by auto
	+ also have "\<dots> = 0\<^sub>v nr $ i" using i by auto
	+ finally show "(A *\<^sub>v r) $ i \<le> 0\<^sub>v nr $ i" by auto
	+ qed
	+ qed
	+ then show "r \<in> polyhedral_cone A"
	+ unfolding polyhedral_cone_def
	+ using A rn by auto
	+ qed
	+ then show "cone ?rows_B \<subseteq> polyhedral_cone A"
	+ using cone_in_polyhedral_cone A by auto
	+
	+ next
	+
	+ show "polyhedral_cone A \<subseteq> cone ?rows_B"
	+ proof (rule ccontr)
	+ assume "\<not> polyhedral_cone A \<subseteq> cone ?rows_B"
	+ then obtain y where yA: "y \<in> polyhedral_cone A"
	+ and yB: "y \<notin> cone ?rows_B" by auto
	+ then have yn: "y \<in> carrier_vec n" unfolding polyhedral_cone_def by auto
	+ have finRB: "finite ?rows_B" by auto
	+ from farkas_minkowsky_weyl_theorem_1[OF rows_B finRB]
	+ obtain nr' A' where A': "A' \<in> carrier_mat nr' n" and cone: "cone ?rows_B = polyhedral_cone A'"
	+ by blast
	+ from yB[unfolded cone polyhedral_cone_def] yn A'
	+ have "\<not> (A' *\<^sub>v y \<le> 0\<^sub>v nr')" by auto
	+ then obtain i where i: "i < nr'" and "row A' i \<bullet> y > 0"
	+ unfolding less_eq_vec_def using A' yn by auto
	+ define w where "w = row A' i"
	+ have w: "w \<in> carrier_vec n" using i A' yn unfolding w_def by auto
	+ from \<open>row A' i \<bullet> y > 0\<close> comm_scalar_prod[OF w yn] have wy: "w \<bullet> y > 0" "y \<bullet> w > 0" unfolding w_def by auto
	+ {
	+ fix b
	+ assume "b \<in> ?rows_B"
	+ hence "b \<in> cone ?rows_B" using set_in_cone[OF rows_B] by auto
	+ from this[unfolded cone polyhedral_cone_def] A'
	+ have b: "b \<in> carrier_vec n" and "A' *\<^sub>v b \<le> 0\<^sub>v nr'" by auto
	+ from this(2)[unfolded less_eq_vec_def, THEN conjunct2, rule_format, of i]
	+ have "w \<bullet> b \<le> 0" unfolding w_def using i A' by auto
	+ hence "b \<bullet> w \<le> 0" using comm_scalar_prod[OF b w] by auto
	+ }
	+ hence wA: "w \<in> cone ?rows_A" unfolding B polyhedral_cone_def using mr w
	+ by (auto simp: less_eq_vec_def)
	+ from wy have yw: "-y \<bullet> w < 0"
	+ by (subst scalar_prod_uminus_left, insert yn w, auto)
	+ have "?rows_A \<subseteq> carrier_vec n" "finite ?rows_A" using assms by auto
	+ from fundamental_theorem_of_linear_inequalities_A_imp_D[OF this wA, unfolded not_ex,
	+ rule_format, of "-y" ] yn yw
	+ obtain i where i: "i < nr" and "- y \<bullet> row A i < 0" by auto
	+ hence "y \<bullet> row A i > 0" by (subst (asm) scalar_prod_uminus_left, insert i assms yn, auto)
	+ hence "row A i \<bullet> y > 0" using comm_scalar_prod[OF _ yn, of "row A i"] i assms yn by auto
	+ with yA show False unfolding polyhedral_cone_def less_eq_vec_def using i assms by auto
	+ qed
	+ qed
	+ moreover have "?rows_B \<subseteq> carrier_vec n"
	+ using row_carrier_vec mr by auto
	+ moreover have "finite ?rows_B" by auto
	+ moreover {
	+ have rA: "set (rows A) = ?rows_A" using A unfolding rows_def by auto
	+ have rB: "set (rows B) = ?rows_B" using mr unfolding rows_def by auto
	+ assume "A \<in> \<int>\<^sub>m \<inter> Bounded_mat Bnd"
	+ hence "set (rows A) \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd" by simp
	+ from Bnd[OF this[unfolded rA]]
	+ have "?rows_B \<subseteq> \<int>\<^sub>v \<inter> ?Bnd" unfolding rA rB .
	+ }
	+ ultimately show ?thesis by blast
	+qed
	+
	+lemma farkas_minkowsky_weyl_theorem:
	+ "(\<exists> X. X \<subseteq> carrier_vec n \<and> finite X \<and> P = cone X)
	+ \<longleftrightarrow> (\<exists> A nr. A \<in> carrier_mat nr n \<and> P = polyhedral_cone A)"
	+ using farkas_minkowsky_weyl_theorem_1 farkas_minkowsky_weyl_theorem_2 by metis
	+end
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Fundamental_Theorem_Linear_Inequalities.thy b/thys/Linear_Inequalities/Fundamental_Theorem_Linear_Inequalities.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Fundamental_Theorem_Linear_Inequalities.thy
	@@ -0,0 +1,777 @@
	+section \<open>The Fundamental Theorem of Linear Inequalities\<close>
	+
	+text \<open>The theorem states that for a given set of vectors A and vector b, either
	+ b is in the cone of a linear independent subset of A, or
	+ there is a hyperplane that contains span(A,b)-1 linearly independent vectors of A
	+ that separates A from b. We prove this theorem and derive some consequences, e.g.,
	+ Caratheodory's theorem that b is the cone of A iff b is in the cone of a linear
	+ independent subset of A.\<close>
	+
	+theory Fundamental_Theorem_Linear_Inequalities
	+ imports
	+ Cone
	+ Normal_Vector
	+ Dim_Span
	+begin
	+
	+context gram_schmidt
	+begin
	+
	+text \<open>The mentions equivances A-D are:
	+ \<^item> A: b is in the cone of vectors A,
	+ \<^item> B: b is in the cone of a subset of linear independent of vectors A,
	+ \<^item> C: there is no separating hyperplane of b and the vectors A,
	+ which contains dim many linear independent vectors of A
	+ \<^item> D: there is no separating hyperplane of b and the vectors A\<close>
	+
	+lemma fundamental_theorem_of_linear_inequalities_A_imp_D:
	+ assumes A: "A \<subseteq> carrier_vec n"
	+ and fin: "finite A"
	+ and b: "b \<in> cone A"
	+ shows "\<nexists> c. c \<in> carrier_vec n \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0"
	+proof
	+ assume "\<exists> c. c \<in> carrier_vec n \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0"
	+ then obtain c where c: "c \<in> carrier_vec n"
	+ and ai: "\<And> ai. ai \<in> A \<Longrightarrow> c \<bullet> ai \<ge> 0"
	+ and cb: "c \<bullet> b < 0" by auto
	+ from b[unfolded cone_def nonneg_lincomb_def finite_cone_def]
	+ obtain l AA where bc: "b = lincomb l AA" and l: "l ` AA \<subseteq> {x. x \<ge> 0}" and AA: "AA \<subseteq> A" by auto
	+ from cone_carrier[OF A] b have b: "b \<in> carrier_vec n" by auto
	+ have "0 \<le> (\<Sum>ai\<in>AA. l ai * (c \<bullet> ai))"
	+ by (intro sum_nonneg mult_nonneg_nonneg, insert l ai AA, auto)
	+ also have "\<dots> = (\<Sum>ai\<in>AA. l ai * (ai \<bullet> c))"
	+ by (rule sum.cong, insert c A AA comm_scalar_prod, force+)
	+ also have "\<dots> = (\<Sum>ai\<in>AA. ((l ai \<cdot>\<^sub>v ai) \<bullet> c))"
	+ by (rule sum.cong, insert smult_scalar_prod_distrib c A AA, auto)
	+ also have "\<dots> = b \<bullet> c" unfolding bc lincomb_def
	+ by (subst finsum_scalar_prod_sum[symmetric], insert c A AA, auto)
	+ also have "\<dots> = c \<bullet> b" using comm_scalar_prod b c by auto
	+ also have "\<dots> < 0" by fact
	+ finally show False by simp
	+qed
	+
	+text \<open>The difficult direction is that C implies B. To this end we follow the
	+ proof that at least one of B and the negation of C is satisfied.\<close>
	+context
	+ fixes a :: "nat \<Rightarrow> 'a vec"
	+ and b :: "'a vec"
	+ and m :: nat
	+ assumes a: "a ` {0 ..< m} \<subseteq> carrier_vec n"
	+ and inj_a: "inj_on a {0 ..< m}"
	+ and b: "b \<in> carrier_vec n"
	+ and full_span: "span (a ` {0 ..< m}) = carrier_vec n"
	+begin
	+
	+private definition "goal = ((\<exists> I. I \<subseteq> {0 ..< m} \<and> card (a ` I) = n \<and> lin_indpt (a ` I) \<and> b \<in> finite_cone (a ` I))
	+ \<or> (\<exists> c I. I \<subseteq> {0 ..< m} \<and> c \<in> {normal_vector (a ` I), - normal_vector (a ` I)} \<and> Suc (card (a ` I)) = n
	+ \<and> lin_indpt (a ` I) \<and> (\<forall> i < m. c \<bullet> a i \<ge> 0) \<and> c \<bullet> b < 0))"
	+
	+private lemma card_a_I[simp]: "I \<subseteq> {0 ..< m} \<Longrightarrow> card (a ` I) = card I"
	+ by (smt inj_a card_image inj_on_image_eq_iff subset_image_inj subset_refl subset_trans)
	+
	+private lemma in_a_I[simp]: "I \<subseteq> {0 ..< m} \<Longrightarrow> i < m \<Longrightarrow> (a i \<in> a ` I) = (i \<in> I)"
	+ using inj_a
	+ by (meson atLeastLessThan_iff image_eqI inj_on_image_mem_iff_alt zero_le)
	+
	+private definition "valid_I = { I. card I = n \<and> lin_indpt (a ` I) \<and> I \<subseteq> {0 ..< m}}"
	+
	+private definition cond where "cond I I' l c h k \<equiv>
	+ b = lincomb l (a ` I) \<and>
	+ h \<in> I \<and> l (a h) < 0 \<and> (\<forall> h'. h' \<in> I \<longrightarrow> h' < h \<longrightarrow> l (a h') \<ge> 0) \<and>
	+ c \<in> carrier_vec n \<and> span (a ` (I - {h})) = { x. x \<in> carrier_vec n \<and> c \<bullet> x = 0} \<and> c \<bullet> b < 0 \<and>
	+ k < m \<and> c \<bullet> a k < 0 \<and> (\<forall> k'. k' < k \<longrightarrow> c \<bullet> a k' \<ge> 0) \<and>
	+ I' = insert k (I - {h})"
	+
	+private definition "step_rel = Restr { (I'', I). \<exists> l c h k. cond I I'' l c h k } valid_I"
	+
	+private lemma finite_step_rel: "finite step_rel"
	+proof (rule finite_subset)
	+ show "step_rel \<subseteq> (Pow {0 ..< m} \<times> Pow {0 ..< m})" unfolding step_rel_def valid_I_def by auto
	+qed auto
	+
	+private lemma acyclic_imp_goal: "acyclic step_rel \<Longrightarrow> goal"
	+proof (rule ccontr)
	+ assume ngoal: "\<not> goal" (* then the algorithm will not terminate *)
	+ {
	+ fix I
	+ assume I: "I \<in> valid_I"
	+ hence Im: "I \<subseteq> {0..<m}" and
	+ lin: "lin_indpt (a ` I)" and
	+ cardI: "card I = n"
	+ by (auto simp: valid_I_def)
	+ let ?D = "(a ` I)"
	+ have finD: "finite ?D" using Im infinite_super by blast
	+ have carrD: "?D \<subseteq> carrier_vec n" using a Im by auto
	+ have cardD: "card ?D = n" using cardI Im by simp
	+ have spanD: "span ?D = carrier_vec n"
	+ by (intro span_carrier_lin_indpt_card_n lin cardD carrD)
	+ obtain lamb where b_is_lincomb: "b = lincomb lamb (a ` I)"
	+ using finite_in_span[OF fin carrD, of b] using spanD b carrD fin_dim lin by auto
	+ define h where "h = (LEAST h. h \<in> I \<and> lamb (a h) < 0)"
	+ have "\<exists> I'. (I', I) \<in> step_rel"
	+ proof (cases "\<forall>i\<in> I . lamb (a i) \<ge> 0")
	+ case cond1_T: True
	+ have goal unfolding goal_def
	+ by (intro disjI1 exI[of _ I] conjI lin cardI
	+ lincomb_in_finite_cone[OF b_is_lincomb finD _ carrD], insert cardI Im cond1_T, auto)
	+ with ngoal show ?thesis by auto
	+ next
	+ case cond1_F: False
	+ hence "\<exists> h. h \<in> I \<and> lamb (a h) < 0" by fastforce
	+ from LeastI_ex[OF this, folded h_def] have h: "h \<in> I" "lamb (a h) < 0" by auto
	+ from not_less_Least[of _ "\<lambda> h. h \<in> I \<and> lamb (a h) < 0", folded h_def]
	+ have h_least: "\<forall> k. k \<in> I \<longrightarrow> k < h \<longrightarrow> lamb (a k) \<ge> 0" by fastforce
	+ obtain I' where I'_def: "I' = I - {h}" by auto
	+ obtain c where c_def: "c = pos_norm_vec (a ` I') (a h)" by auto
	+ let ?D' = "a ` I'"
	+ have I'm: "I' \<subseteq> {0..<m}" using Im I'_def by auto
	+ have carrD': " ?D' \<subseteq> carrier_vec n" using a Im I'_def by auto
	+ have finD': "finite (?D')" using Im I'_def subset_eq_atLeast0_lessThan_finite by auto
	+ have D'subs: "?D' \<subseteq> ?D" using I'_def by auto
	+ have linD': "lin_indpt (?D')" using lin I'_def Im D'subs subset_li_is_li by auto
	+ have D'strictsubs: "?D = ?D' \<union> {a h}" using h I'_def by auto
	+ have h_nin_I: "h \<notin> I'" using h I'_def by auto
	+ have ah_nin_D': "a h \<notin> ?D'" using h inj_a Im h_nin_I by (subst in_a_I, auto simp: I'_def)
	+ have cardD': "Suc (card (?D')) = n " using cardD ah_nin_D' D'strictsubs finD' by simp
	+ have ah_carr: "a h \<in> carrier_vec n" using h a Im by auto
	+ note pnv = pos_norm_vec[OF carrD' finD' linD' cardD' c_def]
	+ have ah_nin_span: "a h \<notin> span ?D'"
	+ using D'strictsubs lin_dep_iff_in_span[OF carrD' linD' ah_carr ah_nin_D'] lin by auto
	+ have cah_ge_zero:"c \<bullet> a h > 0" and "c \<in> carrier_vec n"
	+ and cnorm: "span ?D' = {x \<in> carrier_vec n. x \<bullet> c = 0}"
	+ using ah_carr ah_nin_span pnv by auto
	+ have ccarr: "c \<in> carrier_vec n" by fact
	+ have "b \<bullet> c = lincomb lamb (a ` I) \<bullet> c" using b_is_lincomb by auto
	+ also have "\<dots> = (\<Sum>w\<in> ?D. lamb w * (w \<bullet> c))"
	+ using lincomb_scalar_prod_left[OF carrD, of c lamb] pos_norm_vec ccarr by blast
	+ also have "\<dots> = lamb (a h) * (a h \<bullet> c) + (\<Sum>w\<in> ?D'. lamb w * (w \<bullet> c))"
	+ using sum.insert[OF finD' ah_nin_D', of lamb] D'strictsubs ah_nin_D' finD' by auto
	+ also have "(\<Sum>w\<in> ?D'. lamb w * (w \<bullet> c)) = 0"
	+ apply (rule sum.neutral)
	+ using span_mem[OF carrD', unfolded cnorm] by simp
	+ also have "lamb (a h) * (a h \<bullet> c) + 0 < 0"
	+ using cah_ge_zero h(2) comm_scalar_prod[OF ah_carr ccarr]
	+ by (auto intro: mult_neg_pos)
	+ finally have cb_le_zero: "c \<bullet> b < 0" using comm_scalar_prod[OF b ccarr] by auto
	+
	+ show ?thesis
	+ proof (cases "\<forall>i < m . c \<bullet> a i \<ge> 0")
	+ case cond2_T: True
	+ have goal
	+ unfolding goal_def
	+ by (intro disjI2 exI[of _ c] exI[of _ I'] conjI cb_le_zero linD' cond2_T cardD' I'm pnv(4))
	+ with ngoal show ?thesis by auto
	+ next
	+ case cond2_F: False
	+ define k where "k = (LEAST k. k < m \<and> c \<bullet> a k < 0)"
	+ let ?I'' = "insert k I'"
	+ show ?thesis unfolding step_rel_def
	+ proof (intro exI[of _ ?I''], standard, unfold mem_Collect_eq split, intro exI)
	+ from LeastI_ex[OF ]
	+ have "\<exists>k. k < m \<and> c \<bullet> a k < 0" using cond2_F by fastforce
	+ from LeastI_ex[OF this, folded k_def] have k: "k < m" "c \<bullet> a k < 0" by auto
	+ show "cond I ?I'' lamb c h k" unfolding cond_def I'_def[symmetric] cnorm
	+ proof(intro conjI cb_le_zero b_is_lincomb h ccarr h_least refl k)
	+ show "{x \<in> carrier_vec n. x \<bullet> c = 0} = {x \<in> carrier_vec n. c \<bullet> x = 0}"
	+ using comm_scalar_prod[OF ccarr] by auto
	+ from not_less_Least[of _ "\<lambda> k. k < m \<and> c \<bullet> a k < 0", folded k_def]
	+ have "\<forall>k' < k . k' > m \<or> c \<bullet> a k' \<ge> 0" using k(1) less_trans not_less by blast
	+ then show "\<forall>k' < k . c \<bullet> a k' \<ge> 0" using k(1) by auto
	+ qed
	+
	+ have "?I'' \<in> valid_I" unfolding valid_I_def
	+ proof(standard, intro conjI)
	+ from k a have ak_carr: "a k \<in> carrier_vec n" by auto
	+ have ak_nin_span: "a k \<notin> span ?D'" using k(2) cnorm comm_scalar_prod[OF ak_carr ccarr] by auto
	+ hence ak_nin_D': "a k \<notin> ?D'" using span_mem[OF carrD'] by auto
	+ from lin_dep_iff_in_span[OF carrD' linD' ak_carr ak_nin_D']
	+ show "lin_indpt (a ` ?I'')" using ak_nin_span by auto
	+ show "?I'' \<subseteq> {0..<m}" using I'm k by auto
	+ show "card (insert k I') = n" using cardD' ak_nin_D' finD'
	+ by (metis \<open>insert k I' \<subseteq> {0..<m}\<close> card_a_I card_insert_disjoint image_insert)
	+ qed
	+ then show "(?I'', I) \<in> valid_I \<times> valid_I" using I by auto
	+
	+ qed
	+ qed
	+ qed
	+ } note step = this
	+ { (* create some valid initial set I *)
	+ from exists_lin_indpt_subset[OF a, unfolded full_span]
	+ obtain A where lin: "lin_indpt A" and span: "span A = carrier_vec n" and Am: "A \<subseteq> a ` {0 ..<m}" by auto
	+ from Am a have A: "A \<subseteq> carrier_vec n" by auto
	+ from lin span A have card: "card A = n"
	+ using basis_def dim_basis dim_is_n fin_dim_li_fin by auto
	+ from A Am obtain I where A: "A = a ` I" and I: "I \<subseteq> {0 ..< m}" by (metis subset_imageE)
	+ have "I \<in> valid_I" using I card lin unfolding valid_I_def A by auto
	+ hence "\<exists> I. I \<in> valid_I" ..
	+ }
	+ note init = this
	+ have step_valid: "(I',I) \<in> step_rel \<Longrightarrow> I' \<in> valid_I" for I I' unfolding step_rel_def by auto
	+ have "\<not> (wf step_rel)"
	+ proof
	+ from init obtain I where I: "I \<in> valid_I" by auto
	+ assume "wf step_rel"
	+ from this[unfolded wf_eq_minimal, rule_format, OF I] step step_valid show False by blast
	+ qed
	+ with wf_iff_acyclic_if_finite[OF finite_step_rel]
	+ have "\<not> acyclic step_rel" by auto
	+ thus "acyclic step_rel \<Longrightarrow> False" by auto
	+qed
	+
	+private lemma acyclic_step_rel: "acyclic step_rel"
	+proof (rule ccontr)
	+ assume "\<not> ?thesis"
	+ hence "\<not> acyclic (step_rel\<inverse>)" by auto
	+
	+(* obtain cycle *)
	+ then obtain I where "(I, I) \<in> (step_rel^-1)^+" unfolding acyclic_def by blast
	+ from this[unfolded trancl_power]
	+ obtain len where "(I, I) \<in> (step_rel^-1) ^^ len" and len0: "len > 0" by blast
	+ (* obtain all intermediate I's *)
	+ from this[unfolded relpow_fun_conv] obtain Is where
	+ stepsIs: "\<And> i. i < len \<Longrightarrow> (Is (Suc i), Is i) \<in> step_rel"
	+ and IsI: "Is 0 = I" "Is len = I" by auto
	+ {
	+ fix i
	+ assume "i \<le> len" hence "i - 1 < len" using len0 by auto
	+ from stepsIs[unfolded step_rel_def, OF this]
	+ have "Is i \<in> valid_I" by (cases i, auto)
	+ } note Is_valid = this
	+ from stepsIs[unfolded step_rel_def]
	+ have "\<forall> i. \<exists> l c h k. i < len \<longrightarrow> cond (Is i) (Is (Suc i)) l c h k" by auto
	+ (* obtain all intermediate c's h's, l's, k's *)
	+ from choice[OF this] obtain ls where "\<forall> i. \<exists> c h k. i < len \<longrightarrow> cond (Is i) (Is (Suc i)) (ls i) c h k" by auto
	+ from choice[OF this] obtain cs where "\<forall> i. \<exists> h k. i < len \<longrightarrow> cond (Is i) (Is (Suc i)) (ls i) (cs i) h k" by auto
	+ from choice[OF this] obtain hs where "\<forall> i. \<exists> k. i < len \<longrightarrow> cond (Is i) (Is (Suc i)) (ls i) (cs i) (hs i) k" by auto
	+ from choice[OF this] obtain ks where
	+ cond: "\<And> i. i < len \<Longrightarrow> cond (Is i) (Is (Suc i)) (ls i) (cs i) (hs i) (ks i)" by auto
	+ (* finally derive contradiction *)
	+ let ?R = "{hs i \| i. i < len}"
	+ define r where "r = Max ?R"
	+ from cond[OF len0] have "hs 0 \<in> I" using IsI unfolding cond_def by auto
	+ hence R0: "hs 0 \<in> ?R" using len0 by auto
	+ have finR: "finite ?R" by auto
	+ from Max_in[OF finR] R0
	+ have rR: "r \<in> ?R" unfolding r_def[symmetric] by auto
	+ then obtain p where rp: "r = hs p" and p: "p < len" by auto
	+ from Max_ge[OF finR, folded r_def]
	+ have rLarge: "i < len \<Longrightarrow> hs i \<le> r" for i by auto
	+ have exq: "\<exists>q. ks q = r \<and> q < len"
	+ proof (rule ccontr)
	+ assume neg: "\<not>?thesis"
	+ show False
	+ proof(cases "r \<in> I")
	+ case True
	+ have 1: "j\<in>{Suc p..len} \<Longrightarrow> r \<notin> Is j" for j
	+ proof(induction j rule: less_induct)
	+ case (less j)
	+ from less(2) have j_bounds: "j = Suc p \<or> j > Suc p" by auto
	+ from less(2) have j_len: "j \<le> len" by auto
	+ have pj_cond: "j = Suc p \<Longrightarrow> cond (Is p) (Is j) (ls p) (cs p) (hs p) (ks p)" using cond p by blast
	+ have r_neq_ksp: "r \<noteq> ks p" using p neg by auto
	+ have "j = Suc p \<Longrightarrow> Is j = insert (ks p) (Is p - {r})"
	+ using rp cond pj_cond cond_def[of "Is p" "Is j" _ _ r] by blast
	+ hence c1: "j = Suc p \<Longrightarrow> r \<notin> Is j" using r_neq_ksp by simp
	+ have IH: "\<And>t. t < j \<Longrightarrow> t \<in> {Suc p..len} \<Longrightarrow> r \<notin> Is t" by fact
	+ have r_neq_kspj: "j > Suc p \<and> j \<le> len \<Longrightarrow> r \<noteq> ks (j-1)" using j_len neg IH by auto
	+ have jsucj_cond: "j > Suc p \<and> j \<le> len \<Longrightarrow> Is j = insert (ks (j-1)) (Is (j-1) - {hs (j-1)})"
	+ using cond_def[of "Is (j-1)" "Is j"] cond
	+ by (metis (no_types, lifting) Suc_less_eq2 diff_Suc_1 le_simps(3))
	+ hence "j > Suc p \<and> j \<le> len \<Longrightarrow> r \<notin> insert (ks (j-1)) (Is (j-1))"
	+ using IH r_neq_kspj by auto
	+ hence "j > Suc p \<and> j \<le> len \<Longrightarrow> r \<notin> Is j" using jsucj_cond by simp
	+ then show ?case using j_bounds j_len c1 by blast
	+ qed
	+ then show ?thesis using neg IsI(2) True p by auto
	+ next
	+ case False
	+ have 2: "j\<in>{0..p} \<Longrightarrow> r \<notin> Is j" for j
	+ proof(induction j rule: less_induct)
	+ case(less j)
	+ from less(2) have j_bound: "j \<le> p" by auto
	+ have r_nin_Is0: "r \<notin> Is 0" using IsI(1) False by simp
	+ have IH: "\<And>t. t < j \<and> t \<in> {0..p} \<Longrightarrow> r \<notin> Is t" using less.IH by blast
	+ have j_neq_ksjpred: "j > 0 \<Longrightarrow> r \<noteq> ks (j -1)" using neg j_bound p by auto
	+ have Is_jpredj: "j > 0 \<Longrightarrow> Is j = insert (ks (j-1)) (Is (j-1) - {hs (j-1)})"
	+ using cond_def[of "Is (j-1)" "Is j" _ _ "hs (j-1)" "ks (j-1)"] cond
	+ by (metis (full_types) One_nat_def Suc_pred diff_le_self j_bound le_less_trans p)
	+ have "j > 0 \<Longrightarrow> r \<notin> insert (ks (j-1)) (Is (j-1))"
	+ using j_neq_ksjpred IH j_bound by fastforce
	+ hence "j > 0 \<Longrightarrow> r \<notin> Is j" using Is_jpredj by blast
	+ then show ?case using j_bound r_nin_Is0 by blast
	+ qed
	+ have 3: "r \<in> Is p" using rp cond cond_def p by blast
	+ then show ?thesis using 2 3 by auto
	+ qed
	+ qed
	+ then obtain q where q1: "ks q = r" and q_len: "q < len" by blast
	+
	+ {
	+ fix t i1 i2
	+ assume "i1 < len" "i2 < len" "t < m"
	+ assume "t\<in> Is i1" "t\<notin> Is i2"
	+ have "\<exists>j < len. t = hs j"
	+ proof (rule ccontr)
	+ assume "\<not> ?thesis"
	+ hence hst: "\<And> j. j < len \<Longrightarrow> hs j \<noteq> t" by auto
	+ have main: "t \<notin> Is (i + k) \<Longrightarrow> i + k \<le> len \<Longrightarrow> t \<notin> Is k" for i k
	+ proof (induct i)
	+ case (Suc i)
	+ hence i: "i + k < len" by auto
	+ from cond[OF this, unfolded cond_def]
	+ have "Is (Suc i + k) = insert (ks (i + k)) (Is (i + k) - {hs (i + k)})" by auto
	+ from Suc(2)[unfolded this] hst[OF i] have "t \<notin> Is (i + k)" by auto
	+ from Suc(1)[OF this] i show ?case by auto
	+ qed auto
	+ from main[of i2 0] \<open>i2 < len\<close> \<open>t \<notin> Is i2\<close> have "t \<notin> Is 0" by auto
	+ with IsI have "t \<notin> Is len" by auto
	+ with main[of "len - i1" i1] \<open>i1 < len\<close> have "t \<notin> Is i1" by auto
	+ with \<open>t \<in> Is i1\<close> show False by blast
	+ qed
	+ } note innotin = this
	+
	+ {
	+ fix i
	+ assume i: "i \<in> {Suc r..<m}"
	+ {
	+ assume i_in_Isp: "i \<in> Is p"
	+ have "i \<in> Is q"
	+ proof (rule ccontr)
	+ have i_range: "i < m" using i by simp
	+ assume "\<not> ?thesis"
	+ then have ex: "\<exists>j < len. i = hs j"
	+ using innotin[OF p q_len i_range i_in_Isp] by simp
	+ then obtain j where j_hs: "i = hs j" by blast
	+ have "i>r" using i by simp
	+ then show False using j_hs p rLarge ex by force
	+ qed
	+ }
	+ hence "(i \<in> Is p) \<Longrightarrow> (i \<in> Is q)" by blast
	+ } note bla = this
	+ have blin: "b = lincomb (ls p) (a ` (Is p))" using cond_def p cond by blast
	+ have carrDp: "(a ` (Is p)) \<subseteq> carrier_vec n " using Is_valid valid_I_def a p
	+ by (smt image_subset_iff less_imp_le_nat mem_Collect_eq subsetD)
	+ have carrcq: "cs q \<in> carrier_vec n" using cond cond_def q_len by simp
	+ have ineq1: "(cs q) \<bullet> b < 0" using cond_def q_len cond by blast
	+ let ?Isp_lt_r = "{x \<in> Is p . x < r}"
	+ let ?Isp_gt_r = "{x \<in> Is p . x > r}"
	+ have Is_disj: "?Isp_lt_r \<inter> ?Isp_gt_r = {}" using Is_valid by auto
	+ have "?Isp_lt_r \<subseteq> Is p" by simp
	+ hence Isp_lt_0m: "?Isp_lt_r \<subseteq> {0..<m}" using valid_I_def Is_valid p less_imp_le_nat by blast
	+ have "?Isp_gt_r \<subseteq> Is p" by simp
	+ hence Isp_gt_0m: "?Isp_gt_r \<subseteq> {0..<m}" using valid_I_def Is_valid p less_imp_le_nat by blast
	+ let ?Dp_lt = "a ` ?Isp_lt_r"
	+ let ?Dp_ge = "a ` ?Isp_gt_r"
	+ {
	+ fix A B
	+ assume Asub: "A \<subseteq> {0..<m} \<union> {0..<Suc r}"
	+ assume Bsub: "B \<subseteq> {0..<m} \<union> {0..<Suc r}"
	+ assume ABinters: "A \<inter> B = {}"
	+ have "r \<in> Is p" using rp p cond unfolding cond_def by simp
	+ hence r_lt_m: "r < m" using p Is_valid[of p] unfolding valid_I_def by auto
	+ hence 1: "A \<subseteq> {0..<m}" using Asub by auto
	+ have 2: "B \<subseteq> {0..<m}" using r_lt_m Bsub by auto
	+ have "a ` A \<inter> a ` B = {}"
	+ using inj_on_image_Int[OF inj_a 1 2] ABinters by auto
	+ } note inja = this
	+
	+ have "(Is p \<inter> {0..<r}) \<inter> (Is p \<inter> {r}) = {}" by auto
	+ hence "a ` (Is p \<inter> {0..<r} \<union> Is p \<inter> {r}) = a ` (Is p \<inter> {0..<r}) \<union> a ` (Is p \<inter> {r})"
	+ using inj_a by auto
	+ moreover have "Is p \<inter> {0..<r} \<union> Is p \<inter> {r} \<subseteq> {0..<m} \<union> {0..<Suc r}" by auto
	+ moreover have "Is p \<inter> {Suc r..<m} \<subseteq> {0..<m} \<union> {0..<Suc r}" by auto
	+ moreover have "(Is p \<inter> {0..<r} \<union> Is p \<inter> {r}) \<inter> (Is p \<inter> {Suc r..<m}) = {}" by auto
	+ ultimately have one: "(a ` (Is p \<inter> {0..<r}) \<union> a ` (Is p \<inter> {r})) \<inter> a ` (Is p \<inter> {Suc r..<m}) = {}"
	+ using inja[of "Is p \<inter> {0..<r} \<union> Is p \<inter> {r}" "Is p \<inter> {Suc r..<m}"] by auto
	+ have split: "Is p = Is p \<inter> {0..<r} \<union> Is p \<inter> {r} \<union> Is p \<inter> {Suc r ..< m}"
	+ using rp p Is_valid[of p] unfolding valid_I_def by auto
	+ have gtr: "(\<Sum>w \<in> (a ` (Is p \<inter> {Suc r ..< m})). ((ls p) w) * (cs q \<bullet> w)) = 0"
	+ proof (rule sum.neutral, clarify)
	+ fix w
	+ assume w1: "w \<in> Is p" and w2: "w\<in>{Suc r..<m}"
	+ have w_in_q: "w \<in> Is q" using bla[OF w2] w1 by blast
	+ moreover have "hs q \<le> r" using rR rLarge using q_len by blast
	+ ultimately have "w \<noteq> hs q" using w2 by simp
	+ hence "w \<in> Is q -{hs q}" using w1 w_in_q by auto
	+ moreover have "Is q - {hs q} \<subseteq> {0..<m}"
	+ using q_len Is_valid[of q] unfolding valid_I_def by auto
	+ ultimately have "a w \<in> span ( a ` (Is q - {hs q}))" using a by (intro span_mem, auto)
	+ moreover have "cs q \<in> carrier_vec n \<and> span (a ` (Is q - {hs q})) =
	+ { x. x \<in> carrier_vec n \<and> cs q \<bullet> x = 0}"
	+ using cond[of q] q_len unfolding cond_def by auto
	+ ultimately have "(cs q) \<bullet> (a w) = 0" using a w2 by simp
	+ then show "ls p (a w) * (cs q \<bullet> a w) = 0" by simp
	+ qed
	+ note pp = cond[OF p, unfolded cond_def rp[symmetric]]
	+ note qq = cond[OF q_len, unfolded cond_def q1]
	+ have "(cs q) \<bullet> b = (cs q) \<bullet> lincomb (ls p) (a ` (Is p))" using blin by auto
	+ also have "\<dots> = (\<Sum>w \<in> (a ` (Is p)). ((ls p) w) * (cs q \<bullet> w))"
	+ by (subst lincomb_scalar_prod_right[OF carrDp carrcq], simp)
	+ also have "\<dots> = (\<Sum>w \<in> (a ` (Is p \<inter> {0..<r}) \<union> a ` (Is p \<inter> {r}) \<union> a ` (Is p \<inter> {Suc r..<m})).
	+ ((ls p) w) * (cs q \<bullet> w))"
	+ by (subst (1) split, rule sum.cong, auto)
	+ also have "\<dots> = (\<Sum>w \<in> (a ` (Is p \<inter> {0..<r})). ((ls p) w) * (cs q \<bullet> w))
	+ + (\<Sum>w \<in> (a ` (Is p \<inter> {r})). ((ls p) w) * (cs q \<bullet> w))
	+ + (\<Sum>w \<in> (a ` (Is p \<inter> {Suc r ..< m})). ((ls p) w) * (cs q \<bullet> w))"
	+ apply (subst sum.union_disjoint[OF _ _ one])
	+ apply (force+)[2]
	+ apply (subst sum.union_disjoint)
	+ apply (force+)[2]
	+ apply (rule inja)
	+ by auto
	+ also have "\<dots> = (\<Sum>w \<in> (a ` (Is p \<inter> {0..<r})). ((ls p) w) * (cs q \<bullet> w))
	+ + (\<Sum>w \<in> (a ` (Is p \<inter> {r})). ((ls p) w) * (cs q \<bullet> w))"
	+ using sum.neutral gtr by simp
	+ also have "\<dots> > 0 + 0"
	+ proof (intro add_le_less_mono sum_nonneg mult_nonneg_nonneg)
	+ {
	+ fix x
	+ assume x: "x \<in> a ` (Is p \<inter> {0..<r})"
	+ show "0 \<le> ls p x" using pp x by auto
	+ show "0 \<le> cs q \<bullet> x" using qq x by auto
	+ }
	+ have "r \<in> Is p" using pp by blast
	+ hence "a ` (Is p \<inter> {r}) = {a r}" by auto
	+ hence id: "(\<Sum>w\<in>a ` (Is p \<inter> {r}). ls p w * (cs q \<bullet> w)) = ls p (a r) * (cs q \<bullet> a r)"
	+ by simp
	+ show "0 < (\<Sum>w\<in>a ` (Is p \<inter> {r}). ls p w * (cs q \<bullet> w))"
	+ unfolding id
	+ proof (rule mult_neg_neg)
	+ show "ls p (a r) < 0" using pp by auto
	+ show "cs q \<bullet> a r < 0" using qq by auto
	+ qed
	+ qed
	+ finally have "cs q \<bullet> b > 0" by simp
	+ moreover have "cs q \<bullet> b < 0" using qq by blast
	+ ultimately show False by auto
	+qed
	+
	+lemma fundamental_theorem_neg_C_or_B_in_context:
	+ assumes W: "W = a ` {0 ..< m}"
	+ shows "(\<exists> U. U \<subseteq> W \<and> card U = n \<and> lin_indpt U \<and> b \<in> finite_cone U) \<or>
	+ (\<exists>c U. U \<subseteq> W \<and>
	+ c \<in> {normal_vector U, - normal_vector U} \<and>
	+ Suc (card U) = n \<and> lin_indpt U \<and> (\<forall>w \<in> W. 0 \<le> c \<bullet> w) \<and> c \<bullet> b < 0)"
	+ using acyclic_imp_goal[unfolded goal_def, OF acyclic_step_rel]
	+proof
	+ assume "\<exists>I. I\<subseteq>{0..<m} \<and> card (a ` I) = n \<and> lin_indpt (a ` I) \<and> b \<in> finite_cone (a ` I)"
	+ thus ?thesis unfolding W by (intro disjI1, blast)
	+next
	+ assume "\<exists>c I. I \<subseteq> {0..<m} \<and>
	+ c \<in> {normal_vector (a ` I), - normal_vector (a ` I)} \<and>
	+ Suc (card (a ` I)) = n \<and> lin_indpt (a ` I) \<and> (\<forall>i<m. 0 \<le> c \<bullet> a i) \<and> c \<bullet> b < 0"
	+ then obtain c I where "I \<subseteq> {0..<m} \<and>
	+ c \<in> {normal_vector (a ` I), - normal_vector (a ` I)} \<and>
	+ Suc (card (a ` I)) = n \<and> lin_indpt (a ` I) \<and> (\<forall>i<m. 0 \<le> c \<bullet> a i) \<and> c \<bullet> b < 0" by auto
	+ thus ?thesis unfolding W
	+ by (intro disjI2 exI[of _ c] exI[of _ "a ` I"], auto)
	+qed
	+
	+end
	+
	+lemma fundamental_theorem_of_linear_inequalities_C_imp_B_full_dim:
	+ assumes A: "A \<subseteq> carrier_vec n"
	+ and fin: "finite A"
	+ and span: "span A = carrier_vec n" (* this condition was a wlog in the proof *)
	+ and b: "b \<in> carrier_vec n"
	+ and C: "\<nexists> c B. B \<subseteq> A \<and> c \<in> {normal_vector B, - normal_vector B} \<and> Suc (card B) = n
	+ \<and> lin_indpt B \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0"
	+ shows "\<exists> B \<subseteq> A. lin_indpt B \<and> card B = n \<and> b \<in> finite_cone B"
	+proof -
	+ from finite_distinct_list[OF fin] obtain as where Aas: "A = set as" and dist: "distinct as" by auto
	+ define m where "m = length as"
	+ define a where "a = (\<lambda> i. as ! i)"
	+ have inj: "inj_on a {0..< (m :: nat)}"
	+ and id: "A = a ` {0..<m}"
	+ unfolding m_def a_def Aas using inj_on_nth[OF dist] unfolding set_conv_nth
	+ by auto
	+ from fundamental_theorem_neg_C_or_B_in_context[OF _ inj b, folded id, OF A span refl] C
	+ show ?thesis by blast
	+qed
	+
	+
	+lemma fundamental_theorem_of_linear_inequalities_full_dim: fixes A :: "'a vec set"
	+ defines "HyperN \<equiv> {b. b \<in> carrier_vec n \<and> (\<nexists> B c. B \<subseteq> A \<and> c \<in> {normal_vector B, - normal_vector B}
	+ \<and> Suc (card B) = n \<and> lin_indpt B \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0)}"
	+ defines "HyperA \<equiv> {b. b \<in> carrier_vec n \<and> (\<nexists> c. c \<in> carrier_vec n \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0)}"
	+ defines "lin_indpt_cone \<equiv> \<Union> { finite_cone B \| B. B \<subseteq> A \<and> card B = n \<and> lin_indpt B}"
	+ assumes A: "A \<subseteq> carrier_vec n"
	+ and fin: "finite A"
	+ and span: "span A = carrier_vec n"
	+ shows
	+ "cone A = lin_indpt_cone"
	+ "cone A = HyperN"
	+ "cone A = HyperA"
	+proof -
	+ have "lin_indpt_cone \<subseteq> cone A" unfolding lin_indpt_cone_def cone_def using fin finite_cone_mono A
	+ by auto
	+ moreover have "cone A \<subseteq> HyperA"
	+ proof
	+ fix c
	+ assume cA: "c \<in> cone A"
	+ from fundamental_theorem_of_linear_inequalities_A_imp_D[OF A fin this] cone_carrier[OF A] cA
	+ show "c \<in> HyperA" unfolding HyperA_def by auto
	+ qed
	+ moreover have "HyperA \<subseteq> HyperN"
	+ proof
	+ fix c
	+ assume "c \<in> HyperA"
	+ hence False: "\<And> v. v \<in> carrier_vec n \<Longrightarrow> (\<forall>a\<^sub>i\<in>A. 0 \<le> v \<bullet> a\<^sub>i) \<Longrightarrow> v \<bullet> c < 0 \<Longrightarrow> False"
	+ and c: "c \<in> carrier_vec n" unfolding HyperA_def by auto
	+ show "c \<in> HyperN"
	+ unfolding HyperN_def
	+ proof (standard, intro conjI c notI, clarify, goal_cases)
	+ case (1 W nv)
	+ with A fin have fin: "finite W" and W: "W \<subseteq> carrier_vec n" by (auto intro: finite_subset)
	+ show ?case using False[of nv] 1 normal_vector[OF fin _ _ W] by auto
	+ qed
	+ qed
	+ moreover have "HyperN \<subseteq> lin_indpt_cone"
	+ proof
	+ fix b
	+ assume "b \<in> HyperN"
	+ from this[unfolded HyperN_def]
	+ fundamental_theorem_of_linear_inequalities_C_imp_B_full_dim[OF A fin span, of b]
	+ show "b \<in> lin_indpt_cone" unfolding lin_indpt_cone_def by auto
	+ qed
	+ ultimately show
	+ "cone A = lin_indpt_cone"
	+ "cone A = HyperN"
	+ "cone A = HyperA"
	+ by auto
	+qed
	+
	+lemma fundamental_theorem_of_linear_inequalities_C_imp_B:
	+ assumes A: "A \<subseteq> carrier_vec n"
	+ and fin: "finite A"
	+ and b: "b \<in> carrier_vec n"
	+ and C: "\<nexists> c A'. c \<in> carrier_vec n
	+ \<and> A' \<subseteq> A \<and> Suc (card A') = dim_span (insert b A)
	+ \<and> (\<forall> a \<in> A'. c \<bullet> a = 0)
	+ \<and> lin_indpt A' \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0"
	+ shows "\<exists> B \<subseteq> A. lin_indpt B \<and> card B = dim_span A \<and> b \<in> finite_cone B"
	+proof -
	+ from exists_lin_indpt_sublist[OF A] obtain A' where
	+ lin: "lin_indpt_list A'" and span: "span (set A') = span A" and A'A: "set A' \<subseteq> A" by auto
	+ hence linA': "lin_indpt (set A')" unfolding lin_indpt_list_def by auto
	+ from A'A A have A': "set A' \<subseteq> carrier_vec n" by auto
	+ have dim_spanA: "dim_span A = card (set A')"
	+ by (rule sym, rule same_span_imp_card_eq_dim_span[OF A' A span linA'])
	+ show ?thesis
	+ proof (cases "b \<in> span A")
	+ case False
	+ with span have "b \<notin> span (set A')" by auto
	+ with lin have linAb: "lin_indpt_list (A' @ [b])" unfolding lin_indpt_list_def
	+ using lin_dep_iff_in_span[OF A' _ b] span_mem[OF A', of b] b by auto
	+ interpret gso: gram_schmidt_fs_lin_indpt n "A' @ [b]"
	+ by (standard, insert linAb[unfolded lin_indpt_list_def], auto)
	+ let ?m = "length A'"
	+ define c where "c = - gso.gso ?m"
	+ have c: "c \<in> carrier_vec n" using gso.gso_carrier[of ?m] unfolding c_def by auto
	+ from gso.gso_times_self_is_norm[of ?m]
	+ have "b \<bullet> gso.gso ?m = sq_norm (gso.gso ?m)" unfolding c_def using b c by auto
	+ also have "\<dots> > 0" using gso.sq_norm_pos[of ?m] by auto
	+ finally have cb: "c \<bullet> b < 0" using b c comm_scalar_prod[OF b c] unfolding c_def by auto
	+ {
	+ fix a
	+ assume "a \<in> A"
	+ hence "a \<in> span (set A')" unfolding span using span_mem[OF A] by auto
	+ from finite_in_span[OF _ A' this]
	+ obtain l where "a = lincomb l (set A')" by auto
	+ hence "c \<bullet> a = c \<bullet> lincomb l (set A')" by simp
	+ also have "\<dots> = 0"
	+ by (subst lincomb_scalar_prod_right[OF A' c], rule sum.neutral, insert A', unfold set_conv_nth,
	+ insert gso.gso_scalar_zero[of ?m] c, auto simp: c_def nth_append )
	+ finally have "c \<bullet> a = 0" .
	+ } note cA = this
	+ have "\<exists> c A'. c \<in> carrier_vec n \<and> A' \<subseteq> A \<and> Suc (card A') = dim_span (insert b A)
	+ \<and> (\<forall> a \<in> A'. c \<bullet> a = 0) \<and> lin_indpt A' \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0"
	+ proof (intro exI[of _ c] exI[of _ "set A'"] conjI A'A linA' cb c)
	+ show "\<forall>a\<in>set A'. c \<bullet> a = 0" "\<forall>a\<^sub>i\<in>A. 0 \<le> c \<bullet> a\<^sub>i" using cA A'A by auto
	+ have "dim_span (insert b A) = Suc (dim_span A)"
	+ by (rule dim_span_insert[OF A b False])
	+ also have "\<dots> = Suc (card (set A'))" unfolding dim_spanA ..
	+ finally show "Suc (card (set A')) = dim_span (insert b A)" ..
	+ qed
	+ with C have False by blast
	+ thus ?thesis ..
	+ next
	+ case bspan: True
	+ define N where "N = normal_vectors A'"
	+ from normal_vectors[OF lin, folded N_def]
	+ have N: "set N \<subseteq> carrier_vec n" and
	+ orthA'N: "\<And> w nv. w \<in> set A' \<Longrightarrow> nv \<in> set N \<Longrightarrow> nv \<bullet> w = 0" and
	+ linAN: "lin_indpt_list (A' @ N)" and
	+ lenAN: "length (A' @ N) = n" and
	+ disj: "set A' \<inter> set N = {}" by auto
	+ from linAN lenAN have full_span': "span (set (A' @ N)) = carrier_vec n"
	+ using lin_indpt_list_length_eq_n by blast
	+ hence full_span'': "span (set A' \<union> set N) = carrier_vec n" by auto
	+ from A N A' have AN: "A \<union> set N \<subseteq> carrier_vec n" and A'N: "set (A' @ N) \<subseteq> carrier_vec n" by auto
	+ hence "span (A \<union> set N) \<subseteq> carrier_vec n" by (simp add: span_is_subset2)
	+ with A'A span_is_monotone[of "set (A' @ N)" "A \<union> set N", unfolded full_span']
	+ have full_span: "span (A \<union> set N) = carrier_vec n" unfolding set_append by fast
	+ from fin have finAN: "finite (A \<union> set N)" by auto
	+ note fundamental = fundamental_theorem_of_linear_inequalities_full_dim[OF AN finAN full_span]
	+ show ?thesis
	+ proof (cases "b \<in> cone (A \<union> set N)")
	+ case True
	+ from this[unfolded fundamental(1)] obtain C where CAN: "C \<subseteq> A \<union> set N" and cardC: "card C = n"
	+ and linC: "lin_indpt C"
	+ and bC: "b \<in> finite_cone C" by auto
	+ have finC: "finite C" using finite_subset[OF CAN] fin by auto
	+ from CAN A N have C: "C \<subseteq> carrier_vec n" by auto
	+ from bC[unfolded finite_cone_def nonneg_lincomb_def] finC obtain c
	+ where bC: "b = lincomb c C" and nonneg: "\<And> b. b \<in> C \<Longrightarrow> c b \<ge> 0" by auto
	+ let ?C = "C - set N"
	+ show ?thesis
	+ proof (intro exI[of _ ?C] conjI)
	+ from subset_li_is_li[OF linC] show "lin_indpt ?C" by auto
	+ show CA: "?C \<subseteq> A" using CAN by auto
	+ have bc: "b = lincomb c (?C \<union> (C \<inter> set N))" unfolding bC
	+ by (rule arg_cong[of _ _ "lincomb _"], auto)
	+ have "b = lincomb c (?C - C \<inter> set N)"
	+ proof (rule orthogonal_cone(2)[OF A N fin full_span'' orthA'N refl span
	+ A'A linAN lenAN _ CA _ bc])
	+ show "\<forall>w\<in>set N. w \<bullet> b = 0"
	+ using ortho_span'[OF A' N _ bspan[folded span]] orthA'N by auto
	+ qed auto
	+ also have "?C - C \<inter> set N = ?C" by auto
	+ finally have "b = lincomb c ?C" .
	+ with nonneg have "nonneg_lincomb c ?C b" unfolding nonneg_lincomb_def by auto
	+ thus "b \<in> finite_cone ?C" unfolding finite_cone_def using finite_subset[OF CA fin] by auto
	+ have Cid: "C \<inter> set N \<union> ?C = C" by auto
	+ have "length A' + length N = n" by fact
	+ also have "\<dots> = card (C \<inter> set N \<union> ?C) " using Cid cardC by auto
	+ also have "\<dots> = card (C \<inter> set N) + card ?C"
	+ by (subst card_Un_disjoint, insert finC, auto)
	+ also have "\<dots> \<le> length N + card ?C"
	+ by (rule add_right_mono, rule order.trans, rule card_mono[OF finite_set[of N]],
	+ auto intro: card_length)
	+ also have "length A' = card (set A')" using lin[unfolded lin_indpt_list_def]
	+ distinct_card[of A'] by auto
	+ finally have le: "dim_span A \<le> card ?C" using dim_spanA by auto
	+ have CA: "?C \<subseteq> span A" using CA C in_own_span[OF A] by auto
	+ have linC: "lin_indpt ?C" using subset_li_is_li[OF linC] by auto
	+ show "card ?C = dim_span A"
	+ using card_le_dim_span[OF _ CA linC] le C by force
	+ qed
	+ next
	+ case False
	+ from False[unfolded fundamental(2)] b
	+ obtain C c where
	+ CAN: "C \<subseteq> A \<union> set N" and
	+ cardC: "Suc (card C) = n" and
	+ linC: "lin_indpt C" and
	+ contains: "(\<forall>a\<^sub>i\<in>A \<union> set N. 0 \<le> c \<bullet> a\<^sub>i)" and
	+ cb: "c \<bullet> b < 0" and
	+ nv: "c \<in> {normal_vector C, - normal_vector C}"
	+ by auto
	+ from CAN A N have C: "C \<subseteq> carrier_vec n" by auto
	+ from cardC have cardCn: "card C < n" by auto
	+ from finite_subset[OF CAN] fin have finC: "finite C" by auto
	+ let ?C = "C - set N"
	+ note nv' = normal_vector(1-4)[OF finC cardC linC C]
	+ from nv' nv have c: "c \<in> carrier_vec n" by auto
	+ have "\<exists> c A'. c \<in> carrier_vec n \<and> A' \<subseteq> A \<and> Suc (card A') = dim_span (insert b A)
	+ \<and> (\<forall> a \<in> A'. c \<bullet> a = 0) \<and> lin_indpt A' \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0"
	+ proof (intro exI[of _ c] exI[of _ ?C] conjI cb c)
	+ show CA: "?C \<subseteq> A" using CAN by auto
	+ show "\<forall>a\<^sub>i\<in>A. 0 \<le> c \<bullet> a\<^sub>i" using contains by auto
	+ show lin': "lin_indpt ?C" using subset_li_is_li[OF linC] by auto
	+ show sC0: "\<forall>a\<in> ?C. c \<bullet> a = 0" using nv' nv C by auto
	+ have Cid: "C \<inter> set N \<union> ?C = C" by auto
	+ have "dim_span (set A') = card (set A')"
	+ by (rule sym, rule same_span_imp_card_eq_dim_span[OF A' A' refl linA'])
	+ also have "\<dots> = length A'"
	+ using lin[unfolded lin_indpt_list_def] distinct_card[of A'] by auto
	+ finally have dimA': "dim_span (set A') = length A'" .
	+ from bspan have "span (insert b A) = span A" using b A using already_in_span by auto
	+ from dim_span_cong[OF this[folded span]] dimA'
	+ have dimbA: "dim_span (insert b A) = length A'" by simp
	+ also have "\<dots> = Suc (card ?C)"
	+ proof (rule ccontr)
	+ assume neq: "length A' \<noteq> Suc (card ?C)"
	+ have "length A' + length N = n" by fact
	+ also have "\<dots> = Suc (card (C \<inter> set N \<union> ?C))" using Cid cardC by auto
	+ also have "\<dots> = Suc (card (C \<inter> set N) + card ?C)"
	+ by (subst card_Un_disjoint, insert finC, auto)
	+ finally have id: "length A' + length N = Suc (card (C \<inter> set N) + card ?C)" .
	+ have le1: "card (C \<inter> set N) \<le> length N"
	+ by (metis Int_lower2 List.finite_set card_length card_mono inf.absorb_iff2 le_inf_iff)
	+ from CA C A have CsA: "?C \<subseteq> span (set A')" unfolding span by (meson in_own_span order.trans)
	+ from card_le_dim_span[OF _ this lin'] C
	+ have le2: "card ?C \<le> length A'" unfolding dimA' by auto
	+ from id le1 le2 neq
	+ have id2: "card ?C = length A'" by linarith+
	+ from card_eq_dim_span_imp_same_span[OF A' CsA lin' id2[folded dimA']]
	+ have "span ?C = span A" unfolding span by auto
	+ with bspan have "b \<in> span ?C" by auto
	+ from orthocompl_span[OF _ _ c this] C sC0
	+ have "c \<bullet> b = 0" by auto
	+ with cb show False by simp
	+ qed
	+ finally show "Suc (card ?C) = dim_span (insert b A)" by simp
	+ qed
	+ with assms(4) have False by blast
	+ thus ?thesis ..
	+ qed
	+ qed
	+qed
	+
	+lemma fundamental_theorem_of_linear_inequalities: fixes A :: "'a vec set"
	+ defines "HyperN \<equiv> {b. b \<in> carrier_vec n \<and> (\<nexists> c B. c \<in> carrier_vec n \<and> B \<subseteq> A
	+ \<and> Suc (card B) = dim_span (insert b A) \<and> lin_indpt B
	+ \<and> (\<forall> a \<in> B. c \<bullet> a = 0)
	+ \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0)}"
	+ defines "HyperA \<equiv> {b. b \<in> carrier_vec n \<and> (\<nexists> c. c \<in> carrier_vec n \<and> (\<forall> a\<^sub>i \<in> A. c \<bullet> a\<^sub>i \<ge> 0) \<and> c \<bullet> b < 0)}"
	+ defines "lin_indpt_cone \<equiv> \<Union> { finite_cone B \| B. B \<subseteq> A \<and> card B = dim_span A \<and> lin_indpt B}"
	+ assumes A: "A \<subseteq> carrier_vec n"
	+ and fin: "finite A"
	+ shows
	+ "cone A = lin_indpt_cone"
	+ "cone A = HyperN"
	+ "cone A = HyperA"
	+proof -
	+ have "lin_indpt_cone \<subseteq> cone A"
	+ unfolding lin_indpt_cone_def cone_def using fin finite_cone_mono A by auto
	+ moreover have "cone A \<subseteq> HyperA"
	+ using fundamental_theorem_of_linear_inequalities_A_imp_D[OF A fin] cone_carrier[OF A]
	+ unfolding HyperA_def by blast
	+ moreover have "HyperA \<subseteq> HyperN" unfolding HyperA_def HyperN_def by blast
	+ moreover have "HyperN \<subseteq> lin_indpt_cone"
	+ proof
	+ fix b
	+ assume "b \<in> HyperN"
	+ from this[unfolded HyperN_def]
	+ fundamental_theorem_of_linear_inequalities_C_imp_B[OF A fin, of b]
	+ show "b \<in> lin_indpt_cone" unfolding lin_indpt_cone_def by blast
	+ qed
	+ ultimately show
	+ "cone A = lin_indpt_cone"
	+ "cone A = HyperN"
	+ "cone A = HyperA"
	+ by auto
	+qed
	+
	+corollary Caratheodory_theorem: assumes A: "A \<subseteq> carrier_vec n"
	+ shows "cone A = \<Union> {finite_cone B \|B. B \<subseteq> A \<and> lin_indpt B}"
	+proof
	+ show "\<Union> {finite_cone B \|B. B \<subseteq> A \<and> lin_indpt B} \<subseteq> cone A" unfolding cone_def
	+ using fin[OF fin_dim _ subset_trans[OF _ A]] by auto
	+ {
	+ fix a
	+ assume "a \<in> cone A"
	+ from this[unfolded cone_def] obtain B where
	+ finB: "finite B" and BA: "B \<subseteq> A" and a: "a \<in> finite_cone B" by auto
	+ from BA A have B: "B \<subseteq> carrier_vec n" by auto
	+ hence "a \<in> cone B" using finB a by (simp add: cone_iff_finite_cone)
	+ with fundamental_theorem_of_linear_inequalities(1)[OF B finB]
	+ obtain C where CB: "C \<subseteq> B" and a: "a \<in> finite_cone C" and "lin_indpt C" by auto
	+ with BA have "a \<in> \<Union> {finite_cone B \|B. B \<subseteq> A \<and> lin_indpt B}" by auto
	+ }
	+ thus "\<Union> {finite_cone B \|B. B \<subseteq> A \<and> lin_indpt B} \<supseteq> cone A" by blast
	+qed
	+end
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Integer_Hull.thy b/thys/Linear_Inequalities/Integer_Hull.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Integer_Hull.thy
	@@ -0,0 +1,364 @@
	+section \<open>Integer Hull\<close>
	+
	+text \<open>We define the integer hull of a polyhedron, i.e., the convex hull of all integer solutions.
	+ Moreover, we prove the result of Meyer that the integer hull of a polyhedron defined by an
	+ integer matrix is again a polyhedron, and give bounds for a corresponding decomposition theorem.\<close>
	+
	+theory Integer_Hull
	+ imports
	+ Decomposition_Theorem
	+ Mixed_Integer_Solutions (* for gram-schmidt-floor *)
	+begin
	+
	+context gram_schmidt
	+begin
	+definition "integer_hull P = convex_hull (P \<inter> \<int>\<^sub>v)"
	+
	+lemma integer_hull_mono: "P \<subseteq> Q \<Longrightarrow> integer_hull P \<subseteq> integer_hull Q"
	+ unfolding integer_hull_def
	+ by (intro convex_hull_mono, auto)
	+
	+end
	+
	+lemma abs_neg_floor: "\<bar>of_int b\<bar> \<le> Bnd \<Longrightarrow> - (floor Bnd) \<le> b"
	+ using abs_le_D2 floor_mono by fastforce
	+
	+lemma abs_pos_floor: "\<bar>of_int b\<bar> \<le> Bnd \<Longrightarrow> b \<le> floor Bnd"
	+ using abs_le_D1 le_floor_iff by auto
	+
	+context gram_schmidt_floor
	+begin
	+
	+lemma integer_hull_integer_cone: assumes C: "C \<subseteq> carrier_vec n"
	+ and CI: "C \<subseteq> \<int>\<^sub>v"
	+ shows "integer_hull (cone C) = cone C"
	+proof
	+ have "cone C \<inter> \<int>\<^sub>v \<subseteq> cone C" by blast
	+ thus "integer_hull (cone C) \<subseteq> cone C"
	+ using cone_cone[OF C] convex_cone[OF C] convex_hull_mono
	+ unfolding integer_hull_def convex_def by metis
	+ {
	+ fix x
	+ assume "x \<in> cone C"
	+ then obtain D where finD: "finite D" and DC: "D \<subseteq> C" and x: "x \<in> finite_cone D"
	+ unfolding cone_def by auto
	+ from DC C CI have D: "D \<subseteq> carrier_vec n" and DI: "D \<subseteq> \<int>\<^sub>v" by auto
	+ from D x finD have "x \<in> finite_cone (D \<union> {0\<^sub>v n})" using finite_cone_mono[of "D \<union> {0\<^sub>v n}" D] by auto
	+ then obtain l where x: "lincomb l (D \<union> {0\<^sub>v n}) = x"
	+ and l: "l ` (D \<union> {0\<^sub>v n}) \<subseteq> {t. t \<ge> 0}"
	+ using finD unfolding finite_cone_def nonneg_lincomb_def by auto
	+ define L where "L = sum l (D \<union> {0\<^sub>v n})"
	+ define L_sup :: 'a where "L_sup = of_int (floor L + 1)"
	+ have "L_sup \<ge> L" using floor_correct[of L] unfolding L_sup_def by linarith
	+ have "L \<ge> 0" unfolding L_def using sum_nonneg[of _ l] l by blast
	+ hence "L_sup \<ge> 1" unfolding L_sup_def by simp
	+ hence "L_sup > 0" by fastforce
	+
	+ let ?f = "\<lambda> y. if y = 0\<^sub>v n then L_sup - L else 0"
	+ have "lincomb ?f {0\<^sub>v n} = 0\<^sub>v n"
	+ using already_in_span[of "{}" "0\<^sub>v n"] lincomb_in_span local.span_empty
	+ by auto
	+ moreover have "lincomb ?f (D - {0\<^sub>v n}) = 0\<^sub>v n"
	+ by(rule lincomb_zero, insert D, auto)
	+ ultimately have "lincomb ?f (D \<union> {0\<^sub>v n}) = 0\<^sub>v n"
	+ using lincomb_vec_diff_add[of "D \<union> {0\<^sub>v n}" "{0\<^sub>v n}"] D finD by simp
	+ hence lcomb_f: "lincomb (\<lambda> y. l y + ?f y) (D \<union> {0\<^sub>v n}) = x"
	+ using lincomb_sum[of "D \<union> {0\<^sub>v n}" l ?f] finD D x by simp
	+ have "sum ?f (D \<union> {0\<^sub>v n}) = L_sup - L"
	+ by (simp add: sum.subset_diff[of "{0\<^sub>v n}" "D \<union> {0\<^sub>v n}" ?f] finD)
	+ hence "sum (\<lambda> y. l y + ?f y) (D \<union> {0\<^sub>v n}) = L_sup"
	+ using l L_def by auto
	+ moreover have "(\<lambda> y. l y + ?f y) ` (D \<union> {0\<^sub>v n}) \<subseteq> {t. t \<ge> 0}"
	+ using `L \<le> L_sup` l by force
	+ ultimately obtain l' where x: "lincomb l' (D \<union> {0\<^sub>v n}) = x"
	+ and l': "l' ` (D \<union> {0\<^sub>v n}) \<subseteq> {t. t \<ge> 0}"
	+ and sum_l': "sum l' (D \<union> {0\<^sub>v n}) = L_sup"
	+ using lcomb_f by blast
	+
	+ let ?D' = "{L_sup \<cdot>\<^sub>v v \| v. v \<in> D \<union> {0\<^sub>v n}}"
	+ have Did: "?D' = (\<lambda> v. L_sup \<cdot>\<^sub>v v) ` (D \<union> {0\<^sub>v n})" by force
	+ define l'' where "l'' = (\<lambda> y. l' ((1 / L_sup) \<cdot>\<^sub>v y) / L_sup)"
	+ obtain lD where dist: "distinct lD" and lD: "D \<union> {0\<^sub>v n} = set lD"
	+ using finite_distinct_list[of "D \<union> {0\<^sub>v n}"] finD by auto
	+ let ?lD' = "map ((\<cdot>\<^sub>v) L_sup) lD"
	+ have dist': "distinct ?lD'"
	+ using distinct_smult_nonneg[OF _ dist] `L_sup > 0` by fastforce
	+
	+ have x': "lincomb l'' ?D' = x" unfolding x[symmetric] l''_def
	+ unfolding lincomb_def Did
	+ proof (subst finsum_reindex)
	+ from `L_sup > 0` smult_vec_nonneg_eq[of L_sup] show "inj_on ((\<cdot>\<^sub>v) L_sup) (D \<union> {0\<^sub>v n})"
	+ by (auto simp: inj_on_def)
	+ show "(\<lambda>v. l' (1 / L_sup \<cdot>\<^sub>v v) / L_sup \<cdot>\<^sub>v v) \<in> (\<cdot>\<^sub>v) L_sup ` (D \<union> {0\<^sub>v n}) \<rightarrow> carrier_vec n"
	+ using D by auto
	+ from `L_sup > 0` have "L_sup \<noteq> 0" by auto
	+ then show "(\<Oplus>\<^bsub>V\<^esub>x\<in>D \<union> {0\<^sub>v n}. l' (1 / L_sup \<cdot>\<^sub>v (L_sup \<cdot>\<^sub>v x)) / L_sup \<cdot>\<^sub>v (L_sup \<cdot>\<^sub>v x)) =
	+ (\<Oplus>\<^bsub>V\<^esub>v\<in>D \<union> {0\<^sub>v n}. l' v \<cdot>\<^sub>v v)"
	+ by (intro finsum_cong, insert D, auto simp: smult_smult_assoc)
	+ qed
	+ have "D \<union> {0\<^sub>v n} \<subseteq> cone C" using set_in_cone[OF C] DC zero_in_cone by blast
	+ hence D': "?D' \<subseteq> cone C" using cone_smult[of L_sup, OF _ C] `L_sup > 0` by auto
	+ have "D \<union> {0\<^sub>v n} \<subseteq> \<int>\<^sub>v" unfolding zero_vec_def using DI Ints_vec_def by auto
	+ moreover have "L_sup \<in> \<int>" unfolding L_sup_def by auto
	+ ultimately have D'I: "?D' \<subseteq> \<int>\<^sub>v" unfolding Ints_vec_def by force
	+
	+ have "1 = sum l' (D \<union> {0\<^sub>v n}) * (1 / L_sup)" using sum_l' `L_sup > 0` by auto
	+ also have "sum l' (D \<union> {0\<^sub>v n}) = sum_list (map l' lD)"
	+ using sum.distinct_set_conv_list[OF dist] lD by auto
	+ also have "map l' lD = map (l' \<circ> ((\<cdot>\<^sub>v) (1 / L_sup))) ?lD'"
	+ using smult_smult_assoc[of "1 / L_sup" L_sup] `L_sup > 0`
	+ by (simp add: comp_assoc)
	+ also have "l' \<circ> ((\<cdot>\<^sub>v) (1 / L_sup)) = (\<lambda> x. l' ((1 / L_sup) \<cdot>\<^sub>v x))" by (rule comp_def)
	+ also have "sum_list (map \<dots> ?lD') * (1 / L_sup) =
	+ sum_list (map (\<lambda>y. l' (1 / L_sup \<cdot>\<^sub>v y) * (1 / L_sup)) ?lD')"
	+ using sum_list_mult_const[of _ "1 / L_sup" ?lD'] by presburger
	+ also have "\<dots> = sum_list (map l'' ?lD')"
	+ unfolding l''_def using `L_sup > 0` by simp
	+ also have "\<dots> = sum l'' (set ?lD')" using sum.distinct_set_conv_list[OF dist'] by metis
	+ also have "set ?lD' = ?D'" using lD by auto
	+ finally have sum_l': "sum l'' ?D' = 1" by auto
	+
	+ moreover have "l'' ` ?D' \<subseteq> {t. t \<ge> 0}"
	+ proof
	+ fix y
	+ assume "y \<in> l'' ` ?D'"
	+ then obtain x where y: "y = l'' x" and "x \<in> ?D'" by blast
	+ then obtain v where "v \<in> D \<union> {0\<^sub>v n}" and x: "x = L_sup \<cdot>\<^sub>v v" by blast
	+ hence "0 \<le> l' v / L_sup" using l' `L_sup > 0` by fastforce
	+ also have "\<dots> = l'' x" unfolding x l''_def
	+ using smult_smult_assoc[of "1 / L_sup" "L_sup" v] `L_sup > 0` by simp
	+ finally show "y \<in> {t. t \<ge> 0}" using y by blast
	+ qed
	+ moreover have "finite ?D'" using finD by simp
	+
	+ ultimately have "x \<in> integer_hull (cone C)"
	+ unfolding integer_hull_def convex_hull_def
	+ using x' D' D'I convex_lincomb_def[of l'' ?D' x]
	+ nonneg_lincomb_def[of l'' ?D' x] by fast
	+ }
	+ thus "cone C \<subseteq> integer_hull (cone C)" by blast
	+qed
	+
	+theorem decomposition_theorem_integer_hull_of_polyhedron: assumes A: "A \<in> carrier_mat nr n"
	+ and b: "b \<in> carrier_vec nr"
	+ and AI: "A \<in> \<int>\<^sub>m"
	+ and bI: "b \<in> \<int>\<^sub>v"
	+ and P: "P = polyhedron A b"
	+ and Bnd: "Bnd = Max (abs ` (elements_mat A \<union> vec_set b))"
	+shows "\<exists> H C. H \<union> C \<subseteq> carrier_vec n \<inter> \<int>\<^sub>v
	+ \<and> H \<subseteq> Bounded_vec (fact (n+1) * (max 1 Bnd)^n)
	+ \<and> C \<subseteq> Bounded_vec (fact n * (max 1 Bnd)^n)
	+ \<and> finite (H \<union> C)
	+ \<and> integer_hull P = convex_hull H + cone C"
	+proof -
	+ define DBnd where "DBnd = det_bound n (max 1 Bnd)"
	+ define nBnd where "nBnd = of_nat (n+1) * DBnd"
	+ have DBnd: "DBnd = fact n * (max 1 Bnd)^n" unfolding DBnd_def det_bound_def by auto
	+ have nBnd: "nBnd = fact (n+1) * (max 1 Bnd)^n" unfolding nBnd_def DBnd
	+ by auto
	+ have DBnd0: "DBnd \<ge> 0" unfolding DBnd_def det_bound_def by auto
	+ have Pn: "P \<subseteq> carrier_vec n" unfolding P polyhedron_def by auto
	+ have "A \<in> Bounded_mat Bnd \<and> b \<in> Bounded_vec Bnd"
	+ unfolding Bnd Bounded_mat_elements_mat Bounded_vec_vec_set
	+ by (intro ballI conjI Max_ge finite_imageI imageI finite_UnI, auto)
	+ from decomposition_theorem_polyhedra_1[OF A b P, of Bnd] AI bI this
	+ obtain QQ Q C where C: "C \<subseteq> carrier_vec n" and finC: "finite C"
	+ and QQ: "QQ \<subseteq> carrier_vec n" and finQ: "finite QQ" and BndQQ: "QQ \<subseteq> Bounded_vec DBnd"
	+ and P: "P = Q + cone C"
	+ and Q_def: "Q = convex_hull QQ"
	+ and CI: "C \<subseteq> \<int>\<^sub>v" and BndC: "C \<subseteq> Bounded_vec DBnd"
	+ by (auto simp: DBnd_def)
	+ define Bnd' where "Bnd' = of_nat n * DBnd"
	+ note coneC = cone_iff_finite_cone[OF C finC]
	+ have Q: "Q \<subseteq> carrier_vec n" unfolding Q_def using convex_hull_carrier[OF QQ] .
	+ define B where "B = {x. \<exists> a D. nonneg_lincomb a D x \<and> D \<subseteq> C \<and> lin_indpt D \<and> (\<forall> d \<in> D. a d \<le> 1)}"
	+ {
	+ fix b
	+ assume "b \<in> B"
	+ then obtain a D where b: "b = lincomb a D" and DC: "D \<subseteq> C"
	+ and linD: "lin_indpt D" and bnd_a: "\<forall> d \<in> D. 0 \<le> a d \<and> a d \<le> 1"
	+ by (force simp: B_def nonneg_lincomb_def)
	+ from DC C have D: "D \<subseteq> carrier_vec n" by auto
	+ from DC finC have finD: "finite D" by (metis finite_subset)
	+ from D linD finD have cardD: "card D \<le> n" using dim_is_n li_le_dim(2) by auto
	+ from BndC DC have BndD: "D \<subseteq> Bounded_vec DBnd" by auto
	+ from lincomb_card_bound[OF this D DBnd0 _ cardD, of a, folded b] bnd_a
	+ have "b \<in> Bounded_vec Bnd'" unfolding Bnd'_def by force
	+ }
	+ hence BndB: "B \<subseteq> Bounded_vec Bnd'" ..
	+ from BndQQ have BndQ: "Q \<subseteq> Bounded_vec DBnd" unfolding Q_def using QQ by (metis convex_hull_bound)
	+ have B: "B \<subseteq> carrier_vec n"
	+ unfolding B_def nonneg_lincomb_def using C by auto
	+ from Q B have QB: "Q + B \<subseteq> carrier_vec n" by (auto elim!: set_plus_elim)
	+ from sum_in_Bounded_vecI[of _ DBnd _ Bnd' n] BndQ BndB B Q
	+ have "Q + B \<subseteq> Bounded_vec (DBnd + Bnd')" by (auto elim!: set_plus_elim)
	+ also have "DBnd + Bnd' = nBnd" unfolding nBnd_def Bnd'_def by (simp add: algebra_simps)
	+ finally have QB_Bnd: "Q + B \<subseteq> Bounded_vec nBnd" by blast
	+ have finQBZ: "finite ((Q + B) \<inter> \<int>\<^sub>v)"
	+ proof (rule finite_subset[OF subsetI])
	+ define ZBnd where "ZBnd = floor nBnd"
	+ let ?vecs = "set (map vec_of_list (concat_lists (map (\<lambda> i. map (of_int :: _ \<Rightarrow> 'a) [-ZBnd..ZBnd]) [0..<n])))"
	+ have id: "?vecs = vec_of_list `
	+ {as. length as = n \<and> (\<forall>i<n. \<exists> b. as ! i = of_int b \<and> b \<in> {- ZBnd..ZBnd})}"
	+ unfolding set_map by (rule image_cong, auto)
	+ show "finite ?vecs" by (rule finite_set)
	+ fix x
	+ assume "x \<in> (Q + B) \<inter> \<int>\<^sub>v"
	+ hence xQB: "x \<in> Q + B" and xI: "x \<in> \<int>\<^sub>v" by auto
	+ from xQB QB_Bnd QB have xBnd: "x \<in> Bounded_vec nBnd" and x: "x \<in> carrier_vec n" by auto
	+ have xid: "x = vec_of_list (list_of_vec x)" by auto
	+ show "x \<in> ?vecs" unfolding id
	+ proof (subst xid, intro imageI CollectI conjI allI impI)
	+ show "length (list_of_vec x) = n" using x by auto
	+ fix i
	+ assume i: "i < n"
	+ have id: "list_of_vec x ! i = x $ i" using i x by auto
	+ from xBnd[unfolded Bounded_vec_def] i x have xiBnd: "abs (x $ i) \<le> nBnd" by auto
	+ from xI[unfolded Ints_vec_def] i x have "x $ i \<in> \<int>" by auto
	+ then obtain b where b: "x $ i = of_int b" unfolding Ints_def by blast
	+ show "\<exists>b. list_of_vec x ! i = of_int b \<and> b \<in> {- ZBnd..ZBnd}" unfolding id ZBnd_def
	+ using xiBnd unfolding b by (intro exI[of _ b], auto intro!: abs_neg_floor abs_pos_floor)
	+ qed
	+ qed
	+ have QBZ: "(Q + B) \<inter> \<int>\<^sub>v \<subseteq> carrier_vec n" using QB by auto
	+ from decomposition_theorem_polyhedra_2[OF QBZ finQBZ, folded integer_hull_def, OF C finC refl]
	+ obtain A' b' nr' where A': "A' \<in> carrier_mat nr' n" and b': "b' \<in> carrier_vec nr'"
	+ and IH: "integer_hull (Q + B) + cone C = polyhedron A' b'"
	+ by auto
	+ {
	+ fix p
	+ assume "p \<in> P \<inter> \<int>\<^sub>v"
	+ hence pI: "p \<in> \<int>\<^sub>v" and p: "p \<in> Q + cone C" unfolding P by auto
	+ from set_plus_elim[OF p] obtain q c where
	+ pqc: "p = q + c" and qQ: "q \<in> Q" and cC: "c \<in> cone C" by auto
	+ from qQ Q have q: "q \<in> carrier_vec n" by auto
	+ from Caratheodory_theorem[OF C] cC
	+ obtain D where cD: "c \<in> finite_cone D" and DC: "D \<subseteq> C" and linD: "lin_indpt D" by auto
	+ from DC C have D: "D \<subseteq> carrier_vec n" by auto
	+ from DC finC have finD: "finite D" by (metis finite_subset)
	+ from cD finD
	+ obtain a where "nonneg_lincomb a D c" unfolding finite_cone_def by auto
	+ hence caD: "c = lincomb a D" and a0: "\<And> d. d \<in> D \<Longrightarrow> a d \<ge> 0"
	+ unfolding nonneg_lincomb_def by auto
	+ define a1 where "a1 = (\<lambda> c. a c - of_int (floor (a c)))"
	+ define a2 where "a2 = (\<lambda> c. of_int (floor (a c)) :: 'a)"
	+ define d where "d = lincomb a2 D"
	+ define b where "b = lincomb a1 D"
	+ have b: "b \<in> carrier_vec n" and d: "d \<in> carrier_vec n" unfolding d_def b_def using D by auto
	+ have bB: "b \<in> B" unfolding B_def b_def nonneg_lincomb_def
	+ proof (intro CollectI exI[of _ a1] exI[of _ D] conjI ballI refl subsetI linD)
	+ show "x \<in> a1 ` D \<Longrightarrow> 0 \<le> x" for x using a0 unfolding a1_def by auto
	+ show "a1 c \<le> 1" for c unfolding a1_def by linarith
	+ qed (insert DC, auto)
	+ have cbd: "c = b + d" unfolding b_def d_def caD lincomb_sum[OF finD D, symmetric]
	+ by (rule lincomb_cong[OF refl D], auto simp: a1_def a2_def)
	+ have "nonneg_lincomb a2 D d" unfolding d_def nonneg_lincomb_def
	+ by (intro allI conjI refl subsetI, insert a0, auto simp: a2_def)
	+ hence dC: "d \<in> cone C" unfolding cone_def finite_cone_def using finC finD DC by auto
	+ have p: "p = (q + b) + d" unfolding pqc cbd using q b d by auto
	+ have dI: "d \<in> \<int>\<^sub>v" using CI DC C unfolding d_def indexed_Ints_vec_UNIV
	+ by (intro lincomb_indexed_Ints_vec, auto simp: a2_def)
	+ from diff_indexed_Ints_vec[of _ _ _ UNIV, folded indexed_Ints_vec_UNIV, OF _ d pI dI, unfolded p]
	+ have "q + b + d - d \<in> \<int>\<^sub>v" using q b d by auto
	+ also have "q + b + d - d = q + b" using q b d by auto
	+ finally have qbI: "q + b \<in> \<int>\<^sub>v" by auto
	+ have "p \<in> integer_hull (Q + B) + cone C" unfolding p integer_hull_def
	+ by (intro set_plus_intro dC set_mp[OF set_in_convex_hull] IntI qQ bB qbI, insert Q B,
	+ auto elim!: set_plus_elim)
	+ }
	+ hence "P \<inter> \<int>\<^sub>v \<subseteq> integer_hull (Q + B) + cone C" by auto
	+ hence one_dir: "integer_hull P \<subseteq> integer_hull (Q + B) + cone C" unfolding IH
	+ unfolding integer_hull_def using convex_convex_hull[OF polyhedra_are_convex[OF A' b' refl]]
	+ convex_hull_mono by blast
	+ have "integer_hull (Q + B) + cone C \<subseteq> integer_hull P + cone C" unfolding P
	+ proof (intro set_plus_mono2 subset_refl integer_hull_mono)
	+ show "B \<subseteq> cone C" unfolding B_def cone_def finite_cone_def using finite_subset[OF _ finC] by auto
	+ qed
	+ also have "\<dots> = integer_hull P + integer_hull (cone C)"
	+ using integer_hull_integer_cone[OF C CI] by simp
	+ also have "\<dots> = convex_hull (P \<inter> \<int>\<^sub>v) + convex_hull (cone C \<inter> \<int>\<^sub>v)"
	+ unfolding integer_hull_def by simp
	+ also have "\<dots> = convex_hull ((P \<inter> \<int>\<^sub>v) + (cone C \<inter> \<int>\<^sub>v))"
	+ by (rule convex_hull_sum[symmetric], insert Pn cone_carrier[OF C], auto)
	+ also have "\<dots> \<subseteq> convex_hull ((P + cone C) \<inter> \<int>\<^sub>v)"
	+ proof (rule convex_hull_mono)
	+ show "P \<inter> \<int>\<^sub>v + cone C \<inter> \<int>\<^sub>v \<subseteq> (P + cone C) \<inter> \<int>\<^sub>v"
	+ using add_indexed_Ints_vec[of _ n _ UNIV, folded indexed_Ints_vec_UNIV] cone_carrier[OF C] Pn
	+ by (auto elim!: set_plus_elim)
	+ qed
	+ also have "\<dots> = integer_hull (P + cone C)" unfolding integer_hull_def ..
	+ also have "P + cone C = P"
	+ proof -
	+ have CC: "cone C \<subseteq> carrier_vec n" using C by (rule cone_carrier)
	+ have "P + cone C = Q + (cone C + cone C)" unfolding P
	+ by (rule assoc_add_vecset[symmetric, OF Q CC CC])
	+ also have "cone C + cone C = cone C" by (rule cone_add_cone[OF C])
	+ finally show ?thesis unfolding P .
	+ qed
	+ finally have "integer_hull (Q + B) + cone C \<subseteq> integer_hull P" .
	+ with one_dir have id: "integer_hull P = integer_hull (Q + B) + cone C" by auto
	+ show ?thesis unfolding id unfolding integer_hull_def nBnd[symmetric] DBnd[symmetric]
	+ proof (rule exI[of _ "(Q + B) \<inter> \<int>\<^sub>v"], intro exI[of _ C] conjI refl BndC)
	+ from QB_Bnd show "(Q + B) \<inter> \<int>\<^sub>v \<subseteq> Bounded_vec nBnd" by auto
	+ show "(Q + B) \<inter> \<int>\<^sub>v \<union> C \<subseteq> carrier_vec n \<inter> \<int>\<^sub>v"
	+ using QB C CI by auto
	+ show "finite ((Q + B) \<inter> \<int>\<^sub>v \<union> C)" using finQBZ finC by auto
	+ qed
	+qed
	+
	+corollary integer_hull_of_polyhedron: assumes A: "A \<in> carrier_mat nr n"
	+ and b: "b \<in> carrier_vec nr"
	+ and AI: "A \<in> \<int>\<^sub>m"
	+ and bI: "b \<in> \<int>\<^sub>v"
	+ and P: "P = polyhedron A b"
	+shows "\<exists> A' b' nr'. A' \<in> carrier_mat nr' n \<and> b' \<in> carrier_vec nr' \<and> integer_hull P = polyhedron A' b'"
	+proof -
	+ from decomposition_theorem_integer_hull_of_polyhedron[OF A b AI bI P refl]
	+ obtain H C
	+ where HC: "H \<union> C \<subseteq> carrier_vec n \<inter> \<int>\<^sub>v" "finite (H \<union> C)"
	+ and decomp: "integer_hull P = convex_hull H + cone C" by auto
	+ show ?thesis
	+ by (rule decomposition_theorem_polyhedra_2[OF _ _ _ _ decomp], insert HC, auto)
	+qed
	+
	+corollary small_integer_solution_nonstrict_via_decomp: fixes A :: "'a mat"
	+ assumes A: "A \<in> carrier_mat nr n"
	+ and b: "b \<in> carrier_vec nr"
	+ and AI: "A \<in> \<int>\<^sub>m"
	+ and bI: "b \<in> \<int>\<^sub>v"
	+ and Bnd: "Bnd = Max (abs ` (elements_mat A \<union> vec_set b))"
	+ and x: "x \<in> carrier_vec n"
	+ and xI: "x \<in> \<int>\<^sub>v"
	+ and sol: "A *\<^sub>v x \<le> b"
	+ shows "\<exists> y.
	+ y \<in> carrier_vec n \<and>
	+ y \<in> \<int>\<^sub>v \<and>
	+ A *\<^sub>v y \<le> b \<and>
	+ y \<in> Bounded_vec (fact (n+1) * (max 1 Bnd)^n)"
	+proof -
	+ from x sol have "x \<in> polyhedron A b" unfolding polyhedron_def by auto
	+ with xI x have xsol: "x \<in> integer_hull (polyhedron A b)" unfolding integer_hull_def
	+ by (meson IntI convex_hull_mono in_mono inf_sup_ord(1) inf_sup_ord(2) set_in_convex_hull)
	+ from decomposition_theorem_integer_hull_of_polyhedron[OF A b AI bI refl Bnd]
	+ obtain H C where HC: "H \<union> C \<subseteq> carrier_vec n \<inter> \<int>\<^sub>v"
	+ "H \<subseteq> Bounded_vec (fact (n + 1) * max 1 Bnd ^ n)"
	+ "finite (H \<union> C)" and
	+ id: "integer_hull (polyhedron A b) = convex_hull H + cone C"
	+ by auto
	+ from xsol[unfolded id] have "H \<noteq> {}" unfolding set_plus_def by auto
	+ then obtain h where hH: "h \<in> H" by auto
	+ with set_in_convex_hull have "h \<in> convex_hull H" using HC by auto
	+ moreover have "0\<^sub>v n \<in> cone C" by (intro zero_in_cone)
	+ ultimately have "h + 0\<^sub>v n \<in> integer_hull (polyhedron A b)" unfolding id by auto
	+ also have "h + 0\<^sub>v n = h" using hH HC by auto
	+ also have "integer_hull (polyhedron A b) \<subseteq> convex_hull (polyhedron A b)"
	+ unfolding integer_hull_def by (rule convex_hull_mono, auto)
	+ also have "convex_hull (polyhedron A b) = polyhedron A b" using A b
	+ using convex_convex_hull polyhedra_are_convex by blast
	+ finally have h: "h \<in> carrier_vec n" "A *\<^sub>v h \<le> b" unfolding polyhedron_def by auto
	+ show ?thesis
	+ by (intro exI[of _ h] conjI h, insert HC hH, auto)
	+qed
	+
	+end
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Integral_Bounded_Vectors.thy b/thys/Linear_Inequalities/Integral_Bounded_Vectors.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Integral_Bounded_Vectors.thy
	@@ -0,0 +1,244 @@
	+section \<open>Integral and Bounded Matrices and Vectors\<close>
	+
	+text \<open>We define notions of integral vectors and matrices and bounded vectors and matrices
	+ and prove some preservation lemmas. Moreover, we prove a bound on determinants.\<close>
	+theory Integral_Bounded_Vectors
	+ imports
	+ Missing_VS_Connect
	+ Sum_Vec_Set
	+ LLL_Basis_Reduction.Gram_Schmidt_2 (* for some simp-rules *)
	+begin
	+
	+(* TODO: move into theory Norms *)
	+lemma sq_norm_unit_vec[simp]: assumes i: "i < n"
	+ shows "\<parallel>unit_vec n i\<parallel>\<^sup>2 = (1 :: 'a :: {comm_ring_1,conjugatable_ring})"
	+proof -
	+ from i have id: "[0..<n] = [0..<i] @ [i] @ [Suc i ..< n]"
	+ by (metis append_Cons append_Nil diff_zero length_upt list_trisect)
	+ show ?thesis unfolding sq_norm_vec_def unit_vec_def
	+ by (auto simp: o_def id, subst (1 2) sum_list_0, auto)
	+qed
	+
	+definition Ints_vec ("\<int>\<^sub>v") where
	+ "\<int>\<^sub>v = {x. \<forall> i < dim_vec x. x $ i \<in> \<int>}"
	+
	+definition indexed_Ints_vec where
	+ "indexed_Ints_vec I = {x. \<forall> i < dim_vec x. i \<in> I \<longrightarrow> x $ i \<in> \<int>}"
	+
	+lemma indexed_Ints_vec_UNIV: "\<int>\<^sub>v = indexed_Ints_vec UNIV"
	+ unfolding Ints_vec_def indexed_Ints_vec_def by auto
	+
	+lemma indexed_Ints_vec_subset: "\<int>\<^sub>v \<subseteq> indexed_Ints_vec I"
	+ unfolding Ints_vec_def indexed_Ints_vec_def by auto
	+
	+lemma Ints_vec_vec_set: "v \<in> \<int>\<^sub>v = (vec_set v \<subseteq> \<int>)"
	+ unfolding Ints_vec_def vec_set_def by auto
	+
	+definition Ints_mat ("\<int>\<^sub>m") where
	+ "\<int>\<^sub>m = {A. \<forall> i < dim_row A. \<forall> j < dim_col A. A $$ (i,j) \<in> \<int>}"
	+
	+lemma Ints_mat_elements_mat: "A \<in> \<int>\<^sub>m = (elements_mat A \<subseteq> \<int>)"
	+ unfolding Ints_mat_def elements_mat_def by force
	+
	+lemma minus_in_Ints_vec_iff[simp]: "(-x) \<in> \<int>\<^sub>v \<longleftrightarrow> (x :: 'a :: ring_1 vec) \<in> \<int>\<^sub>v"
	+ unfolding Ints_vec_vec_set by (auto simp: minus_in_Ints_iff)
	+
	+lemma minus_in_Ints_mat_iff[simp]: "(-A) \<in> \<int>\<^sub>m \<longleftrightarrow> (A :: 'a :: ring_1 mat) \<in> \<int>\<^sub>m"
	+ unfolding Ints_mat_elements_mat by (auto simp: minus_in_Ints_iff)
	+
	+lemma Ints_vec_rows_Ints_mat[simp]: "set (rows A) \<subseteq> \<int>\<^sub>v \<longleftrightarrow> A \<in> \<int>\<^sub>m"
	+ unfolding rows_def Ints_vec_def Ints_mat_def by force
	+
	+lemma unit_vec_integral[simp,intro]: "unit_vec n i \<in> \<int>\<^sub>v"
	+ unfolding Ints_vec_def by (auto simp: unit_vec_def)
	+
	+lemma diff_indexed_Ints_vec:
	+ "x \<in> carrier_vec n \<Longrightarrow> y \<in> carrier_vec n \<Longrightarrow> x \<in> indexed_Ints_vec I \<Longrightarrow> y \<in> indexed_Ints_vec I
	+ \<Longrightarrow> x - y \<in> indexed_Ints_vec I"
	+ unfolding indexed_Ints_vec_def by auto
	+
	+lemma smult_indexed_Ints_vec: "x \<in> \<int> \<Longrightarrow> v \<in> indexed_Ints_vec I \<Longrightarrow> x \<cdot>\<^sub>v v \<in> indexed_Ints_vec I"
	+ unfolding indexed_Ints_vec_def smult_vec_def by simp
	+
	+lemma add_indexed_Ints_vec:
	+ "x \<in> carrier_vec n \<Longrightarrow> y \<in> carrier_vec n \<Longrightarrow> x \<in> indexed_Ints_vec I \<Longrightarrow> y \<in> indexed_Ints_vec I
	+ \<Longrightarrow> x + y \<in> indexed_Ints_vec I"
	+ unfolding indexed_Ints_vec_def by auto
	+
	+lemma (in vec_space) lincomb_indexed_Ints_vec: assumes cI: "\<And> x. x \<in> C \<Longrightarrow> c x \<in> \<int>"
	+ and C: "C \<subseteq> carrier_vec n"
	+ and CI: "C \<subseteq> indexed_Ints_vec I"
	+shows "lincomb c C \<in> indexed_Ints_vec I"
	+proof -
	+ from C have id: "dim_vec (lincomb c C) = n" by auto
	+ show ?thesis unfolding indexed_Ints_vec_def mem_Collect_eq id
	+ proof (intro allI impI)
	+ fix i
	+ assume i: "i < n" and iI: "i \<in> I"
	+ have "lincomb c C $ i = (\<Sum>x\<in>C. c x * x $ i)"
	+ by (rule lincomb_index[OF i C])
	+ also have "\<dots> \<in> \<int>"
	+ by (intro Ints_sum Ints_mult cI, insert i iI CI[unfolded indexed_Ints_vec_def] C, force+)
	+ finally show "lincomb c C $ i \<in> \<int>" .
	+ qed
	+qed
	+
	+definition "Bounded_vec (b :: 'a :: linordered_idom) = {x . \<forall> i < dim_vec x . abs (x $ i) \<le> b}"
	+
	+lemma Bounded_vec_vec_set: "v \<in> Bounded_vec b \<longleftrightarrow> (\<forall> x \<in> vec_set v. abs x \<le> b)"
	+ unfolding Bounded_vec_def vec_set_def by auto
	+
	+definition "Bounded_mat (b :: 'a :: linordered_idom) =
	+ {A . (\<forall> i < dim_row A . \<forall> j < dim_col A. abs (A $$ (i,j)) \<le> b)}"
	+
	+lemma Bounded_mat_elements_mat: "A \<in> Bounded_mat b \<longleftrightarrow> (\<forall> x \<in> elements_mat A. abs x \<le> b)"
	+ unfolding Bounded_mat_def elements_mat_def by auto
	+
	+lemma Bounded_vec_rows_Bounded_mat[simp]: "set (rows A) \<subseteq> Bounded_vec B \<longleftrightarrow> A \<in> Bounded_mat B"
	+ unfolding rows_def Bounded_vec_def Bounded_mat_def by force
	+
	+lemma unit_vec_Bounded_vec[simp,intro]: "unit_vec n i \<in> Bounded_vec (max 1 Bnd)"
	+ unfolding Bounded_vec_def unit_vec_def by auto
	+
	+lemma Bounded_matD: assumes "A \<in> Bounded_mat b"
	+ "A \<in> carrier_mat nr nc"
	+shows "i < nr \<Longrightarrow> j < nc \<Longrightarrow> abs (A $$ (i,j)) \<le> b"
	+ using assms unfolding Bounded_mat_def by auto
	+
	+lemma Bounded_vec_mono: "b \<le> B \<Longrightarrow> Bounded_vec b \<subseteq> Bounded_vec B"
	+ unfolding Bounded_vec_def by auto
	+
	+lemma Bounded_mat_mono: "b \<le> B \<Longrightarrow> Bounded_mat b \<subseteq> Bounded_mat B"
	+ unfolding Bounded_mat_def by force
	+
	+lemma finite_Bounded_vec_Max:
	+ assumes A: "A \<subseteq> carrier_vec n"
	+ and fin: "finite A"
	+ shows "A \<subseteq> Bounded_vec (Max { abs (a $ i) \| a i. a \<in> A \<and> i < n})"
	+proof
	+ let ?B = "{ abs (a $ i) \| a i. a \<in> A \<and> i < n}"
	+ have fin: "finite ?B"
	+ by (rule finite_subset[of _ "(\<lambda> (a,i). abs (a $ i)) ` (A \<times> {0 ..< n})"], insert fin, auto)
	+ fix a
	+ assume a: "a \<in> A"
	+ show "a \<in> Bounded_vec (Max ?B)"
	+ unfolding Bounded_vec_def
	+ by (standard, intro allI impI Max_ge[OF fin], insert a A, force)
	+qed
	+
	+definition det_bound :: "nat \<Rightarrow> 'a :: linordered_idom \<Rightarrow> 'a" where
	+ "det_bound n x = fact n * (x^n)"
	+
	+lemma det_bound: assumes A: "A \<in> carrier_mat n n"
	+ and x: "A \<in> Bounded_mat x"
	+shows "abs (det A) \<le> det_bound n x"
	+proof -
	+ have "abs (det A) = abs (\<Sum>p \| p permutes {0..<n}. signof p * (\<Prod>i = 0..<n. A $$ (i, p i)))"
	+ unfolding det_def'[OF A] ..
	+ also have "\<dots> \<le> (\<Sum>p \| p permutes {0..<n}. abs (signof p * (\<Prod>i = 0..<n. A $$ (i, p i))))"
	+ by (rule sum_abs)
	+ also have "\<dots> = (\<Sum>p \| p permutes {0..<n}. (\<Prod>i = 0..<n. abs (A $$ (i, p i))))"
	+ by (rule sum.cong[OF refl], auto simp: abs_mult abs_prod signof_def)
	+ also have "\<dots> \<le> (\<Sum>p \| p permutes {0..<n}. (\<Prod>i = 0..<n. x))"
	+ by (intro sum_mono prod_mono conjI Bounded_matD[OF x A], auto)
	+ also have "\<dots> = fact n * x^n" by (auto simp add: card_permutations)
	+ finally show "abs (det A) \<le> det_bound n x" unfolding det_bound_def by auto
	+qed
	+
	+lemma minus_in_Bounded_vec[simp]:
	+ "(-x) \<in> Bounded_vec b \<longleftrightarrow> x \<in> Bounded_vec b"
	+ unfolding Bounded_vec_def by auto
	+
	+lemma sum_in_Bounded_vecI[intro]: assumes
	+ xB: "x \<in> Bounded_vec B1" and
	+ yB: "y \<in> Bounded_vec B2" and
	+ x: "x \<in> carrier_vec n" and
	+ y: "y \<in> carrier_vec n"
	+shows "x + y \<in> Bounded_vec (B1 + B2)"
	+proof -
	+ from x y have id: "dim_vec (x + y) = n" by auto
	+ show ?thesis unfolding Bounded_vec_def mem_Collect_eq id
	+ proof (intro allI impI)
	+ fix i
	+ assume i: "i < n"
	+ with x y xB yB have *: "abs (x $ i) \<le> B1" "abs (y $ i) \<le> B2"
	+ unfolding Bounded_vec_def by auto
	+ thus "\<bar>(x + y) $ i\<bar> \<le> B1 + B2" using i x y by simp
	+ qed
	+qed
	+
	+lemma (in gram_schmidt) lincomb_card_bound: assumes XBnd: "X \<subseteq> Bounded_vec Bnd"
	+ and X: "X \<subseteq> carrier_vec n"
	+ and Bnd: "Bnd \<ge> 0"
	+ and c: "\<And> x. x \<in> X \<Longrightarrow> abs (c x) \<le> 1"
	+ and card: "card X \<le> k"
	+shows "lincomb c X \<in> Bounded_vec (of_nat k * Bnd)"
	+proof -
	+ from X have dim: "dim_vec (lincomb c X) = n" by auto
	+ show ?thesis unfolding Bounded_vec_def mem_Collect_eq dim
	+ proof (intro allI impI)
	+ fix i
	+ assume i: "i < n"
	+ have "abs (lincomb c X $ i) = abs (\<Sum>x\<in>X. c x * x $ i)"
	+ by (subst lincomb_index[OF i X], auto)
	+ also have "\<dots> \<le> (\<Sum>x\<in>X. abs (c x * x $ i))" by auto
	+ also have "\<dots> = (\<Sum>x\<in>X. abs (c x) * abs (x $ i))" by (auto simp: abs_mult)
	+ also have "\<dots> \<le> (\<Sum>x\<in>X. 1 * abs (x $ i))"
	+ by (rule sum_mono[OF mult_right_mono], insert c, auto)
	+ also have "\<dots> = (\<Sum>x\<in>X. abs (x $ i))" by simp
	+ also have "\<dots> \<le> (\<Sum>x\<in>X. Bnd)"
	+ by (rule sum_mono, insert i XBnd[unfolded Bounded_vec_def] X, force)
	+ also have "\<dots> = of_nat (card X) * Bnd" by simp
	+ also have "\<dots> \<le> of_nat k * Bnd"
	+ by (rule mult_right_mono[OF _ Bnd], insert card, auto)
	+ finally show "abs (lincomb c X $ i) \<le> of_nat k * Bnd" by auto
	+ qed
	+qed
	+
	+lemma bounded_vecset_sum:
	+ assumes Acarr: "A \<subseteq> carrier_vec n"
	+ and Bcarr: "B \<subseteq> carrier_vec n"
	+ and sum: "C = A + B"
	+ and Cbnd: "\<exists> bndC. C \<subseteq> Bounded_vec bndC"
	+ shows "A \<noteq> {} \<Longrightarrow> (\<exists> bndB. B \<subseteq> Bounded_vec bndB)"
	+ and "B \<noteq> {} \<Longrightarrow> (\<exists> bndA. A \<subseteq> Bounded_vec bndA)"
	+proof -
	+ {
	+ fix A B :: "'a vec set"
	+ assume Acarr: "A \<subseteq> carrier_vec n"
	+ assume Bcarr: "B \<subseteq> carrier_vec n"
	+ assume sum: "C = A + B"
	+ assume Ane: "A \<noteq> {}"
	+ have "\<exists> bndB. B \<subseteq> Bounded_vec bndB"
	+ proof(cases "B = {}")
	+ case Bne: False
	+ from Cbnd obtain bndC where bndC: "C \<subseteq> Bounded_vec bndC" by auto
	+ from Ane obtain a where aA: "a \<in> A" and acarr: "a \<in> carrier_vec n" using Acarr by auto
	+ let ?M = "{abs (a $ i) \| i. i < n}"
	+ have finM: "finite ?M" by simp
	+ define nb where "nb = abs bndC + Max ?M"
	+ {
	+ fix b
	+ assume bB: "b \<in> B" and bcarr: "b \<in> carrier_vec n"
	+ have ab: "a + b \<in> Bounded_vec bndC" using aA bB bndC sum by auto
	+ {
	+ fix i
	+ assume i_lt_n: "i < n"
	+ hence ai_le_max: "abs(a $ i) \<le> Max ?M" using acarr finM Max_ge by blast
	+ hence "abs(a $ i + b $ i) \<le> abs bndC"
	+ using ab bcarr acarr index_add_vec(1) i_lt_n unfolding Bounded_vec_def by auto
	+ hence "abs(b $ i) \<le> abs bndC + abs(a $ i)" by simp
	+ hence "abs(b $ i) \<le> nb" using i_lt_n bcarr ai_le_max unfolding nb_def by simp
	+ }
	+ hence "b \<in> Bounded_vec nb" unfolding Bounded_vec_def using bcarr carrier_vecD by blast
	+ }
	+ hence "B \<subseteq> Bounded_vec nb" unfolding Bounded_vec_def using Bcarr by auto
	+ thus ?thesis by auto
	+ qed auto
	+ } note theor = this
	+ show "A \<noteq> {} \<Longrightarrow> (\<exists> bndB. B \<subseteq> Bounded_vec bndB)" using theor[OF Acarr Bcarr sum] by simp
	+ have CBA: "C = B + A" unfolding sum by (rule comm_add_vecset[OF Acarr Bcarr])
	+ show "B \<noteq> {} \<Longrightarrow> \<exists> bndA. A \<subseteq> Bounded_vec bndA" using theor[OF Bcarr Acarr CBA] by simp
	+qed
	+
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Missing_Matrix.thy b/thys/Linear_Inequalities/Missing_Matrix.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Missing_Matrix.thy
	@@ -0,0 +1,458 @@
	+section \<open>Missing Lemmas on Vectors and Matrices\<close>
	+
	+text \<open>We provide some results on vector spaces which should be merged into Jordan-Normal-Form/Matrix.\<close>
	+theory Missing_Matrix
	+ imports Jordan_Normal_Form.Matrix
	+begin
	+
	+lemma orthogonalD': assumes "orthogonal vs"
	+ and "v \<in> set vs" and "w \<in> set vs"
	+shows "(v \<bullet> w = 0) = (v \<noteq> w)"
	+proof -
	+ from assms(2) obtain i where v: "v = vs ! i" and i: "i < length vs" by (auto simp: set_conv_nth)
	+ from assms(3) obtain j where w: "w = vs ! j" and j: "j < length vs" by (auto simp: set_conv_nth)
	+ from orthogonalD[OF assms(1) i j, folded v w] orthogonalD[OF assms(1) i i, folded v v]
	+ show ?thesis using v w by auto
	+qed
	+
	+lemma zero_mat_mult_vector[simp]: "x \<in> carrier_vec nc \<Longrightarrow> 0\<^sub>m nr nc *\<^sub>v x = 0\<^sub>v nr"
	+ by (intro eq_vecI, auto)
	+
	+lemma add_diff_cancel_right_vec:
	+ "a \<in> carrier_vec n \<Longrightarrow> (b :: 'a :: cancel_ab_semigroup_add vec) \<in> carrier_vec n \<Longrightarrow>
	+ (a + b) - b = a"
	+ by (intro eq_vecI, auto)
	+
	+lemma elements_four_block_mat_id:
	+ assumes c: "A \<in> carrier_mat nr1 nc1" "B \<in> carrier_mat nr1 nc2"
	+ "C \<in> carrier_mat nr2 nc1" "D \<in> carrier_mat nr2 nc2"
	+ shows
	+ "elements_mat (four_block_mat A B C D) =
	+ elements_mat A \<union> elements_mat B \<union> elements_mat C \<union> elements_mat D"
	+ (is "elements_mat ?four = ?X")
	+proof
	+ show "elements_mat ?four \<subseteq> ?X"
	+ by (rule elements_four_block_mat[OF c])
	+ have 4: "?four \<in> carrier_mat (nr1 + nr2) (nc1 + nc2)" using c by auto
	+ {
	+ fix x
	+ assume "x \<in> ?X"
	+ then consider (A) "x \<in> elements_mat A"
	+ \| (B) "x \<in> elements_mat B"
	+ \| (C) "x \<in> elements_mat C"
	+ \| (D) "x \<in> elements_mat D" by auto
	+ hence "x \<in> elements_mat ?four"
	+ proof (cases)
	+ case A
	+ from elements_matD[OF this] obtain i j
	+ where *: "i < nr1" "j < nc1" and x: "x = A $$ (i,j)"
	+ using c by auto
	+ from elements_matI[OF 4, of i j x] * c
	+ show ?thesis unfolding x by auto
	+ next
	+ case B
	+ from elements_matD[OF this] obtain i j
	+ where *: "i < nr1" "j < nc2" and x: "x = B $$ (i,j)"
	+ using c by auto
	+ from elements_matI[OF 4, of i "nc1 + j" x] * c
	+ show ?thesis unfolding x by auto
	+ next
	+ case C
	+ from elements_matD[OF this] obtain i j
	+ where *: "i < nr2" "j < nc1" and x: "x = C $$ (i,j)"
	+ using c by auto
	+ from elements_matI[OF 4, of "nr1 + i" j x] * c
	+ show ?thesis unfolding x by auto
	+ next
	+ case D
	+ from elements_matD[OF this] obtain i j
	+ where *: "i < nr2" "j < nc2" and x: "x = D $$ (i,j)"
	+ using c by auto
	+ from elements_matI[OF 4, of "nr1 + i" "nc1 + j" x] * c
	+ show ?thesis unfolding x by auto
	+ qed
	+ }
	+ thus "elements_mat ?four \<supseteq> ?X" by blast
	+qed
	+
	+
	+lemma elements_mat_append_rows: "A \<in> carrier_mat nr n \<Longrightarrow> B \<in> carrier_mat nr2 n \<Longrightarrow>
	+ elements_mat (A @\<^sub>r B) = elements_mat A \<union> elements_mat B"
	+ unfolding append_rows_def
	+ by (subst elements_four_block_mat_id, auto)
	+
	+lemma elements_mat_uminus[simp]: "elements_mat (-A) = uminus ` elements_mat A"
	+ unfolding elements_mat_def by auto
	+
	+lemma vec_set_uminus[simp]: "vec_set (-A) = uminus ` vec_set A"
	+ unfolding vec_set_def by auto
	+
	+definition append_cols :: "'a :: zero mat \<Rightarrow> 'a mat \<Rightarrow> 'a mat" (infixr "@\<^sub>c" 65) where
	+ "A @\<^sub>c B = (A\<^sup>T @\<^sub>r B\<^sup>T)\<^sup>T"
	+
	+lemma carrier_append_cols[simp, intro]:
	+ "A \<in> carrier_mat nr nc1 \<Longrightarrow>
	+ B \<in> carrier_mat nr nc2 \<Longrightarrow> (A @\<^sub>c B) \<in> carrier_mat nr (nc1 + nc2)"
	+ unfolding append_cols_def by auto
	+
	+lemma elements_mat_transpose_mat[simp]: "elements_mat (A\<^sup>T) = elements_mat A"
	+ unfolding elements_mat_def by auto
	+
	+lemma elements_mat_append_cols: "A \<in> carrier_mat n nc \<Longrightarrow> B \<in> carrier_mat n nc1
	+ \<Longrightarrow> elements_mat (A @\<^sub>c B) = elements_mat A \<union> elements_mat B"
	+ unfolding append_cols_def elements_mat_transpose_mat
	+ by (subst elements_mat_append_rows, auto)
	+
	+lemma vec_first_index:
	+ assumes v: "dim_vec v \<ge> n"
	+ and i: "i < n"
	+ shows "(vec_first v n) $ i = v $ i"
	+ unfolding vec_first_def using assms by simp
	+
	+lemma vec_last_index:
	+ assumes v: "v \<in> carrier_vec (n + m)"
	+ and i: "i < m"
	+ shows "(vec_last v m) $ i = v $ (n + i)"
	+ unfolding vec_last_def using assms by simp
	+
	+lemma vec_first_add:
	+ assumes "dim_vec x \<ge> n"
	+ and "dim_vec y \<ge> n"
	+ shows"vec_first (x + y) n = vec_first x n + vec_first y n"
	+ unfolding vec_first_def using assms by auto
	+
	+lemma vec_first_zero[simp]: "m \<le> n \<Longrightarrow> vec_first (0\<^sub>v n) m = 0\<^sub>v m"
	+ unfolding vec_first_def by auto
	+
	+lemma vec_first_smult:
	+ "\<lbrakk> m \<le> n; x \<in> carrier_vec n \<rbrakk> \<Longrightarrow> vec_first (c \<cdot>\<^sub>v x) m = c \<cdot>\<^sub>v vec_first x m"
	+ unfolding vec_first_def by auto
	+
	+lemma elements_mat_mat_of_row[simp]: "elements_mat (mat_of_row v) = vec_set v"
	+ by (auto simp: mat_of_row_def elements_mat_def vec_set_def)
	+
	+lemma vec_set_append_vec[simp]: "vec_set (v @\<^sub>v w) = vec_set v \<union> vec_set w"
	+ by (metis list_of_vec_append set_append set_list_of_vec)
	+
	+lemma vec_set_vNil[simp]: "set\<^sub>v vNil = {}" using set_list_of_vec by force
	+
	+lemma diff_smult_distrib_vec: "((x :: 'a::ring) - y) \<cdot>\<^sub>v v = x \<cdot>\<^sub>v v - y \<cdot>\<^sub>v v"
	+ unfolding smult_vec_def minus_vec_def
	+ by (rule eq_vecI, auto simp: left_diff_distrib)
	+
	+lemma add_diff_eq_vec: fixes y :: "'a :: group_add vec"
	+ shows "y \<in> carrier_vec n \<Longrightarrow> x \<in> carrier_vec n \<Longrightarrow> z \<in> carrier_vec n \<Longrightarrow> y + (x - z) = y + x - z"
	+ by (intro eq_vecI, auto simp: add_diff_eq)
	+
	+definition "mat_of_col v = (mat_of_row v)\<^sup>T"
	+
	+lemma elements_mat_mat_of_col[simp]: "elements_mat (mat_of_col v) = vec_set v"
	+ unfolding mat_of_col_def by auto
	+
	+lemma mat_of_col_dim[simp]: "dim_row (mat_of_col v) = dim_vec v"
	+ "dim_col (mat_of_col v) = 1"
	+ "mat_of_col v \<in> carrier_mat (dim_vec v) 1"
	+ unfolding mat_of_col_def by auto
	+
	+lemma col_mat_of_col[simp]: "col (mat_of_col v) 0 = v"
	+ unfolding mat_of_col_def by auto
	+
	+
	+lemma mult_mat_of_col: "A \<in> carrier_mat nr nc \<Longrightarrow> v \<in> carrier_vec nc \<Longrightarrow>
	+ A * mat_of_col v = mat_of_col (A *\<^sub>v v)"
	+ by (intro mat_col_eqI, auto)
	+
	+lemma mat_mult_append_cols: fixes A :: "'a :: comm_semiring_0 mat"
	+ assumes A: "A \<in> carrier_mat nr nc1"
	+ and B: "B \<in> carrier_mat nr nc2"
	+ and v1: "v1 \<in> carrier_vec nc1"
	+ and v2: "v2 \<in> carrier_vec nc2"
	+ shows "(A @\<^sub>c B) \<^sub>v (v1 @\<^sub>v v2) = A \<^sub>v v1 + B *\<^sub>v v2"
	+proof -
	+ have "(A @\<^sub>c B) \<^sub>v (v1 @\<^sub>v v2) = (A @\<^sub>c B) \<^sub>v col (mat_of_col (v1 @\<^sub>v v2)) 0" by auto
	+ also have "\<dots> = col ((A @\<^sub>c B) * mat_of_col (v1 @\<^sub>v v2)) 0" by auto
	+ also have "(A @\<^sub>c B) * mat_of_col (v1 @\<^sub>v v2) = ((A @\<^sub>c B) * mat_of_col (v1 @\<^sub>v v2))\<^sup>T\<^sup>T"
	+ by auto
	+ also have "((A @\<^sub>c B) * mat_of_col (v1 @\<^sub>v v2))\<^sup>T =
	+ (mat_of_row (v1 @\<^sub>v v2))\<^sup>T\<^sup>T * (A\<^sup>T @\<^sub>r B\<^sup>T)\<^sup>T\<^sup>T"
	+ unfolding append_cols_def mat_of_col_def
	+ proof (rule transpose_mult, force, unfold transpose_carrier_mat, rule mat_of_row_carrier)
	+ have "A\<^sup>T \<in> carrier_mat nc1 nr" using A by auto
	+ moreover have "B\<^sup>T \<in> carrier_mat nc2 nr" using B by auto
	+ ultimately have "A\<^sup>T @\<^sub>r B\<^sup>T \<in> carrier_mat (nc1 + nc2) nr" by auto
	+ hence "dim_row (A\<^sup>T @\<^sub>r B\<^sup>T) = nc1 + nc2" by auto
	+ thus "v1 @\<^sub>v v2 \<in> carrier_vec (dim_row (A\<^sup>T @\<^sub>r B\<^sup>T))" using v1 v2 by auto
	+ qed
	+ also have "\<dots> = (mat_of_row (v1 @\<^sub>v v2)) * (A\<^sup>T @\<^sub>r B\<^sup>T)" by auto
	+ also have "\<dots> = mat_of_row v1 * A\<^sup>T + mat_of_row v2 * B\<^sup>T"
	+ using mat_of_row_mult_append_rows[OF v1 v2] A B by auto
	+ also have "\<dots>\<^sup>T = (mat_of_row v1 * A\<^sup>T)\<^sup>T + (mat_of_row v2 * B\<^sup>T)\<^sup>T"
	+ using transpose_add A B by auto
	+ also have "(mat_of_row v1 * A\<^sup>T)\<^sup>T = A\<^sup>T\<^sup>T * ((mat_of_row v1)\<^sup>T)"
	+ using transpose_mult A v1 transpose_carrier_mat mat_of_row_carrier(1)
	+ by metis
	+ also have "(mat_of_row v2 * B\<^sup>T)\<^sup>T = B\<^sup>T\<^sup>T * ((mat_of_row v2)\<^sup>T)"
	+ using transpose_mult B v2 transpose_carrier_mat mat_of_row_carrier(1)
	+ by metis
	+ also have "A\<^sup>T\<^sup>T * ((mat_of_row v1)\<^sup>T) + B\<^sup>T\<^sup>T * ((mat_of_row v2)\<^sup>T) =
	+ A * mat_of_col v1 + B * mat_of_col v2"
	+ unfolding mat_of_col_def by auto
	+ also have "col \<dots> 0 = col (A * mat_of_col v1) 0 + col (B * mat_of_col v2) 0"
	+ using assms by auto
	+ also have "\<dots> = col (mat_of_col (A \<^sub>v v1)) 0 + col (mat_of_col (B \<^sub>v v2)) 0"
	+ using mult_mat_of_col assms by auto
	+ also have "\<dots> = A \<^sub>v v1 + B \<^sub>v v2" by auto
	+ finally show ?thesis by auto
	+qed
	+
	+lemma vec_first_append:
	+ assumes "v \<in> carrier_vec n"
	+ shows "vec_first (v @\<^sub>v w) n = v"
	+proof -
	+ have "v @\<^sub>v w = vec_first (v @\<^sub>v w) n @\<^sub>v vec_last (v @\<^sub>v w) (dim_vec w)"
	+ using vec_first_last_append assms by simp
	+ thus ?thesis using append_vec_eq[OF assms] by simp
	+qed
	+
	+lemma vec_le_iff_diff_le_0: fixes a :: "'a :: ordered_ab_group_add vec"
	+ shows "(a \<le> b) = (a - b \<le> 0\<^sub>v (dim_vec a))"
	+ unfolding less_eq_vec_def by auto
	+
	+definition "mat_row_first A n \<equiv> mat n (dim_col A) (\<lambda> (i, j). A $$ (i, j))"
	+
	+definition "mat_row_last A n \<equiv> mat n (dim_col A) (\<lambda> (i, j). A $$ (dim_row A - n + i, j))"
	+
	+lemma mat_row_first_carrier[simp]: "mat_row_first A n \<in> carrier_mat n (dim_col A)"
	+ unfolding mat_row_first_def by simp
	+
	+lemma mat_row_first_dim[simp]:
	+ "dim_row (mat_row_first A n) = n"
	+ "dim_col (mat_row_first A n) = dim_col A"
	+ unfolding mat_row_first_def by simp_all
	+
	+lemma mat_row_last_carrier[simp]: "mat_row_last A n \<in> carrier_mat n (dim_col A)"
	+ unfolding mat_row_last_def by simp
	+
	+lemma mat_row_last_dim[simp]:
	+ "dim_row (mat_row_last A n) = n"
	+ "dim_col (mat_row_last A n) = dim_col A"
	+ unfolding mat_row_last_def by simp_all
	+
	+lemma mat_row_first_nth[simp]: "i < n \<Longrightarrow> row (mat_row_first A n) i = row A i"
	+ unfolding mat_row_first_def row_def by fastforce
	+
	+lemma append_rows_nth:
	+ assumes "A \<in> carrier_mat nr1 nc"
	+ and "B \<in> carrier_mat nr2 nc"
	+ shows "i < nr1 \<Longrightarrow> row (A @\<^sub>r B) i = row A i"
	+ and "\<lbrakk> i \<ge> nr1; i < nr1 + nr2 \<rbrakk> \<Longrightarrow> row (A @\<^sub>r B) i = row B (i - nr1)"
	+ unfolding append_rows_def using row_four_block_mat assms by auto
	+
	+lemma mat_of_row_last_nth[simp]:
	+ "i < n \<Longrightarrow> row (mat_row_last A n) i = row A (dim_row A - n + i)"
	+ unfolding mat_row_last_def row_def by auto
	+
	+lemma mat_row_first_last_append:
	+ assumes "dim_row A = m + n"
	+ shows "(mat_row_first A m) @\<^sub>r (mat_row_last A n) = A"
	+proof (rule eq_rowI)
	+ show "dim_row (mat_row_first A m @\<^sub>r mat_row_last A n) = dim_row A"
	+ unfolding append_rows_def using assms by fastforce
	+ show "dim_col (mat_row_first A m @\<^sub>r mat_row_last A n) = dim_col A"
	+ unfolding append_rows_def by fastforce
	+ fix i
	+ assume i: "i < dim_row A"
	+ show "row (mat_row_first A m @\<^sub>r mat_row_last A n) i = row A i"
	+ proof cases
	+ assume i: "i < m"
	+ thus ?thesis using append_rows_nth(1)[OF mat_row_first_carrier[of A m]
	+ mat_row_last_carrier[of A n] i] by simp
	+ next
	+ assume i': "\<not> i < m"
	+ thus ?thesis using append_rows_nth(2)[OF mat_row_first_carrier[of A m]
	+ mat_row_last_carrier[of A n]] i assms by simp
	+ qed
	+qed
	+
	+definition "mat_col_first A n \<equiv> (mat_row_first A\<^sup>T n)\<^sup>T"
	+
	+definition "mat_col_last A n \<equiv> (mat_row_last A\<^sup>T n)\<^sup>T"
	+
	+lemma mat_col_first_carrier[simp]: "mat_col_first A n \<in> carrier_mat (dim_row A) n"
	+ unfolding mat_col_first_def by fastforce
	+
	+lemma mat_col_first_dim[simp]:
	+ "dim_row (mat_col_first A n) = dim_row A"
	+ "dim_col (mat_col_first A n) = n"
	+ unfolding mat_col_first_def by simp_all
	+
	+lemma mat_col_last_carrier[simp]: "mat_col_last A n \<in> carrier_mat (dim_row A) n"
	+ unfolding mat_col_last_def by fastforce
	+
	+lemma mat_col_last_dim[simp]:
	+ "dim_row (mat_col_last A n) = dim_row A"
	+ "dim_col (mat_col_last A n) = n"
	+ unfolding mat_col_last_def by simp_all
	+
	+lemma mat_col_first_nth[simp]:
	+ "\<lbrakk> i < n; i < dim_col A \<rbrakk> \<Longrightarrow> col (mat_col_first A n) i = col A i"
	+ unfolding mat_col_first_def by force
	+
	+lemma append_cols_nth:
	+ assumes "A \<in> carrier_mat nr nc1"
	+ and "B \<in> carrier_mat nr nc2"
	+ shows "i < nc1 \<Longrightarrow> col (A @\<^sub>c B) i = col A i"
	+ and "\<lbrakk> i \<ge> nc1; i < nc1 + nc2 \<rbrakk> \<Longrightarrow> col (A @\<^sub>c B) i = col B (i - nc1)"
	+ unfolding append_cols_def append_rows_def using row_four_block_mat assms
	+ by auto
	+
	+lemma mat_of_col_last_nth[simp]:
	+ "\<lbrakk> i < n; i < dim_col A \<rbrakk> \<Longrightarrow> col (mat_col_last A n) i = col A (dim_col A - n + i)"
	+ unfolding mat_col_last_def by auto
	+
	+lemma mat_col_first_last_append:
	+ assumes "dim_col A = m + n"
	+ shows "(mat_col_first A m) @\<^sub>c (mat_col_last A n) = A"
	+ unfolding append_cols_def mat_col_first_def mat_col_last_def
	+ using mat_row_first_last_append[of "A\<^sup>T"] assms by simp
	+
	+lemma mat_of_row_dim_row_1: "(dim_row A = 1) = (A = mat_of_row (row A 0))"
	+proof
	+ show "dim_row A = 1 \<Longrightarrow> A = mat_of_row (row A 0)" by force
	+ show "A = mat_of_row (row A 0) \<Longrightarrow> dim_row A = 1" using mat_of_row_dim(1) by metis
	+qed
	+
	+lemma mat_of_col_dim_col_1: "(dim_col A = 1) = (A = mat_of_col (col A 0))"
	+proof
	+ show "dim_col A = 1 \<Longrightarrow> A = mat_of_col (col A 0)"
	+ unfolding mat_of_col_def by auto
	+ show "A = mat_of_col (col A 0) \<Longrightarrow> dim_col A = 1" by (metis mat_of_col_dim(2))
	+qed
	+
	+definition vec_of_scal :: "'a \<Rightarrow> 'a vec" where "vec_of_scal x \<equiv> vec 1 (\<lambda> i. x)"
	+
	+lemma vec_of_scal_dim[simp]:
	+ "dim_vec (vec_of_scal x) = 1"
	+ "vec_of_scal x \<in> carrier_vec 1"
	+ unfolding vec_of_scal_def by auto
	+
	+lemma index_vec_of_scal[simp]: "(vec_of_scal x) $ 0 = x"
	+ unfolding vec_of_scal_def by auto
	+
	+lemma row_mat_of_col[simp]: "i < dim_vec v \<Longrightarrow> row (mat_of_col v) i = vec_of_scal (v $ i)"
	+ unfolding mat_of_col_def by auto
	+
	+lemma vec_of_scal_dim_1: "(v \<in> carrier_vec 1) = (v = vec_of_scal (v $ 0))"
	+ by(standard, auto simp del: One_nat_def, metis vec_of_scal_dim(2))
	+
	+lemma mult_mat_of_row_vec_of_scal: fixes x :: "'a :: comm_ring_1"
	+ shows "mat_of_col v *\<^sub>v vec_of_scal x = x \<cdot>\<^sub>v v"
	+ by (auto simp add: scalar_prod_def)
	+
	+lemma smult_pos_vec[simp]: fixes l :: "'a :: linordered_ring_strict"
	+ assumes l: "l > 0"
	+ shows "(l \<cdot>\<^sub>v v \<le> 0\<^sub>v n) = (v \<le> 0\<^sub>v n)"
	+proof (cases "dim_vec v = n")
	+ case True
	+ have "i < n \<Longrightarrow> ((l \<cdot>\<^sub>v v) $ i \<le> 0) \<longleftrightarrow> v $ i \<le> 0" for i using True
	+ mult_le_cancel_left_pos[OF l, of _ 0] by simp
	+ thus ?thesis using True unfolding less_eq_vec_def by auto
	+qed (auto simp: less_eq_vec_def)
	+
	+lemma finite_elements_mat[simp]: "finite (elements_mat A)"
	+ unfolding elements_mat_def by (rule finite_set)
	+
	+lemma finite_vec_set[simp]: "finite (vec_set A)"
	+ unfolding vec_set_def by auto
	+
	+lemma lesseq_vecI: assumes "v \<in> carrier_vec n" "w \<in> carrier_vec n"
	+ "\<And> i. i < n \<Longrightarrow> v $ i \<le> w $ i"
	+shows "v \<le> w"
	+ using assms unfolding less_eq_vec_def by auto
	+
	+lemma lesseq_vecD: assumes "w \<in> carrier_vec n"
	+ and "v \<le> w"
	+ and "i < n"
	+shows "v $ i \<le> w $ i"
	+ using assms unfolding less_eq_vec_def by auto
	+
	+lemma vec_add_mono: fixes a :: "'a :: ordered_ab_semigroup_add vec"
	+ assumes dim: "dim_vec b = dim_vec d"
	+ and ab: "a \<le> b"
	+ and cd: "c \<le> d"
	+ shows "a + c \<le> b + d"
	+proof -
	+ have "\<And> i. i < dim_vec d \<Longrightarrow> (a + c) $ i \<le> (b + d) $ i"
	+ proof -
	+ fix i
	+ assume id: "i < dim_vec d"
	+ have ic: "i < dim_vec c" using id cd unfolding less_eq_vec_def by auto
	+ have ib: "i < dim_vec b" using id dim by auto
	+ have ia: "i < dim_vec a" using ib ab unfolding less_eq_vec_def by auto
	+ have "a $ i \<le> b $ i" using ab ia ib unfolding less_eq_vec_def by auto
	+ moreover have "c $ i \<le> d $ i" using cd ic id unfolding less_eq_vec_def by auto
	+ ultimately have abcdi: "a $ i + c $ i \<le> b $ i + d $ i" using add_mono by auto
	+ have "(a + c) $ i = a $ i + c $ i" using index_add_vec(1) ic by auto
	+ also have "\<dots> \<le> b $ i + d $ i" using abcdi by auto
	+ also have "b $ i + d $ i = (b + d) $ i" using index_add_vec(1) id by auto
	+ finally show "(a + c) $ i \<le> (b + d) $ i" by auto
	+ qed
	+ then show "a + c \<le> b + d" unfolding less_eq_vec_def
	+ using dim index_add_vec(2) cd less_eq_vec_def by auto
	+qed
	+
	+lemma smult_nneg_npos_vec: fixes l :: "'a :: ordered_semiring_0"
	+ assumes l: "l \<ge> 0"
	+ and v: "v \<le> 0\<^sub>v n"
	+ shows "l \<cdot>\<^sub>v v \<le> 0\<^sub>v n"
	+proof -
	+ {
	+ fix i
	+ assume i: "i < n"
	+ then have vi: "v $ i \<le> 0" using v unfolding less_eq_vec_def by simp
	+ then have "(l \<cdot>\<^sub>v v) $ i = l * v $ i" using v i unfolding less_eq_vec_def by auto
	+ also have "l * v $ i \<le> 0" by (rule mult_nonneg_nonpos[OF l vi])
	+ finally have "(l \<cdot>\<^sub>v v) $ i \<le> 0" by auto
	+ }
	+ then show ?thesis using v unfolding less_eq_vec_def by auto
	+qed
	+
	+lemma smult_vec_nonneg_eq: fixes c :: "'a :: field"
	+ shows "c \<noteq> 0 \<Longrightarrow> (c \<cdot>\<^sub>v x = c \<cdot>\<^sub>v y) = (x = y)"
	+proof -
	+ have "c \<noteq> 0 \<Longrightarrow> c \<cdot>\<^sub>v x = c \<cdot>\<^sub>v y \<Longrightarrow> x = y"
	+ by (metis smult_smult_assoc[of "1 / c" "c"] nonzero_divide_eq_eq one_smult_vec)
	+ thus "c \<noteq> 0 \<Longrightarrow> ?thesis" by auto
	+qed
	+
	+lemma distinct_smult_nonneg: fixes c :: "'a :: field"
	+ assumes c: "c \<noteq> 0"
	+ shows "distinct lC \<Longrightarrow> distinct (map ((\<cdot>\<^sub>v) c) lC)"
	+proof (induction lC)
	+ case (Cons v lC)
	+ from Cons.prems have "v \<notin> set lC" by fastforce
	+ hence "c \<cdot>\<^sub>v v \<notin> set (map ((\<cdot>\<^sub>v) c) lC)" using smult_vec_nonneg_eq[OF c] by fastforce
	+ moreover have "map ((\<cdot>\<^sub>v) c) (v # lC) = c \<cdot>\<^sub>v v # map ((\<cdot>\<^sub>v) c) lC" by simp
	+ ultimately show ?case using Cons.IH Cons.prems by simp
	+qed auto
	+
	+lemma exists_vec_append: "(\<exists> x \<in> carrier_vec (n + m). P x) \<longleftrightarrow> (\<exists> x1 \<in> carrier_vec n. \<exists> x2 \<in> carrier_vec m. P (x1 @\<^sub>v x2))"
	+proof
	+ assume "\<exists>x \<in> carrier_vec (n + m). P x"
	+ from this obtain x where xcarr: "x \<in> carrier_vec (n+m)" and Px: "P x" by auto
	+ have "x = vec n (\<lambda> i. x $ i) @\<^sub>v vec m (\<lambda> i. x $ (n + i))"
	+ by (rule eq_vecI, insert xcarr, auto)
	+ hence "P x = P (vec n (\<lambda> i. x $ i) @\<^sub>v vec m (\<lambda> i. x $ (n + i)))" by simp
	+ also have 1: "\<dots>" using xcarr Px calculation by blast
	+ finally show "\<exists>x1\<in>carrier_vec n. \<exists>x2\<in>carrier_vec m. P (x1 @\<^sub>v x2)" using 1 vec_carrier by blast
	+next
	+ assume "(\<exists> x1 \<in> carrier_vec n. \<exists> x2 \<in> carrier_vec m. P (x1 @\<^sub>v x2))"
	+ from this obtain x1 x2 where x1: "x1 \<in> carrier_vec n"
	+ and x2: "x2 \<in> carrier_vec m" and P12: "P (x1 @\<^sub>v x2)" by auto
	+ define x where "x = x1 @\<^sub>v x2"
	+ have xcarr: "x \<in> carrier_vec (n+m)" using x1 x2 by (simp add: x_def)
	+ have "P x" using P12 xcarr using x_def by blast
	+ then show "(\<exists> x \<in> carrier_vec (n + m). P x)" using xcarr by auto
	+qed
	+
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Missing_VS_Connect.thy b/thys/Linear_Inequalities/Missing_VS_Connect.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Missing_VS_Connect.thy
	@@ -0,0 +1,179 @@
	+section \<open>Missing Lemmas on Vector Spaces\<close>
	+
	+text \<open>We provide some results on vector spaces which should be merged into other AFP entries.\<close>
	+theory Missing_VS_Connect
	+ imports
	+ Jordan_Normal_Form.VS_Connect
	+ Missing_Matrix
	+ Polynomial_Factorization.Missing_List
	+begin
	+
	+context vec_space
	+begin
	+lemma span_diff: assumes A: "A \<subseteq> carrier_vec n"
	+ and a: "a \<in> span A" and b: "b \<in> span A"
	+shows "a - b \<in> span A"
	+proof -
	+ from A a have an: "a \<in> carrier_vec n" by auto
	+ from A b have bn: "b \<in> carrier_vec n" by auto
	+ have "a + (-1 \<cdot>\<^sub>v b) \<in> span A"
	+ by (rule span_add1[OF A a], insert b A, auto)
	+ also have "a + (-1 \<cdot>\<^sub>v b) = a - b" using an bn by auto
	+ finally show ?thesis by auto
	+qed
	+
	+lemma finsum_scalar_prod_sum':
	+ assumes f: "f \<in> U \<rightarrow> carrier_vec n"
	+ and w: "w \<in> carrier_vec n"
	+ shows "w \<bullet> finsum V f U = sum (\<lambda>u. w \<bullet> f u) U"
	+ by (subst comm_scalar_prod[OF w], (insert f, auto)[1],
	+ subst finsum_scalar_prod_sum[OF f w],
	+ insert f, intro sum.cong[OF refl] comm_scalar_prod[OF _ w], auto)
	+
	+lemma lincomb_scalar_prod_left: assumes "W \<subseteq> carrier_vec n" "v \<in> carrier_vec n"
	+ shows "lincomb a W \<bullet> v = (\<Sum>w\<in>W. a w * (w \<bullet> v))"
	+ unfolding lincomb_def
	+ by (subst finsum_scalar_prod_sum, insert assms, auto intro!: sum.cong)
	+
	+lemma lincomb_scalar_prod_right: assumes "W \<subseteq> carrier_vec n" "v \<in> carrier_vec n"
	+ shows "v \<bullet> lincomb a W = (\<Sum>w\<in>W. a w * (v \<bullet> w))"
	+ unfolding lincomb_def
	+ by (subst finsum_scalar_prod_sum', insert assms, auto intro!: sum.cong)
	+
	+lemma lin_indpt_empty[simp]: "lin_indpt {}"
	+ using lin_dep_def by auto
	+
	+lemma span_carrier_lin_indpt_card_n:
	+ assumes "W \<subseteq> carrier_vec n" "card W = n" "lin_indpt W"
	+ shows "span W = carrier_vec n"
	+ using assms basis_def dim_is_n dim_li_is_basis fin_dim_li_fin by simp
	+
	+lemma ortho_span: assumes W: "W \<subseteq> carrier_vec n"
	+ and X: "X \<subseteq> carrier_vec n"
	+ and ortho: "\<And> w x. w \<in> W \<Longrightarrow> x \<in> X \<Longrightarrow> w \<bullet> x = 0"
	+ and w: "w \<in> span W" and x: "x \<in> X"
	+shows "w \<bullet> x = 0"
	+proof -
	+ from w W obtain c V where "finite V" and VW: "V \<subseteq> W" and w: "w = lincomb c V"
	+ by (meson in_spanE)
	+ show ?thesis unfolding w
	+ by (subst lincomb_scalar_prod_left, insert W VW X x ortho, auto intro!: sum.neutral)
	+qed
	+
	+lemma ortho_span': assumes W: "W \<subseteq> carrier_vec n"
	+ and X: "X \<subseteq> carrier_vec n"
	+ and ortho: "\<And> w x. w \<in> W \<Longrightarrow> x \<in> X \<Longrightarrow> x \<bullet> w = 0"
	+ and w: "w \<in> span W" and x: "x \<in> X"
	+shows "x \<bullet> w = 0"
	+proof -
	+ from w W obtain c V where "finite V" and VW: "V \<subseteq> W" and w: "w = lincomb c V"
	+ by (meson in_spanE)
	+ show ?thesis unfolding w
	+ by (subst lincomb_scalar_prod_right, insert W VW X x ortho, auto intro!: sum.neutral)
	+qed
	+
	+lemma ortho_span_span: assumes W: "W \<subseteq> carrier_vec n"
	+ and X: "X \<subseteq> carrier_vec n"
	+ and ortho: "\<And> w x. w \<in> W \<Longrightarrow> x \<in> X \<Longrightarrow> w \<bullet> x = 0"
	+ and w: "w \<in> span W" and x: "x \<in> span X"
	+shows "w \<bullet> x = 0"
	+ by (rule ortho_span[OF W _ ortho_span'[OF X W _ _] w x], insert W X ortho, auto)
	+
	+lemma lincomb_in_span[intro]:
	+ assumes X: "X\<subseteq> carrier_vec n"
	+ shows "lincomb a X \<in> span X"
	+proof(cases "finite X")
	+ case False hence "lincomb a X = 0\<^sub>v n" using X
	+ by (simp add: lincomb_def)
	+ thus ?thesis using X by force
	+qed (insert X, auto)
	+
	+lemma generating_card_n_basis: assumes X: "X \<subseteq> carrier_vec n"
	+ and span: "carrier_vec n \<subseteq> span X"
	+ and card: "card X = n"
	+shows "basis X"
	+proof -
	+ have fin: "finite X"
	+ proof (cases "n = 0")
	+ case False
	+ with card show "finite X" by (meson card_infinite)
	+ next
	+ case True
	+ with X have "X \<subseteq> carrier_vec 0" by auto
	+ also have "\<dots> = {0\<^sub>v 0}" by auto
	+ finally have "X \<subseteq> {0\<^sub>v 0}" .
	+ from finite_subset[OF this] show "finite X" by auto
	+ qed
	+ from X have "span X \<subseteq> carrier_vec n" by auto
	+ with span have span: "span X = carrier_vec n" by auto
	+ from dim_is_n card have card: "card X \<le> dim" by auto
	+ from dim_gen_is_basis[OF fin X span card] show "basis X" .
	+qed
	+
	+lemma lincomb_list_append:
	+ assumes Ws: "set Ws \<subseteq> carrier_vec n"
	+ shows "set Vs \<subseteq> carrier_vec n \<Longrightarrow> lincomb_list f (Vs @ Ws) =
	+ lincomb_list f Vs + lincomb_list (\<lambda> i. f (i + length Vs)) Ws"
	+proof (induction Vs arbitrary: f)
	+ case Nil show ?case by(simp add: lincomb_list_carrier[OF Ws])
	+next
	+ case (Cons x Vs)
	+ have "lincomb_list f (x # (Vs @ Ws)) = f 0 \<cdot>\<^sub>v x + lincomb_list (f \<circ> Suc) (Vs @ Ws)"
	+ by (rule lincomb_list_Cons)
	+ also have "lincomb_list (f \<circ> Suc) (Vs @ Ws) =
	+ lincomb_list (f \<circ> Suc) Vs + lincomb_list (\<lambda> i. (f \<circ> Suc) (i + length Vs)) Ws"
	+ using Cons by auto
	+ also have "(\<lambda> i. (f \<circ> Suc) (i + length Vs)) = (\<lambda> i. f (i + length (x # Vs)))" by simp
	+ also have "f 0 \<cdot>\<^sub>v x + ((lincomb_list (f \<circ> Suc) Vs) + lincomb_list \<dots> Ws) =
	+ (f 0 \<cdot>\<^sub>v x + (lincomb_list (f \<circ> Suc) Vs)) + lincomb_list \<dots> Ws"
	+ using assoc_add_vec Cons.prems Ws lincomb_list_carrier by auto
	+ finally show ?case using lincomb_list_Cons by auto
	+qed
	+
	+lemma lincomb_list_snoc[simp]:
	+ shows "set Vs \<subseteq> carrier_vec n \<Longrightarrow> x \<in> carrier_vec n \<Longrightarrow>
	+ lincomb_list f (Vs @ [x]) = lincomb_list f Vs + f (length Vs) \<cdot>\<^sub>v x"
	+ using lincomb_list_append by auto
	+
	+lemma lincomb_list_smult:
	+ "set Vs \<subseteq> carrier_vec n \<Longrightarrow> lincomb_list (\<lambda> i. a * c i) Vs = a \<cdot>\<^sub>v lincomb_list c Vs"
	+proof (induction Vs rule: rev_induct)
	+ case (snoc x Vs)
	+ have x: "x \<in> carrier_vec n" and Vs: "set Vs \<subseteq> carrier_vec n" using snoc.prems by auto
	+ have "lincomb_list (\<lambda> i. a * c i) (Vs @ [x]) =
	+ lincomb_list (\<lambda> i. a * c i) Vs + (a * c (length Vs)) \<cdot>\<^sub>v x"
	+ using x Vs by auto
	+ also have "lincomb_list (\<lambda> i. a * c i) Vs = a \<cdot>\<^sub>v lincomb_list c Vs"
	+ by(rule snoc.IH[OF Vs])
	+ also have "(a * c (length Vs)) \<cdot>\<^sub>v x = a \<cdot>\<^sub>v (c (length Vs) \<cdot>\<^sub>v x)"
	+ using smult_smult_assoc x by auto
	+ also have "a \<cdot>\<^sub>v lincomb_list c Vs + \<dots> = a \<cdot>\<^sub>v (lincomb_list c Vs + c (length Vs) \<cdot>\<^sub>v x)"
	+ using smult_add_distrib_vec[of _ n _ a] lincomb_list_carrier[OF Vs] x by simp
	+ also have "lincomb_list c Vs + c (length Vs) \<cdot>\<^sub>v x = lincomb_list c (Vs @ [x])"
	+ using Vs x by auto
	+ finally show ?case by auto
	+qed simp
	+
	+lemma lincomb_list_index:
	+ assumes i: "i < n"
	+ shows "set Xs \<subseteq> carrier_vec n \<Longrightarrow>
	+ lincomb_list c Xs $ i = sum (\<lambda> j. c j * (Xs ! j) $ i) {0..<length Xs}"
	+proof (induction Xs rule: rev_induct)
	+ case (snoc x Xs)
	+ hence x: "x \<in> carrier_vec n" and Xs: "set Xs \<subseteq> carrier_vec n" by auto
	+ hence "lincomb_list c (Xs @ [x]) = lincomb_list c Xs + c (length Xs) \<cdot>\<^sub>v x" by auto
	+ also have "\<dots> $ i = lincomb_list c Xs $ i + (c (length Xs) \<cdot>\<^sub>v x) $ i"
	+ using i index_add_vec(1) x by simp
	+ also have "(c (length Xs) \<cdot>\<^sub>v x) $ i = c (length Xs) * x $ i" using i x by simp
	+ also have "x $ i= (Xs @ [x]) ! (length Xs) $ i" by simp
	+ also have "lincomb_list c Xs $ i = (\<Sum>j = 0..<length Xs. c j * Xs ! j $ i)"
	+ by (rule snoc.IH[OF Xs])
	+ also have "\<dots> = (\<Sum>j = 0..<length Xs. c j * (Xs @ [x]) ! j $ i)"
	+ by (rule R.finsum_restrict, force, rule restrict_ext, auto simp: append_Cons_nth_left)
	+ finally show ?case
	+ using sum.atLeast0_lessThan_Suc[of "\<lambda> j. c j * (Xs @ [x]) ! j $ i" "length Xs"]
	+ by fastforce
	+qed (simp add: i)
	+
	+end
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Mixed_Integer_Solutions.thy b/thys/Linear_Inequalities/Mixed_Integer_Solutions.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Mixed_Integer_Solutions.thy
	@@ -0,0 +1,247 @@
	+section \<open>Mixed Integer Solutions\<close>
	+
	+text \<open>We prove that if an integral system of linear inequalities
	+$Ax \leq b \wedge A'x < b'$ has a (mixed)integer solution, there there is also
	+a small (mixed)integer solution, where the numbers are bounded by
	+$(n+1)! \cdot m^n$ where $n$ is the number of variables and $m$ is a bound on
	+the absolute values of numbers occurring in $A,A',b,b'$.\<close>
	+
	+theory Mixed_Integer_Solutions
	+ imports Decomposition_Theorem
	+begin
	+
	+
	+definition less_vec :: "'a vec \<Rightarrow> ('a :: ord) vec \<Rightarrow> bool" (infix "<\<^sub>v" 50) where
	+ "v <\<^sub>v w = (dim_vec v = dim_vec w \<and> (\<forall> i < dim_vec w. v $ i < w $ i))"
	+
	+lemma less_vecD: assumes "v <\<^sub>v w" and "w \<in> carrier_vec n"
	+ shows "i < n \<Longrightarrow> v $ i < w $ i"
	+ using assms unfolding less_vec_def by auto
	+
	+lemma less_vecI: assumes "v \<in> carrier_vec n" "w \<in> carrier_vec n"
	+ "\<And> i. i < n \<Longrightarrow> v $ i < w $ i"
	+shows "v <\<^sub>v w"
	+ using assms unfolding less_vec_def by auto
	+
	+lemma less_vec_lesseq_vec: "v <\<^sub>v (w :: 'a :: preorder vec) \<Longrightarrow> v \<le> w"
	+ unfolding less_vec_def less_eq_vec_def
	+ by (auto simp: less_le_not_le)
	+
	+lemma floor_less: "x \<notin> \<int> \<Longrightarrow> of_int \<lfloor>x\<rfloor> < x"
	+ using le_less by fastforce
	+
	+lemma floor_of_int_eq[simp]: "x \<in> \<int> \<Longrightarrow> of_int \<lfloor>x\<rfloor> = x"
	+ by (metis Ints_cases of_int_floor_cancel)
	+
	+
	+locale gram_schmidt_floor = gram_schmidt n f_ty
	+ for n :: nat and f_ty :: "'a :: {floor_ceiling,
	+ trivial_conjugatable_linordered_field} itself"
	+begin
	+
	+lemma small_mixed_integer_solution: fixes A\<^sub>1 :: "'a mat"
	+ assumes A1: "A\<^sub>1 \<in> carrier_mat nr\<^sub>1 n"
	+ and A2: "A\<^sub>2 \<in> carrier_mat nr\<^sub>2 n"
	+ and b1: "b\<^sub>1 \<in> carrier_vec nr\<^sub>1"
	+ and b2: "b\<^sub>2 \<in> carrier_vec nr\<^sub>2"
	+ and A1Bnd: "A\<^sub>1 \<in> \<int>\<^sub>m \<inter> Bounded_mat Bnd"
	+ and b1Bnd: "b\<^sub>1 \<in> \<int>\<^sub>v \<inter> Bounded_vec Bnd"
	+ and A2Bnd: "A\<^sub>2 \<in> \<int>\<^sub>m \<inter> Bounded_mat Bnd"
	+ and b2Bnd: "b\<^sub>2 \<in> \<int>\<^sub>v \<inter> Bounded_vec Bnd"
	+ and x: "x \<in> carrier_vec n"
	+ and xI: "x \<in> indexed_Ints_vec I"
	+ and sol_nonstrict: "A\<^sub>1 *\<^sub>v x \<le> b\<^sub>1"
	+ and sol_strict: "A\<^sub>2 *\<^sub>v x <\<^sub>v b\<^sub>2"
	+ shows "\<exists> x.
	+ x \<in> carrier_vec n \<and>
	+ x \<in> indexed_Ints_vec I \<and>
	+ A\<^sub>1 *\<^sub>v x \<le> b\<^sub>1 \<and>
	+ A\<^sub>2 *\<^sub>v x <\<^sub>v b\<^sub>2 \<and>
	+ x \<in> Bounded_vec (fact (n+1) * (max 1 Bnd)^n)"
	+proof -
	+ define B where "B = det_bound n (max 1 Bnd)"
	+ define A where "A = A\<^sub>1 @\<^sub>r A\<^sub>2"
	+ define b where "b = b\<^sub>1 @\<^sub>v b\<^sub>2"
	+ define nr where "nr = nr\<^sub>1 + nr\<^sub>2"
	+ have B0: "B \<ge> 0" unfolding B_def det_bound_def by auto
	+ note defs = A_def b_def nr_def
	+ from A1 A2 have A: "A \<in> carrier_mat nr n" unfolding defs by auto
	+ from b1 b2 have b: "b \<in> carrier_vec nr" unfolding defs by auto
	+ from A1Bnd A2Bnd A1 A2 have ABnd: "A \<in> \<int>\<^sub>m \<inter> Bounded_mat Bnd" unfolding defs
	+ by (auto simp: Ints_mat_elements_mat Bounded_mat_elements_mat elements_mat_append_rows)
	+ from b1Bnd b2Bnd b1 b2 have bBnd: "b \<in> \<int>\<^sub>v \<inter> Bounded_vec Bnd" unfolding defs
	+ by (auto simp: Ints_vec_vec_set Bounded_vec_vec_set)
	+ from decomposition_theorem_polyhedra_1[OF A b refl, of Bnd] ABnd bBnd
	+ obtain Y Z where Z: "Z \<subseteq> carrier_vec n"
	+ and finX: "finite Z"
	+ and Y: "Y \<subseteq> carrier_vec n"
	+ and finY: "finite Y"
	+ and poly: "polyhedron A b = convex_hull Y + cone Z"
	+ and ZBnd: "Z \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec B"
	+ and YBnd: "Y \<subseteq> Bounded_vec B" unfolding B_def by blast
	+ let ?P = "{x \<in> carrier_vec n. A\<^sub>1 \<^sub>v x \<le> b\<^sub>1 \<and> A\<^sub>2 \<^sub>v x \<le> b\<^sub>2}"
	+ let ?L = "?P \<inter> {x. A\<^sub>2 *\<^sub>v x <\<^sub>v b\<^sub>2} \<inter> indexed_Ints_vec I"
	+ have "polyhedron A b = {x \<in> carrier_vec n. A *\<^sub>v x \<le> b}" unfolding polyhedron_def by auto
	+ also have "\<dots> = ?P" unfolding defs
	+ by (intro Collect_cong conj_cong refl append_rows_le[OF A1 A2 b1])
	+ finally have poly: "?P = convex_hull Y + cone Z" unfolding poly ..
	+ have "x \<in> ?P" using x sol_nonstrict less_vec_lesseq_vec[OF sol_strict] by blast
	+ note sol = this[unfolded poly]
	+ from set_plus_elim[OF sol] obtain y z where xyz: "x = y + z" and
	+ yY: "y \<in> convex_hull Y" and zZ: "z \<in> cone Z" by auto
	+ from convex_hull_carrier[OF Y] yY have y: "y \<in> carrier_vec n" by auto
	+ from Caratheodory_theorem[OF Z] zZ
	+ obtain C where zC: "z \<in> finite_cone C" and CZ: "C \<subseteq> Z" and lin: "lin_indpt C" by auto
	+ from subset_trans[OF CZ Z] lin have card: "card C \<le> n"
	+ using dim_is_n li_le_dim(2) by auto
	+ from finite_subset[OF CZ finX] have finC: "finite C" .
	+ from zC[unfolded finite_cone_def nonneg_lincomb_def] finC obtain a
	+ where za: "z = lincomb a C" and nonneg: "\<And> u. u \<in> C \<Longrightarrow> a u \<ge> 0" by auto
	+ from CZ Z have C: "C \<subseteq> carrier_vec n" by auto
	+ have z: "z \<in> carrier_vec n" using C unfolding za by auto
	+ have yB: "y \<in> Bounded_vec B" using yY convex_hull_bound[OF YBnd Y] by auto
	+ {
	+ fix D
	+ assume DC: "D \<subseteq> C"
	+ from finite_subset[OF this finC] have "finite D" .
	+ hence "\<exists> a. y + lincomb a C \<in> ?L \<and> (\<forall> c \<in> C. a c \<ge> 0) \<and> (\<forall> c \<in> D. a c \<le> 1)"
	+ using DC
	+ proof (induct D)
	+ case empty
	+ show ?case by (intro exI[of _ a], fold za xyz, insert sol_strict x xI nonneg \<open>x \<in> ?P\<close>, auto)
	+ next
	+ case (insert c D)
	+ then obtain a where sol: "y + lincomb a C \<in> ?L"
	+ and a: "(\<forall> c \<in> C. a c \<ge> 0)" and D: "(\<forall> c \<in> D. a c \<le> 1)" by auto
	+ from insert(4) C have c: "c \<in> carrier_vec n" and cC: "c \<in> C" by auto
	+ show ?case
	+ proof (cases "a c > 1")
	+ case False
	+ thus ?thesis by (intro exI[of _ a], insert sol a D, auto)
	+ next
	+ case True (* this is the core reasoning step where a\<^sub>c is large *)
	+ let ?z = "\<lambda> d. lincomb a C - d \<cdot>\<^sub>v c"
	+ let ?x = "\<lambda> d. y + ?z d"
	+ {
	+ fix d
	+ have lin: "lincomb a (C - {c}) \<in> carrier_vec n" using C by auto
	+ have id: "?z d = lincomb (\<lambda> e. if e = c then (a c - d) else a e) C"
	+ unfolding lincomb_del2[OF finC C TrueI cC]
	+ by (subst (2) lincomb_cong[OF refl, of _ _ a], insert C c lin, auto simp: diff_smult_distrib_vec)
	+ {
	+ assume le: "d \<le> a c"
	+ have "?z d \<in> finite_cone C"
	+ proof -
	+ have "\<forall>f\<in>C. 0 \<le> (\<lambda>e. if e = c then a c - d else a e) f" using le a finC by simp
	+ then show ?thesis unfolding id using le a finC
	+ by (simp add: C lincomb_in_finite_cone)
	+ qed
	+ hence "?z d \<in> cone Z" using CZ
	+ using finC local.cone_def by blast
	+ hence "?x d \<in> ?P" unfolding poly
	+ by (intro set_plus_intro[OF yY], auto)
	+ } note sol = this
	+ {
	+ fix w :: "'a vec"
	+ assume w: "w \<in> carrier_vec n"
	+ have "w \<bullet> (?x d) = w \<bullet> y + w \<bullet> lincomb a C - d * (w \<bullet> c)"
	+ by (subst scalar_prod_add_distrib[OF w y], (insert C c, force),
	+ subst scalar_prod_minus_distrib[OF w], insert w c C, auto)
	+ } note scalar = this
	+ note id sol scalar
	+ } note generic = this
	+ let ?fl = "(of_int (floor (a c)) :: 'a)"
	+ define p where "p = (if ?fl = a c then a c - 1 else ?fl)"
	+ have p_lt_ac: "p < a c" unfolding p_def
	+ using floor_less floor_of_int_eq by auto
	+ have p1_ge_ac: "p + 1 \<ge> a c" unfolding p_def
	+ using floor_correct le_less by auto
	+ have p1: "p \<ge> 1" using True unfolding p_def by auto
	+ define a' where "a' = (\<lambda>e. if e = c then a c - p else a e)"
	+ have lin_id: "lincomb a' C = lincomb a C - p \<cdot>\<^sub>v c" unfolding a'_def using id
	+ by (simp add: generic(1))
	+ hence 1: "y + lincomb a' C \<in> {x \<in> carrier_vec n. A\<^sub>1 \<^sub>v x \<le> b\<^sub>1 \<and> A\<^sub>2 \<^sub>v x \<le> b\<^sub>2}"
	+ using p_lt_ac generic(2)[of p] by auto
	+ have pInt: "p \<in> \<int>" unfolding p_def using sol by auto
	+ have "C \<subseteq> indexed_Ints_vec I" using CZ ZBnd
	+ using indexed_Ints_vec_subset by force
	+ hence "c \<in> indexed_Ints_vec I" using cC by auto
	+ hence pvindInts: "p \<cdot>\<^sub>v c \<in> indexed_Ints_vec I" unfolding indexed_Ints_vec_def using pInt by simp
	+ have prod: "A\<^sub>2 *\<^sub>v (?x b) \<in> carrier_vec nr\<^sub>2" for b using A2 C c y by auto
	+ have 2: "y + lincomb a' C \<in> {x. A\<^sub>2 *\<^sub>v x <\<^sub>v b\<^sub>2}" unfolding lin_id
	+ proof (intro less_vecI[OF prod b2] CollectI)
	+ fix i
	+ assume i: "i < nr\<^sub>2"
	+ from sol have "A\<^sub>2 *\<^sub>v (?x 0) <\<^sub>v b\<^sub>2" using y C c by auto
	+ from less_vecD[OF this b2 i]
	+ have lt: "row A\<^sub>2 i \<bullet> ?x 0 < b\<^sub>2 $ i" using A2 i by auto
	+ from generic(2)[of "a c"] i A2
	+ have le: "row A\<^sub>2 i \<bullet> ?x (a c) \<le> b\<^sub>2 $ i"
	+ unfolding less_eq_vec_def by auto
	+ from A2 i have A2icarr: "row A\<^sub>2 i \<in> carrier_vec n" by auto
	+ have "row A\<^sub>2 i \<bullet> ?x p < b\<^sub>2 $ i"
	+ proof -
	+ define lhs where "lhs = row A\<^sub>2 i \<bullet> y + row A\<^sub>2 i \<bullet> lincomb a C - b\<^sub>2 $ i"
	+ define mult where "mult = row A\<^sub>2 i \<bullet> c"
	+ have le2: "lhs \<le> a c * mult" using le unfolding generic(3)[OF A2icarr] lhs_def mult_def by auto
	+ have lt2: "lhs < 0 * mult" using lt unfolding generic(3)[OF A2icarr] lhs_def by auto
	+ from le2 lt2 have "lhs < p * mult" using p_lt_ac p1 True
	+ by (smt dual_order.strict_trans linorder_neqE_linordered_idom
	+ mult_less_cancel_right not_less zero_less_one_class.zero_less_one)
	+ then show ?thesis unfolding generic(3)[OF A2icarr] lhs_def mult_def by auto
	+ qed
	+ thus "(A\<^sub>2 *\<^sub>v ?x p) $ i < b\<^sub>2 $ i" using i A2 by auto
	+ qed
	+ have "y + lincomb a' C = y + lincomb a C - p \<cdot>\<^sub>v c"
	+ by (subst lin_id, insert y C c, auto simp: add_diff_eq_vec)
	+ also have "\<dots> \<in> indexed_Ints_vec I" using sol
	+ by(intro diff_indexed_Ints_vec[OF _ _ _ pvindInts, of _ n ], insert c C, auto)
	+ finally have 3: "y + lincomb a' C \<in> indexed_Ints_vec I" by auto
	+ have 4: "\<forall>c\<in>C. 0 \<le> a' c" unfolding a'_def p_def using p_lt_ac a by auto
	+ have 5: "\<forall>c\<in>insert c D. a' c \<le> 1" unfolding a'_def using p1_ge_ac D p_def by auto
	+ show ?thesis
	+ by (intro exI[of _ a'], intro conjI IntI 1 2 3 4 5)
	+ qed
	+ qed
	+ }
	+ from this[of C] obtain a where
	+ sol: "y + lincomb a C \<in> ?L" and bnds: "(\<forall> c \<in> C. a c \<ge> 0)" "(\<forall> c \<in> C. a c \<le> 1)" by auto
	+ show ?thesis
	+ proof (intro exI[of _ "y + lincomb a C"] conjI)
	+ from ZBnd CZ have BndC: "C \<subseteq> Bounded_vec B" and IntC: "C \<subseteq> \<int>\<^sub>v" by auto
	+ have "lincomb a C \<in> Bounded_vec (of_nat n * B)"
	+ using lincomb_card_bound[OF BndC C B0 _ card] bnds by auto
	+ from sum_in_Bounded_vecI[OF yB this y] C
	+ have "y + lincomb a C \<in> Bounded_vec (B + of_nat n * B)" by auto
	+ also have "B + of_nat n * B = of_nat (n+1) * B" by (auto simp: field_simps)
	+ also have "\<dots> = fact (n + 1) * (max 1 Bnd)^n" unfolding B_def det_bound_def by simp
	+ finally show "y + lincomb a C \<in> Bounded_vec (fact (n + 1) * max 1 Bnd ^ n)" by auto
	+ qed (insert sol, auto)
	+qed
	+
	+corollary small_integer_solution_nonstrict: fixes A :: "'a mat"
	+ assumes A: "A \<in> carrier_mat nr n"
	+ and b: "b \<in> carrier_vec nr"
	+ and ABnd: "A \<in> \<int>\<^sub>m \<inter> Bounded_mat Bnd"
	+ and bBnd: "b \<in> \<int>\<^sub>v \<inter> Bounded_vec Bnd"
	+ and x: "x \<in> carrier_vec n"
	+ and xI: "x \<in> \<int>\<^sub>v"
	+ and sol: "A *\<^sub>v x \<le> b"
	+ shows "\<exists> y.
	+ y \<in> carrier_vec n \<and>
	+ y \<in> \<int>\<^sub>v \<and>
	+ A *\<^sub>v y \<le> b \<and>
	+ y \<in> Bounded_vec (fact (n+1) * (max 1 Bnd)^n)"
	+proof -
	+ let ?A2 = "0\<^sub>m 0 n :: 'a mat"
	+ let ?b2 = "0\<^sub>v 0 :: 'a vec"
	+ have "\<exists>y. y \<in> carrier_vec n \<and> y \<in> \<int>\<^sub>v \<and> A \<^sub>v y \<le> b \<and> ?A2 \<^sub>v y <\<^sub>v ?b2
	+ \<and> y \<in> Bounded_vec (fact (n + 1) * max 1 Bnd ^ n)"
	+ by (rule small_mixed_integer_solution[OF A _ b _ ABnd bBnd _ _ x _ sol, of ?A2 0 ?b2 UNIV,
	+ folded indexed_Ints_vec_UNIV], insert xI,
	+ auto simp: Ints_vec_def Ints_mat_def Bounded_mat_def Bounded_vec_def less_vec_def)
	+ thus ?thesis by blast
	+qed
	+
	+end
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/Normal_Vector.thy b/thys/Linear_Inequalities/Normal_Vector.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Normal_Vector.thy
	@@ -0,0 +1,446 @@
	+section \<open>Normal Vectors\<close>
	+
	+text \<open>We provide a function for the normal vector of a half-space (given as n-1 linearly
	+ independent vectors).
	+ We further provide a function that returns a list of normal vectors that span the
	+ orthogonal complement of some subspace of $R^n$.
	+ Bounds for all normal vectors are provided.\<close>
	+
	+theory Normal_Vector
	+ imports
	+ Integral_Bounded_Vectors
	+ Basis_Extension
	+begin
	+
	+context gram_schmidt
	+begin
	+ (* TODO move *)
	+lemma ortho_sum_in_span:
	+ assumes W: "W \<subseteq> carrier_vec n"
	+ and X: "X \<subseteq> carrier_vec n"
	+ and ortho: "\<And> w x. w \<in> W \<Longrightarrow> x \<in> X \<Longrightarrow> x \<bullet> w = 0"
	+ and inspan: "lincomb l1 X + lincomb l2 W \<in> span X"
	+ shows "lincomb l2 W = 0\<^sub>v n"
	+proof (rule ccontr)
	+ let ?v = "lincomb l2 W"
	+ have vcarr: "?v \<in> carrier_vec n" using W by auto
	+ have vspan: "?v \<in> span W" using W by auto
	+ assume "\<not>?thesis"
	+ from this have vnz: "?v \<noteq> 0\<^sub>v n" by auto
	+ let ?x = "lincomb l1 X"
	+ have xcarr: "?x \<in> carrier_vec n" using X by auto
	+ have xspan: "?x \<in> span X" using X xcarr by auto
	+ have "0 \<noteq> sq_norm ?v" using vnz vcarr by simp
	+ also have "sq_norm ?v = 0 + ?v \<bullet> ?v" by (simp add: sq_norm_vec_as_cscalar_prod)
	+ also have "\<dots> = ?x \<bullet> ?v + ?v \<bullet> ?v"
	+ by (subst (2) ortho_span_span[OF X W ortho], insert X W, auto)
	+ also have "\<dots> = (?x + ?v ) \<bullet> ?v" using xcarr vcarr
	+ using add_scalar_prod_distrib by force
	+ also have "\<dots> = 0"
	+ by (rule ortho_span_span[OF X W ortho inspan vspan])
	+ finally show False by simp
	+qed
	+
	+(* TODO move *)
	+lemma ortho_lin_indpt: assumes W: "W \<subseteq> carrier_vec n"
	+ and X: "X \<subseteq> carrier_vec n"
	+ and ortho: "\<And> w x. w \<in> W \<Longrightarrow> x \<in> X \<Longrightarrow> x \<bullet> w = 0"
	+ and linW: "lin_indpt W"
	+ and linX: "lin_indpt X"
	+shows "lin_indpt (W \<union> X)"
	+proof (rule ccontr)
	+ assume "\<not>?thesis"
	+ from this obtain c where zerocomb:"lincomb c (W \<union> X) = 0\<^sub>v n"
	+ and notallz: "\<exists>v \<in> (W \<union> X). c v \<noteq> 0"
	+ using assms fin_dim fin_dim_li_fin finite_lin_indpt2 infinite_Un le_sup_iff
	+ by metis
	+ have zero_nin_W: "0\<^sub>v n \<notin> W" using assms by (metis vs_zero_lin_dep)
	+ have WXinters: "W \<inter> X = {}"
	+ proof (rule ccontr)
	+ assume "\<not>?thesis"
	+ from this obtain v where v: "v\<in> W \<inter> X" by auto
	+ hence "v\<bullet>v=0" using ortho by auto
	+ moreover have "v \<in> carrier_vec n" using assms v by auto
	+ ultimately have "v=0\<^sub>v n" using sq_norm_vec_as_cscalar_prod[of v] by auto
	+ then show False using zero_nin_W v by auto
	+ qed
	+ have finX: "finite X" using X linX by (simp add: fin_dim_li_fin)
	+ have finW: "finite W" using W linW by (simp add: fin_dim_li_fin)
	+ have split: "lincomb c (W \<union> X) = lincomb c X + lincomb c W"
	+ using lincomb_union[OF W X WXinters finW finX]
	+ by (simp add: M.add.m_comm W X)
	+ hence "lincomb c X + lincomb c W \<in> span X" using zerocomb
	+ using local.span_zero by auto
	+ hence z1: "lincomb c W = 0\<^sub>v n"
	+ using ortho_sum_in_span[OF W X ortho] by simp
	+ hence z2: "lincomb c X = 0\<^sub>v n" using split zerocomb X by simp
	+ have or: "(\<exists>v \<in> W. c v \<noteq> 0) \<or> (\<exists> v\<in> X. c v \<noteq> 0)" using notallz by auto
	+ have ex1: "\<exists>v \<in> W. c v \<noteq> 0 \<Longrightarrow> False" using linW
	+ using finW lin_dep_def z1 by blast
	+ have ex2: "\<exists> v\<in> X. c v \<noteq> 0 \<Longrightarrow> False" using linX
	+ using finX lin_dep_def z2 by blast
	+ show False using ex1 ex2 or by auto
	+qed
	+
	+definition normal_vector :: "'a vec set \<Rightarrow> 'a vec" where
	+ "normal_vector W = (let ws = (SOME ws. set ws = W \<and> distinct ws);
	+ m = length ws;
	+ B = (\<lambda> j. mat m m (\<lambda>(i, j'). ws ! i $ (if j' < j then j' else Suc j')))
	+ in vec n (\<lambda> j. (-1)^(m+j) * det (B j)))"
	+
	+lemma normal_vector: assumes fin: "finite W"
	+ and card: "Suc (card W) = n"
	+ and lin: "lin_indpt W"
	+ and W: "W \<subseteq> carrier_vec n"
	+shows "normal_vector W \<in> carrier_vec n"
	+ "normal_vector W \<noteq> 0\<^sub>v n"
	+ "w \<in> W \<Longrightarrow> w \<bullet> normal_vector W = 0"
	+ "w \<in> W \<Longrightarrow> normal_vector W \<bullet> w = 0"
	+ "lin_indpt (insert (normal_vector W) W)"
	+ "normal_vector W \<notin> W"
	+ "W \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd \<Longrightarrow> normal_vector W \<in> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n-1) Bnd)"
	+proof -
	+ define ws where "ws = (SOME ws. set ws = W \<and> distinct ws)"
	+ from finite_distinct_list[OF fin]
	+ have "\<exists> ws. set ws = W \<and> distinct ws" by auto
	+ from someI_ex[OF this, folded ws_def] have id: "set ws = W" and dist: "distinct ws" by auto
	+ have len: "length ws = card W" using distinct_card[OF dist] id by auto
	+ let ?n = "length ws"
	+ define B where "B = (\<lambda> j. mat ?n ?n (\<lambda>(i, j'). ws ! i $ (if j' < j then j' else Suc j')))"
	+ define nv where "nv = vec n (\<lambda> j. (-1)^(?n+j) * det (B j))"
	+ have nv2: "normal_vector W = nv" unfolding normal_vector_def Let_def
	+ ws_def[symmetric] B_def nv_def ..
	+ define A where "A = (\<lambda> w. mat_of_rows n (ws @ [w]))"
	+ from len id card have len: "Suc ?n = n" by auto
	+ have A: "A w \<in> carrier_mat n n" for w using id W len unfolding A_def by auto
	+ {
	+ fix w :: "'a vec"
	+ assume w: "w \<in> carrier_vec n"
	+ from len have n1[simp]: "n - Suc 0 = ?n" by auto
	+ {
	+ fix j
	+ assume j: "j < n"
	+ have "mat_delete (A w) ?n j = B j"
	+ unfolding mat_delete_def A_def mat_of_rows_def B_def
	+ by (rule eq_matI, insert j len, auto simp: nth_append)
	+ } note B = this
	+ have "det (A w) = (\<Sum>j<n. (A w) $$ (length ws, j) * cofactor (A w) ?n j)"
	+ by (subst laplace_expansion_row[OF A, of ?n], insert len, auto)
	+ also have "\<dots> = (\<Sum>j<n. w $ j * (-1)^(?n+j) * det (mat_delete (A w) ?n j))"
	+ by (rule sum.cong, auto simp: A_def mat_of_rows_def cofactor_def)
	+ also have "\<dots> = (\<Sum>j<n. w $ j * (-1)^(?n+j) * det (B j))"
	+ by (rule sum.cong[OF refl], subst B, auto)
	+ also have "\<dots> = (\<Sum>j<n. w $ j * nv $ j)"
	+ by (rule sum.cong[OF refl], auto simp: nv_def)
	+ also have "\<dots> = w \<bullet> nv" unfolding scalar_prod_def unfolding nv_def
	+ by (rule sum.cong, auto)
	+ finally have "det (A w) = w \<bullet> nv" .
	+ } note det_scalar = this
	+ have nv: "nv \<in> carrier_vec n" unfolding nv_def by auto
	+ {
	+ fix w
	+ assume wW: "w \<in> W"
	+ with W have w: "w \<in> carrier_vec n" by auto
	+ from wW id obtain i where i: "i < ?n" and ws: "ws ! i = w" unfolding set_conv_nth by auto
	+ from det_scalar[OF w] have "det (A w) = w \<bullet> nv" .
	+ also have "det (A w) = 0"
	+ by (subst det_identical_rows[OF A, of i ?n], insert i ws len, auto simp: A_def mat_of_rows_def nth_append)
	+ finally have "w \<bullet> nv = 0" ..
	+ note this this[unfolded comm_scalar_prod[OF w nv]]
	+ } note ortho = this
	+ have nv0: "nv \<noteq> 0\<^sub>v n"
	+ proof
	+ assume nv: "nv = 0\<^sub>v n"
	+ define bs where "bs = basis_extension ws"
	+ define w where "w = hd bs"
	+ have "lin_indpt_list ws" using dist lin W unfolding lin_indpt_list_def id by auto
	+ from basis_extension[OF this, folded bs_def] len
	+ have lin: "lin_indpt_list (ws @ bs)" and "length bs = 1" and bsc: "set bs \<subseteq> carrier_vec n"
	+ by (auto simp: unit_vecs_def)
	+ hence bs: "bs = [w]" unfolding w_def by (cases bs, auto)
	+ with bsc have w: "w \<in> carrier_vec n" by auto
	+ note lin = lin[unfolded bs]
	+ from lin_indpt_list_length_eq_n[OF lin] len
	+ have basis: "basis (set (ws @ [w]))" by auto
	+ from w det_scalar nv have det0: "det (A w) = 0" by auto
	+ with basis_det_nonzero[OF basis] len show False
	+ unfolding A_def by auto
	+ qed
	+ let ?nv = "normal_vector W"
	+ from ortho nv nv0
	+ show nv: "?nv \<in> carrier_vec n"
	+ and ortho: "\<And> w. w \<in> W \<Longrightarrow> w \<bullet> ?nv = 0"
	+ "\<And> w. w \<in> W \<Longrightarrow> ?nv \<bullet> w = 0"
	+ and n0: "?nv \<noteq> 0\<^sub>v n" unfolding nv2 by auto
	+ from n0 nv have "sq_norm ?nv \<noteq> 0" by auto
	+ hence nvnv: "?nv \<bullet> ?nv \<noteq> 0" by (auto simp: sq_norm_vec_as_cscalar_prod)
	+ show nvW: "?nv \<notin> W" using nvnv ortho by blast
	+ have "?nv \<notin> span W" using W ortho nvnv nv
	+ using orthocompl_span by blast
	+ with lin_dep_iff_in_span[OF W lin nv nvW]
	+ show "lin_indpt (insert ?nv W)" by auto
	+ {
	+ assume "W \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd"
	+ hence wsI: "set ws \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd" unfolding id by auto
	+ have ws: "set ws \<subseteq> carrier_vec n" using W unfolding id by auto
	+ from wsI ws have wsI: "i < ?n \<Longrightarrow> ws ! i \<in> \<int>\<^sub>v \<inter> Bounded_vec Bnd \<inter> carrier_vec n" for i
	+ using len wsI unfolding set_conv_nth by auto
	+ have ints: "i < ?n \<Longrightarrow> j < n \<Longrightarrow> ws ! i $ j \<in> \<int>" for i j
	+ using wsI[of i, unfolded Ints_vec_def] by force
	+ have bnd: "i < ?n \<Longrightarrow> j < n \<Longrightarrow> abs (ws ! i $ j) \<le> Bnd" for i j
	+ using wsI[unfolded Bounded_vec_def, of i] by auto
	+ {
	+ fix i
	+ assume i: "i < n"
	+ have ints: "nv $ i \<in> \<int>" unfolding nv_def using wsI len ws
	+ by (auto simp: i B_def set_conv_nth intro!: Ints_mult Ints_det ints)
	+ have "\<bar>nv $ i\<bar> \<le> det_bound (n - 1) Bnd" unfolding nv_def using wsI len ws i
	+ by (auto simp: B_def Bounded_mat_def abs_mult intro!: det_bound bnd)
	+ note ints this
	+ }
	+ with nv nv2 show "?nv \<in> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n - 1) Bnd)"
	+ unfolding Ints_vec_def Bounded_vec_def by auto
	+ }
	+qed
	+
	+lemma normal_vector_span:
	+ assumes card: "Suc (card D) = n"
	+ and D: "D \<subseteq> carrier_vec n" and fin: "finite D" and lin: "lin_indpt D"
	+ shows "span D = { x. x \<in> carrier_vec n \<and> x \<bullet> normal_vector D = 0}"
	+proof -
	+ note nv = normal_vector[OF fin card lin D]
	+ {
	+ fix x
	+ assume xspan: "x \<in> span D"
	+ from finite_in_span[OF fin D xspan] obtain c where
	+ "x \<bullet> normal_vector D = lincomb c D \<bullet> normal_vector D" by auto
	+ also have "\<dots> = (\<Sum>w\<in>D. c w * (w \<bullet> normal_vector D))"
	+ by (rule lincomb_scalar_prod_left, insert D nv, auto)
	+ also have "\<dots> = 0"
	+ apply (rule sum.neutral) using nv(1,2,3) D comm_scalar_prod[of "normal_vector D"] by fastforce
	+ finally have "x \<in> carrier_vec n" "x \<bullet> normal_vector D = 0" using xspan D by auto
	+ }
	+ moreover
	+ {
	+ let ?n = "normal_vector D"
	+ fix x
	+ assume x: "x \<in> carrier_vec n" and xscal: "x \<bullet> normal_vector D = 0"
	+ let ?B = "(insert (normal_vector D) D)"
	+ have "card ?B = n" using card card_insert_disjoint[OF fin nv(6)] by auto
	+ moreover have B: "?B \<subseteq> carrier_vec n" using D nv by auto
	+ ultimately have "span ?B = carrier_vec n"
	+ by (intro span_carrier_lin_indpt_card_n, insert nv(5), auto)
	+ hence xspan: "x \<in> span ?B" using x by auto
	+ obtain c where "x = lincomb c ?B" using finite_in_span[OF _ B xspan] fin by auto
	+ hence "0 = lincomb c ?B \<bullet> normal_vector D" using xscal by auto
	+ also have "\<dots> = (\<Sum>w\<in> ?B. c w * (w \<bullet> normal_vector D))"
	+ by (subst lincomb_scalar_prod_left, insert B, auto)
	+ also have "\<dots> = (\<Sum>w\<in> D. c w * (w \<bullet> normal_vector D)) + c ?n * (?n \<bullet> ?n)"
	+ by (subst sum.insert[OF fin nv(6)], auto)
	+ also have "(\<Sum>w\<in> D. c w * (w \<bullet> normal_vector D)) = 0"
	+ apply(rule sum.neutral) using nv(1,3) comm_scalar_prod[OF nv(1)] D by fastforce
	+ also have "?n \<bullet> ?n = sq_norm ?n" using sq_norm_vec_as_cscalar_prod[of ?n] by simp
	+ finally have "c ?n * sq_norm ?n = 0" by simp
	+ hence ncoord: "c ?n = 0" using nv(1-5) by auto
	+ have "x = lincomb c ?B" by fact
	+ also have "\<dots> = lincomb c D"
	+ apply (subst lincomb_insert2[OF fin D _ nv(6,1)]) using ncoord nv(1) D by auto
	+ finally have "x \<in> span D" using fin by auto
	+ }
	+ ultimately show ?thesis by auto
	+qed
	+
	+definition normal_vectors :: "'a vec list \<Rightarrow> 'a vec list" where
	+ "normal_vectors ws = (let us = basis_extension ws
	+ in map (\<lambda> i. normal_vector (set (ws @ us) - {us ! i})) [0..<length us])"
	+
	+lemma normal_vectors:
	+ assumes lin: "lin_indpt_list ws"
	+ shows "set (normal_vectors ws) \<subseteq> carrier_vec n"
	+ "w \<in> set ws \<Longrightarrow> nv \<in> set (normal_vectors ws) \<Longrightarrow> nv \<bullet> w = 0"
	+ "w \<in> set ws \<Longrightarrow> nv \<in> set (normal_vectors ws) \<Longrightarrow> w \<bullet> nv = 0"
	+ "lin_indpt_list (ws @ normal_vectors ws)"
	+ "length ws + length (normal_vectors ws) = n"
	+ "set ws \<inter> set (normal_vectors ws) = {}"
	+ "set ws \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd \<Longrightarrow>
	+ set (normal_vectors ws) \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n-1) (max 1 Bnd))"
	+proof -
	+ define us where "us = basis_extension ws"
	+ from basis_extension[OF assms, folded us_def]
	+ have units: "set us \<subseteq> set (unit_vecs n)"
	+ and lin: "lin_indpt_list (ws @ us)"
	+ and len: "length (ws @ us) = n"
	+ by auto
	+ from lin_indpt_list_length_eq_n[OF lin len]
	+ have span: "span (set (ws @ us)) = carrier_vec n" by auto
	+ from lin[unfolded lin_indpt_list_def]
	+ have wsus: "set (ws @ us) \<subseteq> carrier_vec n"
	+ and dist: "distinct (ws @ us)"
	+ and lin': "lin_indpt (set (ws @ us))" by auto
	+ let ?nv = "normal_vectors ws"
	+ note nv_def = normal_vectors_def[of ws, unfolded Let_def, folded us_def]
	+ let ?m = "length ws"
	+ let ?n = "length us"
	+ have lnv[simp]: "length ?nv = length us" unfolding nv_def by auto
	+ {
	+ fix i
	+ let ?V = "set (ws @ us) - {us ! i}"
	+ assume i: "i < ?n"
	+ hence nvi: "?nv ! i = normal_vector ?V" unfolding nv_def by auto
	+ from i have "us ! i \<in> set us" by auto
	+ with wsus have u: "us ! i \<in> carrier_vec n" by auto
	+ have id: "?V \<union> {us ! i} = set (ws @ us)" using i by auto
	+ have V: "?V \<subseteq> carrier_vec n" using wsus by auto
	+ have finV: "finite ?V" by auto
	+ have "Suc (card ?V) = card (insert (us ! i) ?V)"
	+ by (subst card_insert_disjoint[OF finV], auto)
	+ also have "insert (us ! i) ?V = set (ws @ us)" using i by auto
	+ finally have cardV: "Suc (card ?V) = n"
	+ using len distinct_card[OF dist] by auto
	+ from subset_li_is_li[OF lin'] have linV: "lin_indpt ?V" by auto
	+ from lin_dep_iff_in_span[OF _ linV u, unfolded id] wsus lin'
	+ have usV: "us ! i \<notin> span ?V" by auto
	+ note nv = normal_vector[OF finV cardV linV V, folded nvi]
	+ from normal_vector_span[OF cardV V _ linV, folded nvi] comm_scalar_prod[OF _ nv(1)]
	+ have span: "span ?V = {x \<in> carrier_vec n. ?nv ! i \<bullet> x = 0}"
	+ by auto
	+ from nv(1,2) have "sq_norm (?nv ! i) \<noteq> 0" by auto
	+ hence nvi: "?nv ! i \<bullet> ?nv ! i \<noteq> 0"
	+ by (auto simp: sq_norm_vec_as_cscalar_prod)
	+ from span nvi have nvspan: "?nv ! i \<notin> span ?V" by auto
	+ from u usV[unfolded span] have "?nv ! i \<bullet> us ! i \<noteq> 0" by blast
	+ note nv nvi this span usV nvspan
	+ } note nvi = this
	+ show nv: "set ?nv \<subseteq> carrier_vec n"
	+ unfolding set_conv_nth using nvi(1) by auto
	+ {
	+ fix w nv
	+ assume w: "w \<in> set ws"
	+ with dist have wus: "w \<notin> set us" by auto
	+ assume n: "nv \<in> set ?nv"
	+ with w wus show "nv \<bullet> w = 0"
	+ unfolding set_conv_nth[of "normal_vectors _"] by (auto intro!: nvi(4)[of _ w])
	+ thus "w \<bullet> nv = 0" using comm_scalar_prod[of w n nv] w nv n wsus by auto
	+ } note scalar_0 = this
	+ show "length ws + length ?nv = n" using len by simp
	+ {
	+ assume wsI: "set ws \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec Bnd"
	+ {
	+ fix nv
	+ assume "nv \<in> set ?nv"
	+ then obtain i where nv: "nv = ?nv ! i" and i: "i < ?n" unfolding set_conv_nth by auto
	+ from wsI have "set (ws @ us) - {us ! i} \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (max 1 Bnd)" using units
	+ Bounded_vec_mono[of Bnd "max 1 Bnd"]
	+ by (auto simp: unit_vecs_def)
	+ from nvi(7)[OF i this] nv
	+ have "nv \<in> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n - 1) (max 1 Bnd))"
	+ by auto
	+ }
	+ thus "set ?nv \<subseteq> \<int>\<^sub>v \<inter> Bounded_vec (det_bound (n - 1) (max 1 Bnd))" by auto
	+ }
	+ have dist_nv: "distinct ?nv" unfolding distinct_conv_nth lnv
	+ proof (intro allI impI)
	+ fix i j
	+ assume i: "i < ?n" and j: "j < ?n" and ij: "i \<noteq> j"
	+ with dist have usj: "us ! j \<in> set (ws @ us) - {us ! i}"
	+ by (simp, auto simp: distinct_conv_nth set_conv_nth)
	+ from nvi(4)[OF i this] nvi(9)[OF j]
	+ show "?nv ! i \<noteq> ?nv ! j" by auto
	+ qed
	+ show disj: "set ws \<inter> set ?nv = {}"
	+ proof (rule ccontr)
	+ assume "\<not> ?thesis"
	+ then obtain w where w: "w \<in> set ws" "w \<in> set ?nv" by auto
	+ from scalar_0[OF this] this(1) have "sq_norm w = 0"
	+ by (auto simp: sq_norm_vec_as_cscalar_prod)
	+ with w wsus have "w = 0\<^sub>v n" by auto
	+ with vs_zero_lin_dep[OF wsus lin'] w(1) show False by auto
	+ qed
	+ have dist': "distinct (ws @ ?nv)" using dist disj dist_nv by auto
	+ show "lin_indpt_list (ws @ ?nv)" unfolding lin_indpt_list_def
	+ proof (intro conjI dist')
	+ show set: "set (ws @ ?nv) \<subseteq> carrier_vec n" using nv wsus by auto
	+ hence ws: "set ws \<subseteq> carrier_vec n" by auto
	+ have lin_nv: "lin_indpt (set ?nv)"
	+ proof
	+ assume "lin_dep (set ?nv)"
	+ from finite_lin_dep[OF finite_set this nv]
	+ obtain a v where comb: "lincomb a (set ?nv) = 0\<^sub>v n" and vnv: "v \<in> set ?nv" and av0: "a v \<noteq> 0" by auto
	+ from vnv[unfolded set_conv_nth] obtain i where i: "i < ?n" and vi: "v = ?nv ! i" by auto
	+ define b where "b = (\<lambda> w. a w / a v)"
	+ define c where "c = (\<lambda> w. -1 * b w)"
	+ define x where "x = lincomb b (set ?nv - {v})"
	+ define w where "w = lincomb c (set ?nv - {v})"
	+ have w: "w \<in> carrier_vec n" unfolding w_def using nv by auto
	+ have x: "x \<in> carrier_vec n" unfolding x_def using nv by auto
	+ from arg_cong[OF comb, of "\<lambda> x. (1/ a v) \<cdot>\<^sub>v x"]
	+ have "0\<^sub>v n = 1 / a v \<cdot>\<^sub>v lincomb a (set ?nv)" by auto
	+ also have "\<dots> = lincomb b (set ?nv)"
	+ by (subst lincomb_smult[symmetric, OF nv], auto simp: b_def)
	+ also have "\<dots> = b v \<cdot>\<^sub>v v + lincomb b (set ?nv - {v})"
	+ by (subst lincomb_del2[OF _ nv _ vnv], auto)
	+ also have "b v \<cdot>\<^sub>v v = v" using av0 unfolding b_def by auto
	+ finally have "v + lincomb b (set ?nv - {v}) - lincomb b (set ?nv - {v}) =
	+ 0\<^sub>v n - lincomb b (set ?nv - {v})" (is "?l = ?r") by simp
	+ also have "?l = v"
	+ by (rule add_diff_cancel_right_vec, insert vnv nv, auto)
	+ also have "?r = w" unfolding w_def c_def
	+ by (subst lincomb_smult, unfold x_def[symmetric], insert nv x, auto)
	+ finally have vw: "v = w" .
	+ have u: "us ! i \<in> carrier_vec n" using i wsus by auto
	+ have nv': "set ?nv - {?nv ! i} \<subseteq> carrier_vec n" using nv by auto
	+ have "?nv ! i \<bullet> us ! i = 0"
	+ unfolding vi[symmetric] vw unfolding w_def vi
	+ unfolding lincomb_scalar_prod_left[OF nv' u]
	+ proof (rule sum.neutral, intro ballI)
	+ fix x
	+ assume "x \<in> set ?nv - {?nv ! i}"
	+ then obtain j where j: "j < ?n" and x: "x = ?nv ! j" and ij: "i \<noteq> j" unfolding set_conv_nth by auto
	+ from dist[simplified] ij i j have "us ! i \<noteq> us ! j" unfolding distinct_conv_nth by auto
	+ with i have "us ! i \<in> set (ws @ us) - {us ! j}" by auto
	+ from nvi(3-4)[OF j this]
	+ show "c x * (x \<bullet> us ! i) = 0" unfolding x by auto
	+ qed
	+ with nvi(9)[OF i] show False ..
	+ qed
	+ from subset_li_is_li[OF lin'] have "lin_indpt (set ws)" by auto
	+ from ortho_lin_indpt[OF nv ws scalar_0 lin_nv this]
	+ have "lin_indpt (set ?nv \<union> set ws)" .
	+ also have "set ?nv \<union> set ws = set (ws @ ?nv)" by auto
	+ finally show "lin_indpt (set (ws @ ?nv))" .
	+ qed
	+qed
	+
	+definition pos_norm_vec :: "'a vec set \<Rightarrow> 'a vec \<Rightarrow> 'a vec" where
	+ "pos_norm_vec D x = (let c' = normal_vector D;
	+ c = (if c' \<bullet> x > 0 then c' else -c') in c)"
	+
	+lemma pos_norm_vec:
	+ assumes D: "D \<subseteq> carrier_vec n" and fin: "finite D" and lin: "lin_indpt D"
	+ and card: "Suc (card D) = n"
	+ and c_def: "c = pos_norm_vec D x"
	+ shows "c \<in> carrier_vec n" "span D = { x. x \<in> carrier_vec n \<and> x \<bullet> c = 0}"
	+ "x \<notin> span D \<Longrightarrow> x \<in> carrier_vec n \<Longrightarrow> c \<bullet> x > 0"
	+ "c \<in> {normal_vector D, -normal_vector D}"
	+proof -
	+ have n: "normal_vector D \<in> carrier_vec n" using normal_vector assms by auto
	+ show cnorm: "c \<in> {normal_vector D, -normal_vector D}" unfolding c_def pos_norm_vec_def Let_def by auto
	+ then show c: "c \<in> carrier_vec n" using assms normal_vector by auto
	+ have "span D = { x. x \<in> carrier_vec n \<and> x \<bullet> normal_vector D = 0}"
	+ using normal_vector_span[OF card D fin lin] by auto
	+ also have "\<dots> = { x. x \<in> carrier_vec n \<and> x \<bullet> c = 0}" using cnorm c by auto
	+ finally show span_char: "span D = { x. x \<in> carrier_vec n \<and> x \<bullet> c = 0}" by auto
	+ {
	+ assume x: "x \<notin> span D" "x \<in> carrier_vec n"
	+ hence "c \<bullet> x \<noteq> 0" using comm_scalar_prod[OF c] unfolding span_char by auto
	+ hence "normal_vector D \<bullet> x \<noteq> 0" using cnorm n x by auto
	+ with x have b: "\<not> (normal_vector D \<bullet> x > 0) \<Longrightarrow> (-normal_vector D) \<bullet> x > 0"
	+ using assms n by auto
	+ then show "c \<bullet> x > 0" unfolding c_def pos_norm_vec_def Let_def
	+ by (auto split: if_splits)
	+ }
	+qed
	+
	+end
	+
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/ROOT b/thys/Linear_Inequalities/ROOT
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/ROOT
	@@ -0,0 +1,17 @@
	+chapter AFP
	+
	+session "Linear_Inequalities" (AFP) = "LLL_Basis_Reduction" +
	+ options [timeout = 600]
	+ theories
	+ Missing_Matrix
	+ Missing_VS_Connect
	+ theories
	+ Cone
	+ Convex_Hull
	+ theories
	+ Farkas_Lemma
	+ Mixed_Integer_Solutions
	+ Integer_Hull
	+ document_files
	+ "root.bib"
	+ "root.tex"
	diff --git a/thys/Linear_Inequalities/Sum_Vec_Set.thy b/thys/Linear_Inequalities/Sum_Vec_Set.thy
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/Sum_Vec_Set.thy
	@@ -0,0 +1,58 @@
	+section \<open>Sum of Vector Sets\<close>
	+
	+text \<open>We use Isabelle's Set-Algebra theory to be able to write V + W for sets of vectors V and W,
	+ and prove some obvious properties about them.\<close>
	+theory Sum_Vec_Set
	+ imports
	+ Missing_Matrix
	+ "HOL-Library.Set_Algebras"
	+begin
	+
	+
	+lemma add_0_right_vecset:
	+ assumes "(A :: 'a :: monoid_add vec set) \<subseteq> carrier_vec n"
	+ shows "A + {0\<^sub>v n} = A"
	+ unfolding set_plus_def using assms by force
	+
	+lemma add_0_left_vecset:
	+ assumes "(A :: 'a :: monoid_add vec set) \<subseteq> carrier_vec n"
	+ shows "{0\<^sub>v n} + A = A"
	+ unfolding set_plus_def using assms by force
	+
	+lemma assoc_add_vecset:
	+ assumes "(A :: 'a :: semigroup_add vec set) \<subseteq> carrier_vec n"
	+ and "B \<subseteq> carrier_vec n"
	+ and "C \<subseteq> carrier_vec n"
	+ shows "A + (B + C) = (A + B) + C"
	+proof -
	+ {
	+ fix x
	+ assume "x \<in> A + (B + C)"
	+ then obtain a b c where "x = a + (b + c)" and *: "a \<in> A" "b \<in> B" "c \<in> C"
	+ unfolding set_plus_def by auto
	+ with assms have "x = (a + b) + c" using assoc_add_vec[of a n b c] by force
	+ with * have "x \<in> (A + B) + C" by auto
	+ }
	+ moreover
	+ {
	+ fix x
	+ assume "x \<in> (A + B) + C"
	+ then obtain a b c where "x = (a + b) + c" and *: "a \<in> A" "b \<in> B" "c \<in> C"
	+ unfolding set_plus_def by auto
	+ with assms have "x = a + (b + c)" using assoc_add_vec[of a n b c] by force
	+ with * have "x \<in> A + (B + C)" by auto
	+ }
	+ ultimately show ?thesis by blast
	+qed
	+
	+lemma sum_carrier_vec[intro]: "A \<subseteq> carrier_vec n \<Longrightarrow> B \<subseteq> carrier_vec n \<Longrightarrow> A + B \<subseteq> carrier_vec n"
	+ unfolding set_plus_def by force
	+
	+lemma comm_add_vecset:
	+ assumes "(A :: 'a :: ab_semigroup_add vec set) \<subseteq> carrier_vec n"
	+ and "B \<subseteq> carrier_vec n"
	+ shows "A + B = B + A"
	+ unfolding set_plus_def using comm_add_vec assms by blast
	+
	+
	+end
	\ No newline at end of file
	diff --git a/thys/Linear_Inequalities/document/root.bib b/thys/Linear_Inequalities/document/root.bib
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/document/root.bib
	@@ -0,0 +1,122 @@
	+@inproceedings{WST10,
	+ author = {Ren\'e Thiemann and Christian Sternagel},
	+ title = {Certified Polynomial Interpretations over Matrices and over Domains},
	+ year = 2010,
	+ booktitle = {Proc.\ WST '10},
	+ note = "To appear."
	+}
	+
	+@Article{MatrixJAR,
	+ author = {J.~Endrullis and J.~Waldmann and H.~Zantema},
	+ title = {{Matrix Interpretations for Proving Termination of Term Rewriting}},
	+ journal = {Journal of Automated Reasoning},
	+ year = {2008},
	+ OPTkey = {},
	+ volume = {40},
	+ number = {2-3},
	+ pages = {195--220},
	+ OPTmonth = {},
	+ OPTnote = {},
	+ OPTannote = {}
	+}
	+
	+@inproceedings{Arctic,
	+ author = {A.\ Koprowski and J.\ Waldmann},
	+ title = {Arctic Termination {\ldots} Below Zero},
	+ booktitle = {Proc.\ RTA'08},
	+ year = {2008},
	+ pages = {202--216},
	+ series = "LNCS 5117"
	+}
	+
	+@inproceedings{CeTA,
	+ author = {R.~Thiemann and C.~Sternagel},
	+ title = {Certification of Termination Proofs using \ceta},
	+ booktitle = {Proc.\ TPHOLs'09},
	+ series = {LNCS 5674},
	+ year = 2009,
	+ pages = {452--468}
	+}
	+@inproceedings{CeTAcomplexity,
	+ author = {M.~Avanzini and C.~Sternagel and R.~Thiemann},
	+ title = {Certification of Complexity Proofs using \ceta},
	+ booktitle = {Proc.\ {RTA} 2015},
	+ series = {LIPIcs 36},
	+ pages = {23--39},
	+ year = {2015}
	+}
	+
	+@book{PO07,
	+ title={Matrix theory: from generalized inverses to {J}ordan form},
	+ author={Piziak, Robert and Odell, Patrick L},
	+ year={2007},
	+ publisher={CRC Press}
	+}
	+
	+@article{Containers-AFP,
	+ author = {Andreas Lochbihler},
	+ title = {Light-weight Containers},
	+ journal = {Archive of Formal Proofs},
	+ month = apr,
	+ year = 2013,
	+ note = {\url{http://isa-afp.org/entries/Containers.shtml},
	+ Formal proof development},
	+ ISSN = {2150-914x},
	+}
	+
	+@article{Gauss_Jordan-AFP,
	+ author = {Jose Divas\'on and Jesus Aransay},
	+ title = {Gauss-Jordan Algorithm and Its Applications},
	+ journal = {Archive of Formal Proofs},
	+ month = sep,
	+ year = 2014,
	+ note = {\url{http://isa-afp.org/entries/Gauss_Jordan.shtml},
	+ Formal proof development},
	+ ISSN = {2150-914x},
	+}
	+
	+@article{Matrix-AFP,
	+ author = {Christian Sternagel and Rene Thiemann},
	+ title = {Executable Matrix Operations on Matrices of Arbitrary Dimensions},
	+ journal = {Archive of Formal Proofs},
	+ month = jun,
	+ year = 2010,
	+ note = {\url{http://isa-afp.org/entries/Matrix.shtml},
	+ Formal proof development},
	+ ISSN = {2150-914x},
	+}
	+
	+@book{schrijver1998theory,
	+ title={Theory of linear and integer programming},
	+ author={Schrijver, Alexander},
	+ year={1998},
	+ publisher={John Wiley \& Sons}
	+}
	+
	+@inproceedings{incremental_simplex,
	+ author = {Bruno Dutertre and
	+ Leonardo Mendon{\c{c}}a de Moura},
	+ opteditor = {Thomas Ball and
	+ Robert B. Jones},
	+ title = {A Fast Linear-Arithmetic Solver for {DPLL(T)}},
	+ booktitle = {Proc. Computer Aided Verification},
	+ series = {LNCS},
	+ volume = {4144},
	+ pages = {81--94},
	+ publisher = {Springer},
	+ year = {2006},
	+ note = {Extended version available as Technical Report, CSL-06-01, SRI International.},
	+ doi = {10.1007/11817963\_11},
	+}
	+
	+@article{Papad,
	+ author = {Christos H. Papadimitriou},
	+ title = {On the complexity of integer programming},
	+ journal = {J. {ACM}},
	+ volume = {28},
	+ number = {4},
	+ pages = {765--768},
	+ year = {1981},
	+ url = {https://doi.org/10.1145/322276.322287},
	+ doi = {10.1145/322276.322287},
	+}
	diff --git a/thys/Linear_Inequalities/document/root.tex b/thys/Linear_Inequalities/document/root.tex
	new file mode 100644
	--- /dev/null
	+++ b/thys/Linear_Inequalities/document/root.tex
	@@ -0,0 +1,107 @@
	+\documentclass[11pt,a4paper]{article}
	+\usepackage{isabelle,isabellesym}
	+
	+\usepackage{amsmath}
	+\usepackage{amssymb}
	+\usepackage{amsthm}
	+\usepackage{authblk}
	+
	+
	+
	+\newcommand\ints{\mathbb{Z}}
	+\newcommand\reals{\mathbb{R}}
	+
	+\newtheorem{theorem}{Theorem}
	+% this should be the last package used
	+\usepackage{pdfsetup}
	+
	+% urls in roman style, theory text in math-similar italics
	+\urlstyle{rm}
	+\isabellestyle{it}
	+
	+\newcommand\isafor{\textsf{IsaFoR}}
	+\newcommand\ceta{\textsf{Ce\kern-.18emT\kern-.18emA}}
	+
	+\begin{document}
	+
	+\title{Linear Inequalities\footnote{Supported by FWF (Austrian Science Fund) project Y757.}}
	+\author[1]{Ralph Bottesch}
	+\author[2]{Alban Reynaud}
	+\author[1]{Ren\'e Thiemann}
	+\affil[1]{University of Innsbruck}
	+\affil[2]{ENS Lyon}
	+
	+\maketitle
	+
	+\begin{abstract}
	+ We formalize results about linear inqualities, mainly from Schrijver's book
	+ \cite{schrijver1998theory}.
	+ The main results are the proof of the fundamental theorem on linear
	+ inequalities, Farkas' lemma, Carath\'eodory's theorem,
	+ the Farkas-Minkowsky-Weyl theorem,
	+ the decomposition theorem of
	+ polyhedra, and Meyer's result that the integer hull of a polyhedron is a
	+ polyhedron itself. Several theorems include bounds on the appearing
	+ numbers, and in particular we provide an a-priori bound
	+ on mixed-integer solutions of linear inequalities.
	+
	+\end{abstract}
	+
	+\tableofcontents
	+
	+\section{Introduction}
	+
	+The motivation for this formalization is the aim of developing a verified theory solver
	+for linear integer arithmetic. Such a solver can be a combination of a simplex-implementation within
	+a branch-and-bound approach, that might also utilize Gomory cuts \cite[Section 4 of the extended version]{incremental_simplex}.
	+However, the branch-and-bound algorithm does
	+not terminate in general, since the search space in infinite. To solve this latter problem, one can use
	+results of Papadimitriou: he showed that whenever a set of linear inequalities has an integer
	+solution, then it also has a small solution, where the bound on such a solution can be computed
	+easily from the input \cite{Papad}.
	+
	+In this entry, we therefore formalize several results on linear inequalities which are required
	+to obtain the desired bound, by following the proofs of Schrijver's
	+textbook~\cite[Sections 7 and 16]{schrijver1998theory}.
	+
	+We start with basic definitions and results on cones, convex hulls, and polyhedra.
	+Next, we verify the fundamental theorem of linear inequalities, which in
	+our formalization shows the equivalence of four statements to describe a cone.
	+From this theorem, one easily derives Farkas' Lemma and Carath\'eodory's theorem.
	+Moreover we verify the Farkas-Minkowsky-Weyl theorem, that a convex cone is polyhedral if and only if
	+it is finitely generated, and use this result to obtain
	+the decomposition theorem for polyhedra, i.e., that a polyhedron can always be decomposed into
	+a polytope and a finitely generated cone.
	+For most of the previously mentioned results, we include bounds, so that in particular we have a
	+quantitative version of the decomposition theorem, which provides bounds on the vectors that construct
	+the polytope and the cone, and where these bounds are
	+computed directly from the input polyhedron that should be decomposed.
	+
	+We further prove the decomposition theorem also for the integer hull of a polyhedron, using the same bounds,
	+which gives rise to small integer solutions for linear inequalities. We finally formalize a direct proof
	+for the more general case of mixed integer solutions, where we also permit both strict and non-strict
	+linear inequalities.
	+
	+\begin{theorem}
	+\label{thm}
	+Consider
	+$A_1 \in \ints^{m_1 \times n}, b_1 \in \ints^{m_1}, A_2 \in \ints^{m_2 \times n}, b_2 \in \ints^{m_2}$.
	+Let $\beta$ be a bound on $A_1,b_1,A_2,b_2$, i.e., $\beta \geq \|z\|$ for all numbers $z$ that occur within $A_1,b_1,A_2,b_2$. Let $n = n_1+n_2$.
	+Then if $x \in \ints^{n_1} \times \reals^{n_2} \subseteq \reals^n$ is a mixed integer solution of the linear inequalities, i.e.,
	+$A_1x \leq b_1$ and $A_2x < b_2$, then there also exists a mixed integer solution
	+$y \in \ints^{n_1} \times \reals^{n_2}$ where
	+$\|y_i\| \leq (n+1)! \cdot \beta^n$ for each entry $y_i$ of $y$.
	+\end{theorem}
	+
	+The verified bound in Theorem~\ref{thm} in particular implies that integer-satisfiability
	+of linear-inqualities with integer coefficients is in NP.
	+
	+% include generated text of all theories
	+\input{session}
	+
	+
	+
	+\bibliographystyle{abbrv}
	+\bibliography{root}
	+
	+\end{document}
	diff --git a/thys/Nullstellensatz/Algebraically_Closed_Fields.thy b/thys/Nullstellensatz/Algebraically_Closed_Fields.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Nullstellensatz/Algebraically_Closed_Fields.thy
	@@ -0,0 +1,207 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Algebraically Closed Fields\<close>
	+
	+theory Algebraically_Closed_Fields
	+ imports "HOL-Computational_Algebra.Fundamental_Theorem_Algebra"
	+begin
	+
	+lemma prod_eq_zeroE:
	+ assumes "prod f I = (0::'a::{semiring_no_zero_divisors,comm_monoid_mult,zero_neq_one})"
	+ obtains i where "finite I" and "i \<in> I" and "f i = 0"
	+proof -
	+ have "finite I"
	+ proof (rule ccontr)
	+ assume "infinite I"
	+ with assms show False by simp
	+ qed
	+ moreover from this assms obtain i where "i \<in> I" and "f i = 0"
	+ proof (induct I arbitrary: thesis)
	+ case empty
	+ from empty(2) show ?case by simp
	+ next
	+ case (insert j I)
	+ from insert.hyps(1, 2) have "f j * prod f I = prod f (insert j I)" by simp
	+ also have "\<dots> = 0" by fact
	+ finally have "f j = 0 \<or> prod f I = 0" by simp
	+ thus ?case
	+ proof
	+ assume "f j = 0"
	+ with _ show ?thesis by (rule insert.prems) simp
	+ next
	+ assume "prod f I = 0"
	+ then obtain i where "i \<in> I" and "f i = 0" using insert.hyps(3) by blast
	+ from _ this(2) show ?thesis by (rule insert.prems) (simp add: \<open>i \<in> I\<close>)
	+ qed
	+ qed
	+ ultimately show ?thesis ..
	+qed
	+
	+lemma degree_prod_eq:
	+ assumes "finite I" and "\<And>i. i \<in> I \<Longrightarrow> f i \<noteq> 0"
	+ shows "Polynomial.degree (prod f I :: _::semiring_no_zero_divisors poly) = (\<Sum>i\<in>I. Polynomial.degree (f i))"
	+ using assms
	+proof (induct I)
	+ case empty
	+ show ?case by simp
	+next
	+ case (insert j J)
	+ have 1: "f i \<noteq> 0" if "i \<in> J" for i
	+ proof (rule insert.prems)
	+ from that show "i \<in> insert j J" by simp
	+ qed
	+ hence eq: "Polynomial.degree (prod f J) = (\<Sum>i\<in>J. Polynomial.degree (f i))" by (rule insert.hyps)
	+ from insert.hyps(1, 2) have "Polynomial.degree (prod f (insert j J)) = Polynomial.degree (f j * prod f J)"
	+ by simp
	+ also have "\<dots> = Polynomial.degree (f j) + Polynomial.degree (prod f J)"
	+ proof (rule degree_mult_eq)
	+ show "f j \<noteq> 0" by (rule insert.prems) simp
	+ next
	+ show "prod f J \<noteq> 0"
	+ proof
	+ assume "prod f J = 0"
	+ then obtain i where "i \<in> J" and "f i = 0" by (rule prod_eq_zeroE)
	+ from this(1) have "f i \<noteq> 0" by (rule 1)
	+ thus False using \<open>f i = 0\<close> ..
	+ qed
	+ qed
	+ also from insert.hyps(1, 2) have "\<dots> = (\<Sum>i\<in>insert j J. Polynomial.degree (f i))" by (simp add: eq)
	+ finally show ?case .
	+qed
	+
	+class alg_closed_field =
	+ assumes alg_closed_field_axiom: "\<And>p::'a::field poly. 0 < Polynomial.degree p \<Longrightarrow> \<exists>z. poly p z = 0"
	+begin
	+
	+lemma rootE:
	+ assumes "0 < Polynomial.degree p"
	+ obtains z where "poly p z = (0::'a)"
	+proof -
	+ from assms have "\<exists>z. poly p z = 0" by (rule alg_closed_field_axiom)
	+ then obtain z where "poly p z = 0" ..
	+ thus ?thesis ..
	+qed
	+
	+lemma infinite_UNIV: "infinite (UNIV::'a set)"
	+proof
	+ assume fin: "finite (UNIV::'a set)"
	+ define p where "p = (\<Prod>a\<in>UNIV. [:- a, 1::'a:]) + [:-1:]"
	+ have "Polynomial.degree (\<Prod>a\<in>UNIV. [:- a, 1::'a:]) = (\<Sum>a\<in>UNIV. Polynomial.degree [:- a, 1::'a:])"
	+ using fin by (rule degree_prod_eq) simp
	+ also have "\<dots> = (\<Sum>a\<in>(UNIV::'a set). 1)" by simp
	+ also have "\<dots> = card (UNIV::'a set)" by simp
	+ also from fin have "\<dots> > 0" by (rule finite_UNIV_card_ge_0)
	+ finally have "0 < Polynomial.degree (\<Prod>a\<in>UNIV. [:- a, 1::'a:])" .
	+ hence "Polynomial.degree [:-1:] < Polynomial.degree (\<Prod>a\<in>UNIV. [:- a, 1::'a:])" by simp
	+ hence "Polynomial.degree p = Polynomial.degree (\<Prod>a\<in>UNIV. [:- a, 1::'a:])" unfolding p_def
	+ by (rule degree_add_eq_left)
	+ also have "\<dots> > 0" by fact
	+ finally have "0 < Polynomial.degree p" .
	+ then obtain z where "poly p z = 0" by (rule rootE)
	+ hence "(\<Prod>a\<in>UNIV. (z - a)) = 1" by (simp add: p_def poly_prod)
	+ thus False by (metis UNIV_I cancel_comm_monoid_add_class.diff_cancel fin one_neq_zero prod_zero_iff)
	+qed
	+
	+lemma linear_factorsE:
	+ fixes p :: "'a poly"
	+ obtains c A m where "finite A" and "p = Polynomial.smult c (\<Prod>a\<in>A. [:- a, 1:] ^ m a)"
	+ and "\<And>a. m a = 0 \<longleftrightarrow> a \<notin> A" and "c = 0 \<longleftrightarrow> p = 0" and "\<And>z. poly p z = 0 \<longleftrightarrow> (c = 0 \<or> z \<in> A)"
	+proof -
	+ obtain c A m where fin: "finite A" and p: "p = Polynomial.smult c (\<Prod>a\<in>A. [:- a, 1:] ^ m a)"
	+ and *: "\<And>x. m x = 0 \<longleftrightarrow> x \<notin> A"
	+ proof (induct p arbitrary: thesis rule: poly_root_induct[where P="\<lambda>_. True"])
	+ case 0
	+ show ?case
	+ proof (rule 0)
	+ show "0 = Polynomial.smult 0 (\<Prod>a\<in>{}. [:- a, 1:] ^ (\<lambda>_. 0) a)" by simp
	+ qed simp_all
	+ next
	+ case (no_roots p)
	+ have "Polynomial.degree p = 0"
	+ proof (rule ccontr)
	+ assume "Polynomial.degree p \<noteq> 0"
	+ hence "0 < Polynomial.degree p" by simp
	+ then obtain z where "poly p z = 0" by (rule rootE)
	+ moreover have "poly p z \<noteq> 0" by (rule no_roots) blast
	+ ultimately show False by simp
	+ qed
	+ then obtain c where p: "p = [:c:]" by (rule degree_eq_zeroE)
	+ show ?case
	+ proof (rule no_roots)
	+ show "p = Polynomial.smult c (\<Prod>a\<in>{}. [:- a, 1:] ^ (\<lambda>_. 0) a)" by (simp add: p)
	+ qed simp_all
	+ next
	+ case (root a p)
	+ obtain A c m where 1: "finite A" and p: "p = Polynomial.smult c (\<Prod>a\<in>A. [:- a, 1:] ^ m a)"
	+ and 2: "\<And>x. m x = 0 \<longleftrightarrow> x \<notin> A" by (rule root.hyps) blast
	+ define m' where "m' = (\<lambda>x. if x = a then Suc (m x) else m x)"
	+ show ?case
	+ proof (rule root.prems)
	+ from 1 show "finite (insert a A)" by simp
	+ next
	+ have "[:a, - 1:] * p = [:- a, 1:] * (- p)" by simp
	+ also have "\<dots> = [:- a, 1:] * (Polynomial.smult (- c) (\<Prod>a\<in>A. [:- a, 1:] ^ m a))"
	+ by (simp add: p)
	+ also have "\<dots> = Polynomial.smult (- c) ([:- a, 1:] * (\<Prod>a\<in>A. [:- a, 1:] ^ m a))"
	+ by (simp only: mult_smult_right ac_simps)
	+ also have "[:- a, 1:] * (\<Prod>a\<in>A. [:- a, 1:] ^ m a) = (\<Prod>a\<in>insert a A. [:- a, 1:] ^ m' a)"
	+ proof (cases "a \<in> A")
	+ case True
	+ with 1 have "(\<Prod>a\<in>A. [:- a, 1:] ^ m a) = [:- a, 1:] ^ m a * (\<Prod>a\<in>A-{a}. [:- a, 1:] ^ m a)"
	+ by (simp add: prod.remove)
	+ also from refl have "(\<Prod>a\<in>A-{a}. [:- a, 1:] ^ m a) = (\<Prod>a\<in>A-{a}. [:- a, 1:] ^ m' a)"
	+ by (rule prod.cong) (simp add: m'_def)
	+ finally have "[:- a, 1:] * (\<Prod>a\<in>A. [:- a, 1:] ^ m a) =
	+ ([:- a, 1:] * [:- a, 1:] ^ m a) * (\<Prod>a\<in>A - {a}. [:- a, 1:] ^ m' a)"
	+ by (simp only: mult.assoc)
	+ also have "[:- a, 1:] * [:- a, 1:] ^ m a = [:- a, 1:] ^ m' a" by (simp add: m'_def)
	+ finally show ?thesis using 1 by (simp add: prod.insert_remove)
	+ next
	+ case False
	+ with 1 have "(\<Prod>a\<in>insert a A. [:- a, 1:] ^ m' a) = [:- a, 1:] ^ m' a * (\<Prod>a\<in>A. [:- a, 1:] ^ m' a)"
	+ by simp
	+ also from refl have "(\<Prod>a\<in>A. [:- a, 1:] ^ m' a) = (\<Prod>a\<in>A. [:- a, 1:] ^ m a)"
	+ proof (rule prod.cong)
	+ fix x
	+ assume "x \<in> A"
	+ with False have "x \<noteq> a" by blast
	+ thus "[:- x, 1:] ^ m' x = [:- x, 1:] ^ m x" by (simp add: m'_def)
	+ qed
	+ finally have "(\<Prod>a\<in>insert a A. [:- a, 1:] ^ m' a) = [:- a, 1:] ^ m' a * (\<Prod>a\<in>A. [:- a, 1:] ^ m a)" .
	+ also from False have "m' a = 1" by (simp add: m'_def 2)
	+ finally show ?thesis by simp
	+ qed
	+ finally show "[:a, - 1:] * p = Polynomial.smult (- c) (\<Prod>a\<in>insert a A. [:- a, 1:] ^ m' a)" .
	+ next
	+ fix x
	+ show "m' x = 0 \<longleftrightarrow> x \<notin> insert a A" by (simp add: m'_def 2)
	+ qed
	+ qed
	+ moreover have "c = 0 \<longleftrightarrow> p = 0"
	+ proof
	+ assume "p = 0"
	+ hence "[:c:] = 0 \<or> (\<Prod>a\<in>A. [:- a, 1:] ^ m a) = 0" by (simp add: p)
	+ thus "c = 0"
	+ proof
	+ assume "[:c:] = 0"
	+ thus ?thesis by simp
	+ next
	+ assume "(\<Prod>a\<in>A. [:- a, 1:] ^ m a) = 0"
	+ then obtain a where "[:- a, 1:] ^ m a = 0" by (rule prod_eq_zeroE)
	+ thus ?thesis by simp
	+ qed
	+ qed (simp add: p)
	+ moreover {
	+ fix z
	+ have "0 < m z" if "z \<in> A" by (rule ccontr) (simp add: * that)
	+ hence "poly p z = 0 \<longleftrightarrow> (c = 0 \<or> z \<in> A)" by (auto simp: p poly_prod * fin elim: prod_eq_zeroE)
	+ }
	+ ultimately show ?thesis ..
	+qed
	+
	+end (* alg_closed_field *)
	+
	+instance complex :: alg_closed_field
	+ by standard (rule fundamental_theorem_of_algebra, simp add: constant_degree)
	+
	+end (* theory *)
	diff --git a/thys/Nullstellensatz/Lex_Order_PP.thy b/thys/Nullstellensatz/Lex_Order_PP.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Nullstellensatz/Lex_Order_PP.thy
	@@ -0,0 +1,116 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Properties of the Lexicographic Order on Power-Products\<close>
	+
	+theory Lex_Order_PP
	+ imports Polynomials.Power_Products
	+begin
	+
	+text \<open>We prove some useful properties of the purely lexicographic order relation on
	+ power-products.\<close>
	+
	+lemma lex_pm_keys_leE:
	+ assumes "lex_pm s t" and "x \<in> keys (s::'x::linorder \<Rightarrow>\<^sub>0 'a::add_linorder_min)"
	+ obtains y where "y \<in> keys t" and "y \<le> x"
	+ using assms(1) unfolding lex_pm_alt
	+proof (elim disjE exE conjE)
	+ assume "s = t"
	+ show ?thesis
	+ proof
	+ from assms(2) show "x \<in> keys t" by (simp only: \<open>s = t\<close>)
	+ qed (fact order.refl)
	+next
	+ fix y
	+ assume 1: "lookup s y < lookup t y" and 2: "\<forall>y'<y. lookup s y' = lookup t y'"
	+ show ?thesis
	+ proof (cases "y \<le> x")
	+ case True
	+ from zero_min 1 have "0 < lookup t y" by (rule le_less_trans)
	+ hence "y \<in> keys t" by (simp add: dual_order.strict_implies_not_eq in_keys_iff)
	+ thus ?thesis using True ..
	+ next
	+ case False
	+ hence "x < y" by simp
	+ with 2 have "lookup s x = lookup t x" by simp
	+ with assms(2) have "x \<in> keys t" by (simp only: in_keys_iff not_False_eq_True)
	+ thus ?thesis using order.refl ..
	+ qed
	+qed
	+
	+lemma lex_pm_except_max:
	+ assumes "lex_pm s t" and "keys s \<union> keys t \<subseteq> {..x}"
	+ shows "lex_pm (except s {x}) (except t {x})"
	+proof -
	+ from assms(1) have "s = t \<or> (\<exists>x. lookup s x < lookup t x \<and> (\<forall>y<x. lookup s y = lookup t y))"
	+ by (simp only: lex_pm_alt)
	+ thus ?thesis
	+ proof (elim disjE exE conjE)
	+ assume "s = t"
	+ thus ?thesis by (simp only: lex_pm_refl)
	+ next
	+ fix y
	+ assume "\<forall>z<y. lookup s z = lookup t z"
	+ hence eq: "lookup s z = lookup t z" if "z < y" for z using that by simp
	+ assume *: "lookup s y < lookup t y"
	+ hence "y \<in> keys s \<union> keys t" by (auto simp flip: lookup_not_eq_zero_eq_in_keys)
	+ with assms(2) have "y \<in> {..x}" ..
	+ hence "y = x \<or> y < x" by auto
	+ thus ?thesis
	+ proof
	+ assume y: "y = x"
	+ have "except s {x} = except t {x}"
	+ proof (rule poly_mapping_eqI)
	+ fix z
	+ show "lookup (except s {x}) z = lookup (except t {x}) z"
	+ proof (rule linorder_cases)
	+ assume "z < y"
	+ thus ?thesis by (simp add: lookup_except eq)
	+ next
	+ assume "y < z"
	+ hence "z \<notin> {..x}" by (simp add: y)
	+ with assms(2) have "z \<notin> keys s" and "z \<notin> keys t" by blast+
	+ with \<open>y < z\<close> show ?thesis by (simp add: y lookup_except in_keys_iff)
	+ next
	+ assume "z = y"
	+ thus ?thesis by (simp add: y lookup_except)
	+ qed
	+ qed
	+ thus ?thesis by (simp only: lex_pm_refl)
	+ next
	+ assume "y < x"
	+ show ?thesis unfolding lex_pm_alt
	+ proof (intro disjI2 exI conjI allI impI)
	+ from \<open>y < x\<close> * show "lookup (except s {x}) y < lookup (except t {x}) y"
	+ by (simp add: lookup_except)
	+ next
	+ fix z
	+ assume "z < y"
	+ hence "z < x" using \<open>y < x\<close> by (rule less_trans)
	+ with \<open>z < y\<close> show "lookup (except s {x}) z = lookup (except t {x}) z"
	+ by (simp add: lookup_except eq)
	+ qed
	+ qed
	+ qed
	+qed
	+
	+lemma lex_pm_strict_plus_left:
	+ assumes "lex_pm_strict s t" and "\<And>x y. x \<in> keys t \<Longrightarrow> y \<in> keys u \<Longrightarrow> x < y"
	+ shows "lex_pm_strict (u + s) (t::_ \<Rightarrow>\<^sub>0 'a::add_linorder_min)"
	+proof -
	+ from assms(1) obtain x where 1: "lookup s x < lookup t x" and 2: "\<And>y. y < x \<Longrightarrow> lookup s y = lookup t y"
	+ by (auto simp: lex_pm_strict_def less_poly_mapping_def less_fun_def)
	+ from 1 have "x \<in> keys t" by (auto simp flip: lookup_not_eq_zero_eq_in_keys)
	+ have lookup_u: "lookup u z = 0" if "z \<le> x" for z
	+ proof (rule ccontr)
	+ assume "lookup u z \<noteq> 0"
	+ hence "z \<in> keys u" by (simp add: in_keys_iff)
	+ with \<open>x \<in> keys t\<close> have "x < z" by (rule assms(2))
	+ with that show False by simp
	+ qed
	+ from 1 have "lookup (u + s) x < lookup t x" by (simp add: lookup_add lookup_u)
	+ moreover have "lookup (u + s) y = lookup t y" if "y < x" for y using that
	+ by (simp add: lookup_add 2 lookup_u)
	+ ultimately show ?thesis by (auto simp: lex_pm_strict_def less_poly_mapping_def less_fun_def)
	+qed
	+
	+end (* theory *)
	diff --git a/thys/Nullstellensatz/Nullstellensatz.thy b/thys/Nullstellensatz/Nullstellensatz.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Nullstellensatz/Nullstellensatz.thy
	@@ -0,0 +1,1394 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Hilbert's Nullstellensatz\<close>
	+
	+theory Nullstellensatz
	+ imports Algebraically_Closed_Fields
	+ "HOL-Computational_Algebra.Fraction_Field"
	+ Lex_Order_PP
	+ Univariate_PM
	+ Groebner_Bases.Groebner_PM
	+begin
	+
	+text \<open>We prove the geometric version of Hilbert's Nullstellensatz, i.e. the precise correspondence
	+ between algebraic varieties and radical ideals.
	+ The field-theoretic version of the Nullstellensatz is proved in theory \<open>Nullstellensatz_Field\<close>.\<close>
	+
	+subsection \<open>Preliminaries\<close>
	+
	+lemma finite_linorder_induct [consumes 1, case_names empty insert]:
	+ assumes "finite (A::'a::linorder set)" and "P {}"
	+ and "\<And>a A. finite A \<Longrightarrow> A \<subseteq> {..<a} \<Longrightarrow> P A \<Longrightarrow> P (insert a A)"
	+ shows "P A"
	+proof -
	+ define k where "k = card A"
	+ thus ?thesis using assms(1)
	+ proof (induct k arbitrary: A)
	+ case 0
	+ with assms(2) show ?case by simp
	+ next
	+ case (Suc k)
	+ define a where "a = Max A"
	+ from Suc.prems(1) have "A \<noteq> {}" by auto
	+ with Suc.prems(2) have "a \<in> A" unfolding a_def by (rule Max_in)
	+ with Suc.prems have "k = card (A - {a})" by simp
	+ moreover from Suc.prems(2) have "finite (A - {a})" by simp
	+ ultimately have "P (A - {a})" by (rule Suc.hyps)
	+ with \<open>finite (A - {a})\<close> _ have "P (insert a (A - {a}))"
	+ proof (rule assms(3))
	+ show "A - {a} \<subseteq> {..<a}"
	+ proof
	+ fix b
	+ assume "b \<in> A - {a}"
	+ hence "b \<in> A" and "b \<noteq> a" by simp_all
	+ moreover from Suc.prems(2) this(1) have "b \<le> a" unfolding a_def by (rule Max_ge)
	+ ultimately show "b \<in> {..<a}" by simp
	+ qed
	+ qed
	+ with \<open>a \<in> A\<close> show ?case by (simp add: insert_absorb)
	+ qed
	+qed
	+
	+lemma Fract_same: "Fract a a = (1 when a \<noteq> 0)"
	+ by (simp add: One_fract_def Zero_fract_def eq_fract when_def)
	+
	+lemma Fract_eq_zero_iff: "Fract a b = 0 \<longleftrightarrow> a = 0 \<or> b = 0"
	+ by (metis (no_types, lifting) Zero_fract_def eq_fract(1) eq_fract(2) mult_eq_0_iff one_neq_zero)
	+
	+lemma poly_plus_rightE:
	+ obtains c where "poly p (x + y) = poly p x + c * y"
	+proof (induct p arbitrary: thesis)
	+ case 0
	+ have "poly 0 (x + y) = poly 0 x + 0 * y" by simp
	+ thus ?case by (rule 0)
	+next
	+ case (pCons a p)
	+ obtain c where "poly p (x + y) = poly p x + c * y" by (rule pCons.hyps)
	+ hence "poly (pCons a p) (x + y) = a + (x + y) * (poly p x + c * y)" by simp
	+ also have "\<dots> = poly (pCons a p) x + (x * c + (poly p x + c * y)) * y" by (simp add: algebra_simps)
	+ finally show ?case by (rule pCons.prems)
	+qed
	+
	+lemma poly_minus_rightE:
	+ obtains c where "poly p (x - y) = poly p x - c * (y::_::comm_ring)"
	+ by (metis (no_types, hide_lams) add_uminus_conv_diff linordered_field_class.sign_simps(5)
	+ mult_minus_left poly_plus_rightE)
	+
	+lemma map_poly_plus:
	+ assumes "f 0 = 0" and "\<And>a b. f (a + b) = f a + f b"
	+ shows "map_poly f (p + q) = map_poly f p + map_poly f q"
	+ by (rule Polynomial.poly_eqI) (simp add: coeff_map_poly assms)
	+
	+lemma map_poly_minus:
	+ assumes "f 0 = 0" and "\<And>a b. f (a - b) = f a - f b"
	+ shows "map_poly f (p - q) = map_poly f p - map_poly f q"
	+ by (rule Polynomial.poly_eqI) (simp add: coeff_map_poly assms)
	+
	+lemma map_poly_sum:
	+ assumes "f 0 = 0" and "\<And>a b. f (a + b) = f a + f b"
	+ shows "map_poly f (sum g A) = (\<Sum>a\<in>A. map_poly f (g a))"
	+ by (induct A rule: infinite_finite_induct) (simp_all add: map_poly_plus assms)
	+
	+lemma map_poly_times:
	+ assumes "f 0 = 0" and "\<And>a b. f (a + b) = f a + f b" and "\<And>a b. f (a * b) = f a * f b"
	+ shows "map_poly f (p * q) = map_poly f p * map_poly f q"
	+proof (induct p)
	+ case 0
	+ show ?case by simp
	+next
	+ case (pCons c p)
	+ show ?case by (simp add: assms map_poly_plus map_poly_smult map_poly_pCons pCons)
	+qed
	+
	+lemma poly_Fract:
	+ assumes "set (Polynomial.coeffs p) \<subseteq> range (\<lambda>x. Fract x 1)"
	+ obtains q m where "poly p (Fract a b) = Fract q (b ^ m)"
	+ using assms
	+proof (induct p arbitrary: thesis)
	+ case 0
	+ have "poly 0 (Fract a b) = Fract 0 (b ^ 1)" by (simp add: fract_collapse)
	+ thus ?case by (rule 0)
	+next
	+ case (pCons c p)
	+ from pCons.hyps(1) have "insert c (set (Polynomial.coeffs p)) = set (Polynomial.coeffs (pCons c p))"
	+ by auto
	+ with pCons.prems(2) have "c \<in> range (\<lambda>x. Fract x 1)" and "set (Polynomial.coeffs p) \<subseteq> range (\<lambda>x. Fract x 1)"
	+ by blast+
	+ from this(2) obtain q0 m0 where poly_p: "poly p (Fract a b) = Fract q0 (b ^ m0)"
	+ using pCons.hyps(2) by blast
	+ from \<open>c \<in> _\<close> obtain c0 where c: "c = Fract c0 1" ..
	+ show ?case
	+ proof (cases "b = 0")
	+ case True
	+ hence "poly (pCons c p) (Fract a b) = Fract c0 (b ^ 0)" by (simp add: c fract_collapse)
	+ thus ?thesis by (rule pCons.prems)
	+ next
	+ case False
	+ hence "poly (pCons c p) (Fract a b) = Fract (c0 * b ^ Suc m0 + a * q0) (b ^ Suc m0)"
	+ by (simp add: poly_p c)
	+ thus ?thesis by (rule pCons.prems)
	+ qed
	+qed
	+
	+lemma (in ordered_term) lt_sum_le_Max: "lt (sum f A) \<preceq>\<^sub>t ord_term_lin.Max {lt (f a) \| a. a \<in> A}"
	+proof (induct A rule: infinite_finite_induct)
	+ case (infinite A)
	+ thus ?case by (simp add: min_term_min)
	+next
	+ case empty
	+ thus ?case by (simp add: min_term_min)
	+next
	+ case (insert a A)
	+ show ?case
	+ proof (cases "A = {}")
	+ case True
	+ thus ?thesis by simp
	+ next
	+ case False
	+ from insert.hyps(1, 2) have "lt (sum f (insert a A)) = lt (f a + sum f A)" by simp
	+ also have "\<dots> \<preceq>\<^sub>t ord_term_lin.max (lt (f a)) (lt (sum f A))" by (rule lt_plus_le_max)
	+ also have "\<dots> \<preceq>\<^sub>t ord_term_lin.max (lt (f a)) (ord_term_lin.Max {lt (f a) \|a. a \<in> A})"
	+ using insert.hyps(3) ord_term_lin.max.mono by blast
	+ also from insert.hyps(1) False have "\<dots> = ord_term_lin.Max (insert (lt (f a)) {lt (f x) \|x. x \<in> A})"
	+ by simp
	+ also have "\<dots> = ord_term_lin.Max {lt (f x) \|x. x \<in> insert a A}"
	+ by (rule arg_cong[where f=ord_term_lin.Max]) blast
	+ finally show ?thesis .
	+ qed
	+qed
	+
	+subsection \<open>Ideals and Varieties\<close>
	+
	+definition variety_of :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) set \<Rightarrow> ('x \<Rightarrow> 'a::comm_semiring_1) set"
	+ where "variety_of F = {a. \<forall>f\<in>F. poly_eval a f = 0}"
	+
	+definition ideal_of :: "('x \<Rightarrow> 'a::comm_semiring_1) set \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) set"
	+ where "ideal_of A = {f. \<forall>a\<in>A. poly_eval a f = 0}"
	+
	+abbreviation "\<V> \<equiv> variety_of"
	+abbreviation "\<I> \<equiv> ideal_of"
	+
	+lemma variety_ofI: "(\<And>f. f \<in> F \<Longrightarrow> poly_eval a f = 0) \<Longrightarrow> a \<in> \<V> F"
	+ by (simp add: variety_of_def)
	+
	+lemma variety_ofI_alt: "poly_eval a ` F \<subseteq> {0} \<Longrightarrow> a \<in> \<V> F"
	+ by (auto intro: variety_ofI)
	+
	+lemma variety_ofD: "a \<in> \<V> F \<Longrightarrow> f \<in> F \<Longrightarrow> poly_eval a f = 0"
	+ by (simp add: variety_of_def)
	+
	+lemma variety_of_empty [simp]: "\<V> {} = UNIV"
	+ by (simp add: variety_of_def)
	+
	+lemma variety_of_UNIV [simp]: "\<V> UNIV = {}"
	+ by (metis (mono_tags, lifting) Collect_empty_eq UNIV_I one_neq_zero poly_eval_one variety_of_def)
	+
	+lemma variety_of_antimono: "F \<subseteq> G \<Longrightarrow> \<V> G \<subseteq> \<V> F"
	+ by (auto simp: variety_of_def)
	+
	+lemma variety_of_ideal [simp]: "\<V> (ideal F) = \<V> F"
	+proof
	+ show "\<V> (ideal F) \<subseteq> \<V> F" by (intro variety_of_antimono ideal.span_superset)
	+next
	+ show "\<V> F \<subseteq> \<V> (ideal F)"
	+ proof (intro subsetI variety_ofI)
	+ fix a f
	+ assume "a \<in> \<V> F" and "f \<in> ideal F"
	+ from this(2) show "poly_eval a f = 0"
	+ proof (induct f rule: ideal.span_induct_alt)
	+ case base
	+ show ?case by simp
	+ next
	+ case (step c f g)
	+ with \<open>a \<in> \<V> F\<close> show ?case by (auto simp: poly_eval_plus poly_eval_times dest: variety_ofD)
	+ qed
	+ qed
	+qed
	+
	+lemma ideal_ofI: "(\<And>a. a \<in> A \<Longrightarrow> poly_eval a f = 0) \<Longrightarrow> f \<in> \<I> A"
	+ by (simp add: ideal_of_def)
	+
	+lemma ideal_ofD: "f \<in> \<I> A \<Longrightarrow> a \<in> A \<Longrightarrow> poly_eval a f = 0"
	+ by (simp add: ideal_of_def)
	+
	+lemma ideal_of_empty [simp]: "\<I> {} = UNIV"
	+ by (simp add: ideal_of_def)
	+
	+lemma ideal_of_antimono: "A \<subseteq> B \<Longrightarrow> \<I> B \<subseteq> \<I> A"
	+ by (auto simp: ideal_of_def)
	+
	+lemma ideal_ideal_of [simp]: "ideal (\<I> A) = \<I> A"
	+ unfolding ideal.span_eq_iff
	+proof (rule ideal.subspaceI)
	+ show "0 \<in> \<I> A" by (rule ideal_ofI) simp
	+next
	+ fix f g
	+ assume "f \<in> \<I> A"
	+ hence f: "poly_eval a f = 0" if "a \<in> A" for a using that by (rule ideal_ofD)
	+ assume "g \<in> \<I> A"
	+ hence g: "poly_eval a g = 0" if "a \<in> A" for a using that by (rule ideal_ofD)
	+ show "f + g \<in> \<I> A" by (rule ideal_ofI) (simp add: poly_eval_plus f g)
	+next
	+ fix c f
	+ assume "f \<in> \<I> A"
	+ hence f: "poly_eval a f = 0" if "a \<in> A" for a using that by (rule ideal_ofD)
	+ show "c * f \<in> \<I> A" by (rule ideal_ofI) (simp add: poly_eval_times f)
	+qed
	+
	+lemma ideal_of_UN: "\<I> (\<Union> (A ` J)) = (\<Inter>j\<in>J. \<I> (A j))"
	+proof (intro set_eqI iffI ideal_ofI INT_I)
	+ fix p j a
	+ assume "p \<in> \<I> (\<Union> (A ` J))"
	+ assume "j \<in> J" and "a \<in> A j"
	+ hence "a \<in> \<Union> (A ` J)" ..
	+ with \<open>p \<in> _\<close> show "poly_eval a p = 0" by (rule ideal_ofD)
	+next
	+ fix p a
	+ assume "a \<in> \<Union> (A ` J)"
	+ then obtain j where "j \<in> J" and "a \<in> A j" ..
	+ assume "p \<in> (\<Inter>j\<in>J. \<I> (A j))"
	+ hence "p \<in> \<I> (A j)" using \<open>j \<in> J\<close> ..
	+ thus "poly_eval a p = 0" using \<open>a \<in> A j\<close> by (rule ideal_ofD)
	+qed
	+
	+corollary ideal_of_Un: "\<I> (A \<union> B) = \<I> A \<inter> \<I> B"
	+ using ideal_of_UN[of id "{A, B}"] by simp
	+
	+lemma variety_of_ideal_of_variety [simp]: "\<V> (\<I> (\<V> F)) = \<V> F" (is "_ = ?V")
	+proof
	+ have "F \<subseteq> \<I> (\<V> F)" by (auto intro!: ideal_ofI dest: variety_ofD)
	+ thus "\<V> (\<I> ?V) \<subseteq> ?V" by (rule variety_of_antimono)
	+next
	+ show "?V \<subseteq> \<V> (\<I> ?V)" by (auto intro!: variety_ofI dest: ideal_ofD)
	+qed
	+
	+lemma ideal_of_inj_on: "inj_on \<I> (range (\<V>::(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::comm_semiring_1) set \<Rightarrow> _))"
	+proof (rule inj_onI)
	+ fix A B :: "('x \<Rightarrow> 'a) set"
	+ assume "A \<in> range \<V>"
	+ then obtain F where A: "A = \<V> F" ..
	+ assume "B \<in> range \<V>"
	+ then obtain G where B: "B = \<V> G" ..
	+ assume "\<I> A = \<I> B"
	+ hence "\<V> (\<I> A) = \<V> (\<I> B)" by simp
	+ thus "A = B" by (simp add: A B)
	+qed
	+
	+lemma ideal_of_variety_of_ideal [simp]: "\<I> (\<V> (\<I> A)) = \<I> A" (is "_ = ?I")
	+proof
	+ have "A \<subseteq> \<V> (\<I> A)" by (auto intro!: variety_ofI dest: ideal_ofD)
	+ thus "\<I> (\<V> ?I) \<subseteq> ?I" by (rule ideal_of_antimono)
	+next
	+ show "?I \<subseteq> \<I> (\<V> ?I)" by (auto intro!: ideal_ofI dest: variety_ofD)
	+qed
	+
	+lemma variety_of_inj_on: "inj_on \<V> (range (\<I>::('x \<Rightarrow> 'a::comm_semiring_1) set \<Rightarrow> _))"
	+proof (rule inj_onI)
	+ fix F G :: "(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) set"
	+ assume "F \<in> range \<I>"
	+ then obtain A where F: "F = \<I> A" ..
	+ assume "G \<in> range \<I>"
	+ then obtain B where G: "G = \<I> B" ..
	+ assume "\<V> F = \<V> G"
	+ hence "\<I> (\<V> F) = \<I> (\<V> G)" by simp
	+ thus "F = G" by (simp add: F G)
	+qed
	+
	+lemma image_map_indets_ideal_of:
	+ assumes "inj f"
	+ shows "map_indets f ` \<I> A = \<I> ((\<lambda>a. a \<circ> f) -` (A::('x \<Rightarrow> 'a::comm_semiring_1) set)) \<inter> P[range f]"
	+proof -
	+ {
	+ fix p and a::"'x \<Rightarrow> 'a"
	+ assume "\<forall>a\<in>(\<lambda>a. a \<circ> f) -` A. poly_eval (a \<circ> f) p = 0"
	+ hence eq: "poly_eval (a \<circ> f) p = 0" if "a \<circ> f \<in> A" for a using that by simp
	+ have "the_inv f \<circ> f = id" by (rule ext) (simp add: assms the_inv_f_f)
	+ hence a: "a = a \<circ> the_inv f \<circ> f" by (simp add: comp_assoc)
	+ moreover assume "a \<in> A"
	+ ultimately have "(a \<circ> the_inv f) \<circ> f \<in> A" by simp
	+ hence "poly_eval ((a \<circ> the_inv f) \<circ> f) p = 0" by (rule eq)
	+ hence "poly_eval a p = 0" by (simp flip: a)
	+ }
	+ thus ?thesis
	+ by (auto simp: ideal_of_def poly_eval_map_indets simp flip: range_map_indets intro!: imageI)
	+qed
	+
	+lemma variety_of_map_indets: "\<V> (map_indets f ` F) = (\<lambda>a. a \<circ> f) -` \<V> F"
	+ by (auto simp: variety_of_def poly_eval_map_indets)
	+
	+subsection \<open>Radical Ideals\<close>
	+
	+definition radical :: "'a::monoid_mult set \<Rightarrow> 'a set" ("\<surd>(_)" [999] 999)
	+ where "radical F = {f. \<exists>m. f ^ m \<in> F}"
	+
	+lemma radicalI: "f ^ m \<in> F \<Longrightarrow> f \<in> \<surd>F"
	+ by (auto simp: radical_def)
	+
	+lemma radicalE:
	+ assumes "f \<in> \<surd>F"
	+ obtains m where "f ^ m \<in> F"
	+ using assms by (auto simp: radical_def)
	+
	+lemma radical_empty [simp]: "\<surd>{} = {}"
	+ by (simp add: radical_def)
	+
	+lemma radical_UNIV [simp]: "\<surd>UNIV = UNIV"
	+ by (simp add: radical_def)
	+
	+lemma radical_ideal_eq_UNIV_iff: "\<surd>ideal F = UNIV \<longleftrightarrow> ideal F = UNIV"
	+proof
	+ assume "\<surd>ideal F = UNIV"
	+ hence "1 \<in> \<surd>ideal F" by simp
	+ then obtain m where "1 ^ m \<in> ideal F" by (rule radicalE)
	+ thus "ideal F = UNIV" by (simp add: ideal_eq_UNIV_iff_contains_one)
	+qed simp
	+
	+lemma zero_in_radical_ideal [simp]: "0 \<in> \<surd>ideal F"
	+proof (rule radicalI)
	+ show "0 ^ 1 \<in> ideal F" by (simp add: ideal.span_zero)
	+qed
	+
	+lemma radical_mono: "F \<subseteq> G \<Longrightarrow> \<surd>F \<subseteq> \<surd>G"
	+ by (auto elim!: radicalE intro: radicalI)
	+
	+lemma radical_superset: "F \<subseteq> \<surd>F"
	+proof
	+ fix f
	+ assume "f \<in> F"
	+ hence "f ^ 1 \<in> F" by simp
	+ thus "f \<in> \<surd>F" by (rule radicalI)
	+qed
	+
	+lemma radical_idem [simp]: "\<surd>\<surd>F = \<surd>F"
	+proof
	+ show "\<surd>\<surd>F \<subseteq> \<surd>F" by (auto elim!: radicalE intro: radicalI simp flip: power_mult)
	+qed (fact radical_superset)
	+
	+lemma radical_Int_subset: "\<surd>(A \<inter> B) \<subseteq> \<surd>A \<inter> \<surd>B"
	+ by (auto intro: radicalI elim: radicalE)
	+
	+lemma radical_ideal_Int: "\<surd>(ideal F \<inter> ideal G) = \<surd>ideal F \<inter> \<surd>ideal G"
	+ using radical_Int_subset
	+proof (rule subset_antisym)
	+ show "\<surd>ideal F \<inter> \<surd>ideal G \<subseteq> \<surd>(ideal F \<inter> ideal G)"
	+ proof
	+ fix p
	+ assume "p \<in> \<surd>ideal F \<inter> \<surd>ideal G"
	+ hence "p \<in> \<surd>ideal F" and "p \<in> \<surd>ideal G" by simp_all
	+ from this(1) obtain m1 where p1: "p ^ m1 \<in> ideal F" by (rule radicalE)
	+ from \<open>p \<in> \<surd>ideal G\<close> obtain m2 where "p ^ m2 \<in> ideal G" by (rule radicalE)
	+ hence "p ^ m1 * p ^ m2 \<in> ideal G" by (rule ideal.span_scale)
	+ moreover from p1 have "p ^ m2 * p ^ m1 \<in> ideal F" by (rule ideal.span_scale)
	+ ultimately have "p ^ (m1 + m2) \<in> ideal F \<inter> ideal G" by (simp add: power_add mult.commute)
	+ thus "p \<in> \<surd>(ideal F \<inter> ideal G)" by (rule radicalI)
	+ qed
	+qed
	+
	+lemma ideal_radical_ideal [simp]: "ideal (\<surd>ideal F) = \<surd>ideal F" (is "_ = ?R")
	+ unfolding ideal.span_eq_iff
	+proof (rule ideal.subspaceI)
	+ have "0 ^ 1 \<in> ideal F" by (simp add: ideal.span_zero)
	+ thus "0 \<in> ?R" by (rule radicalI)
	+next
	+ fix a b
	+ assume "a \<in> ?R"
	+ then obtain m where "a ^ m \<in> ideal F" by (rule radicalE)
	+ have a: "a ^ k \<in> ideal F" if "m \<le> k" for k
	+ proof -
	+ from \<open>a ^ m \<in> _\<close> have "a ^ (k - m + m) \<in> ideal F" by (simp only: power_add ideal.span_scale)
	+ with that show ?thesis by simp
	+ qed
	+ assume "b \<in> ?R"
	+ then obtain n where "b ^ n \<in> ideal F" by (rule radicalE)
	+ have b: "b ^ k \<in> ideal F" if "n \<le> k" for k
	+ proof -
	+ from \<open>b ^ n \<in> _\<close> have "b ^ (k - n + n) \<in> ideal F" by (simp only: power_add ideal.span_scale)
	+ with that show ?thesis by simp
	+ qed
	+ have "(a + b) ^ (m + n) \<in> ideal F" unfolding binomial_ring
	+ proof (rule ideal.span_sum)
	+ fix k
	+ show "of_nat (m + n choose k) * a ^ k * b ^ (m + n - k) \<in> ideal F"
	+ proof (cases "k \<le> m")
	+ case True
	+ hence "n \<le> m + n - k" by simp
	+ hence "b ^ (m + n - k) \<in> ideal F" by (rule b)
	+ thus ?thesis by (rule ideal.span_scale)
	+ next
	+ case False
	+ hence "m \<le> k" by simp
	+ hence "a ^ k \<in> ideal F" by (rule a)
	+ hence "of_nat (m + n choose k) * b ^ (m + n - k) * a ^ k \<in> ideal F" by (rule ideal.span_scale)
	+ thus ?thesis by (simp only: ac_simps)
	+ qed
	+ qed
	+ thus "a + b \<in> ?R" by (rule radicalI)
	+next
	+ fix c a
	+ assume "a \<in> ?R"
	+ then obtain m where "a ^ m \<in> ideal F" by (rule radicalE)
	+ hence "(c * a) ^ m \<in> ideal F" by (simp only: power_mult_distrib ideal.span_scale)
	+ thus "c * a \<in> ?R" by (rule radicalI)
	+qed
	+
	+lemma radical_ideal_of [simp]: "\<surd>\<I> A = \<I> (A::(_ \<Rightarrow> _::semiring_1_no_zero_divisors) set)"
	+proof
	+ show "\<surd>\<I> A \<subseteq> \<I> A" by (auto elim!: radicalE dest!: ideal_ofD intro!: ideal_ofI simp: poly_eval_power)
	+qed (fact radical_superset)
	+
	+lemma variety_of_radical_ideal [simp]: "\<V> (\<surd>ideal F) = \<V> (F::(_ \<Rightarrow>\<^sub>0 _::semiring_1_no_zero_divisors) set)"
	+proof
	+ have "F \<subseteq> ideal F" by (rule ideal.span_superset)
	+ also have "\<dots> \<subseteq> \<surd>ideal F" by (rule radical_superset)
	+ finally show "\<V> (\<surd>ideal F) \<subseteq> \<V> F" by (rule variety_of_antimono)
	+next
	+ show "\<V> F \<subseteq> \<V> (\<surd>ideal F)"
	+ proof (intro subsetI variety_ofI)
	+ fix a f
	+ assume "a \<in> \<V> F"
	+ hence "a \<in> \<V> (ideal F)" by simp
	+ assume "f \<in> \<surd>ideal F"
	+ then obtain m where "f ^ m \<in> ideal F" by (rule radicalE)
	+ with \<open>a \<in> \<V> (ideal F)\<close> have "poly_eval a (f ^ m) = 0" by (rule variety_ofD)
	+ thus "poly_eval a f = 0" by (simp add: poly_eval_power)
	+ qed
	+qed
	+
	+lemma image_map_indets_radical:
	+ assumes "inj f"
	+ shows "map_indets f ` \<surd>F = \<surd>(map_indets f ` (F::(_ \<Rightarrow>\<^sub>0 'a::comm_ring_1) set)) \<inter> P[range f]"
	+proof
	+ show "map_indets f ` \<surd>F \<subseteq> \<surd>(map_indets f ` F) \<inter> P[range f]"
	+ by (auto simp: radical_def simp flip: map_indets_power range_map_indets intro!: imageI)
	+next
	+ show "\<surd>(map_indets f ` F) \<inter> P[range f] \<subseteq> map_indets f ` \<surd>F"
	+ proof
	+ fix p
	+ assume "p \<in> \<surd>(map_indets f ` F) \<inter> P[range f]"
	+ hence "p \<in> \<surd>(map_indets f ` F)" and "p \<in> range (map_indets f)"
	+ by (simp_all add: range_map_indets)
	+ from this(1) obtain m where "p ^ m \<in> map_indets f ` F" by (rule radicalE)
	+ then obtain q where "q \<in> F" and p_m: "p ^ m = map_indets f q" ..
	+ from assms obtain g where "g \<circ> f = id" and "map_indets g \<circ> map_indets f = (id::_ \<Rightarrow> _ \<Rightarrow>\<^sub>0 'a)"
	+ by (rule map_indets_inverseE)
	+ hence eq: "map_indets g (map_indets f p') = p'" for p'::"_ \<Rightarrow>\<^sub>0 'a"
	+ by (simp add: pointfree_idE)
	+ from p_m have "map_indets g (p ^ m) = map_indets g (map_indets f q)" by (rule arg_cong)
	+ hence "(map_indets g p) ^ m = q" by (simp add: eq)
	+ from \<open>p \<in> range _\<close> obtain p' where "p = map_indets f p'" ..
	+ hence "p = map_indets f (map_indets g p)" by (simp add: eq)
	+ moreover have "map_indets g p \<in> \<surd>F"
	+ proof (rule radicalI)
	+ from \<open>q \<in> F\<close> show "map_indets g p ^ m \<in> F" by (simp add: p_m eq flip: map_indets_power)
	+ qed
	+ ultimately show "p \<in> map_indets f ` \<surd>F" by (rule image_eqI)
	+ qed
	+qed
	+
	+subsection \<open>Geometric Version of the Nullstellensatz\<close>
	+
	+lemma weak_Nullstellensatz_aux_1:
	+ assumes "\<And>i. i \<in> I \<Longrightarrow> g i \<in> ideal B"
	+ obtains c where "c \<in> ideal B" and "(\<Prod>i\<in>I. (f i + g i) ^ m i) = (\<Prod>i\<in>I. f i ^ m i) + c"
	+ using assms
	+proof (induct I arbitrary: thesis rule: infinite_finite_induct)
	+ case (infinite I)
	+ from ideal.span_zero show ?case by (rule infinite) (simp add: infinite(1))
	+next
	+ case empty
	+ from ideal.span_zero show ?case by (rule empty) simp
	+next
	+ case (insert j I)
	+ have "g i \<in> ideal B" if "i \<in> I" for i by (rule insert.prems) (simp add: that)
	+ with insert.hyps(3) obtain c where c: "c \<in> ideal B"
	+ and 1: "(\<Prod>i\<in>I. (f i + g i) ^ m i) = (\<Prod>i\<in>I. f i ^ m i) + c" by blast
	+ define k where "k = m j"
	+ obtain d where 2: "(f j + g j) ^ m j = f j ^ m j + d * g j" unfolding k_def[symmetric]
	+ proof (induct k arbitrary: thesis)
	+ case 0
	+ have "(f j + g j) ^ 0 = f j ^ 0 + 0 * g j" by simp
	+ thus ?case by (rule 0)
	+ next
	+ case (Suc k)
	+ obtain d where "(f j + g j) ^ k = f j ^ k + d * g j" by (rule Suc.hyps)
	+ hence "(f j + g j) ^ Suc k = (f j ^ k + d * g j) * (f j + g j)" by simp
	+ also have "\<dots> = f j ^ Suc k + (f j ^ k + d * (f j + g j)) * g j" by (simp add: algebra_simps)
	+ finally show ?case by (rule Suc.prems)
	+ qed
	+ from c have : "f j ^ m j c + (((\<Prod>i\<in>I. f i ^ m i) + c) * d) * g j \<in> ideal B" (is "?c \<in> _")
	+ by (intro ideal.span_add ideal.span_scale insert.prems insertI1)
	+ from insert.hyps(1, 2) have "(\<Prod>i\<in>insert j I. (f i + g i) ^ m i) =
	+ (f j ^ m j + d * g j) * ((\<Prod>i\<in>I. f i ^ m i) + c)"
	+ by (simp add: 1 2)
	+ also from insert.hyps(1, 2) have "\<dots> = (\<Prod>i\<in>insert j I. f i ^ m i) + ?c" by (simp add: algebra_simps)
	+ finally have "(\<Prod>i\<in>insert j I. (f i + g i) ^ m i) = (\<Prod>i\<in>insert j I. f i ^ m i) + ?c" .
	+ with * show ?case by (rule insert.prems)
	+qed
	+
	+lemma weak_Nullstellensatz_aux_2:
	+ assumes "finite X" and "F \<subseteq> P[insert x X]" and "X \<subseteq> {..<x::'x::{countable,linorder}}"
	+ and "1 \<notin> ideal F" and "ideal F \<inter> P[{x}] \<subseteq> {0}"
	+ obtains a::"'a::alg_closed_field" where "1 \<notin> ideal (poly_eval (\<lambda>_. monomial a 0) ` focus {x} ` F)"
	+proof -
	+ let ?x = "monomial 1 (Poly_Mapping.single x 1)"
	+ from assms(3) have "x \<notin> X" by blast
	+ hence eq1: "insert x X - {x} = X" and eq2: "insert x X - X = {x}" by blast+
	+
	+ interpret i: pm_powerprod lex_pm "lex_pm_strict::('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow> _"
	+ unfolding lex_pm_def lex_pm_strict_def
	+ by standard (simp_all add: lex_pm_zero_min lex_pm_plus_monotone flip: lex_pm_def)
	+ have lpp_focus: "i.lpp (focus X g) = except (i.lpp g) {x}" if "g \<in> P[insert x X]" for g::"_ \<Rightarrow>\<^sub>0 'a"
	+ proof (cases "g = 0")
	+ case True
	+ thus ?thesis by simp
	+ next
	+ case False
	+ have keys_focus_g: "keys (focus X g) = (\<lambda>t. except t {x}) ` keys g"
	+ unfolding keys_focus using refl
	+ proof (rule image_cong)
	+ fix t
	+ assume "t \<in> keys g"
	+ also from that have "\<dots> \<subseteq> .[insert x X]" by (rule PolysD)
	+ finally have "keys t \<subseteq> insert x X" by (rule PPsD)
	+ hence "except t (- X) = except t (insert x X \<inter> - X)"
	+ by (metis (no_types, lifting) Int_commute except_keys_Int inf.orderE inf_left_commute)
	+ also from \<open>x \<notin> X\<close> have "insert x X \<inter> - X = {x}" by simp
	+ finally show "except t (- X) = except t {x}" .
	+ qed
	+ show ?thesis
	+ proof (rule i.punit.lt_eqI_keys)
	+ from False have "i.lpp g \<in> keys g" by (rule i.punit.lt_in_keys)
	+ thus "except (i.lpp g) {x} \<in> keys (focus X g)" unfolding keys_focus_g by (rule imageI)
	+
	+ fix t
	+ assume "t \<in> keys (focus X g)"
	+ then obtain s where "s \<in> keys g" and t: "t = except s {x}" unfolding keys_focus_g ..
	+ from this(1) have "lex_pm s (i.lpp g)" by (rule i.punit.lt_max_keys)
	+ moreover have "keys s \<union> keys (i.lpp g) \<subseteq> {..x}"
	+ proof (rule Un_least)
	+ from \<open>g \<in> P[_]\<close> have "keys g \<subseteq> .[insert x X]" by (rule PolysD)
	+ with \<open>s \<in> keys g\<close> have "s \<in> .[insert x X]" ..
	+ hence "keys s \<subseteq> insert x X" by (rule PPsD)
	+ thus "keys s \<subseteq> {..x}" using assms(3) by auto
	+
	+ from \<open>i.lpp g \<in> keys g\<close> \<open>keys g \<subseteq> _\<close> have "i.lpp g \<in> .[insert x X]" ..
	+ hence "keys (i.lpp g) \<subseteq> insert x X" by (rule PPsD)
	+ thus "keys (i.lpp g) \<subseteq> {..x}" using assms(3) by auto
	+ qed
	+ ultimately show "lex_pm t (except (i.lpp g) {x})" unfolding t by (rule lex_pm_except_max)
	+ qed
	+ qed
	+
	+ define G where "G = i.punit.reduced_GB F"
	+ from assms(1) have "finite (insert x X)" by simp
	+ hence fin_G: "finite G" and G_sub: "G \<subseteq> P[insert x X]" and ideal_G: "ideal G = ideal F"
	+ and "0 \<notin> G" and G_isGB: "i.punit.is_Groebner_basis G" unfolding G_def using assms(2)
	+ by (rule i.finite_reduced_GB_Polys, rule i.reduced_GB_Polys, rule i.reduced_GB_ideal_Polys,
	+ rule i.reduced_GB_nonzero_Polys, rule i.reduced_GB_is_GB_Polys)
	+ define G' where "G' = focus X ` G"
	+ from fin_G \<open>0 \<notin> G\<close> have fin_G': "finite G'" and "0 \<notin> G'" by (auto simp: G'_def)
	+ have G'_sub: "G' \<subseteq> P[X]" by (auto simp: G'_def intro: focus_in_Polys)
	+ define G'' where "G'' = i.lcf ` G'"
	+ from \<open>0 \<notin> G'\<close> have "0 \<notin> G''" by (auto simp: G''_def i.punit.lc_eq_zero_iff)
	+ have lookup_focus_in: "lookup (focus X g) t \<in> P[{x}]" if "g \<in> G" for g t
	+ proof -
	+ have "lookup (focus X g) t \<in> range (lookup (focus X g))" by (rule rangeI)
	+ from that G_sub have "g \<in> P[insert x X]" ..
	+ hence "range (lookup (focus X g)) \<subseteq> P[insert x X - X]" by (rule focus_coeffs_subset_Polys')
	+ with \<open>_ \<in> range _\<close> have "lookup (focus X g) t \<in> P[insert x X - X]" ..
	+ also have "insert x X - X = {x}" by (simp only: eq2)
	+ finally show ?thesis .
	+ qed
	+ hence lcf_in: "i.lcf (focus X g) \<in> P[{x}]" if "g \<in> G" for g
	+ unfolding i.punit.lc_def using that by blast
	+ have G''_sub: "G'' \<subseteq> P[{x}]"
	+ proof
	+ fix c
	+ assume "c \<in> G''"
	+ then obtain g' where "g' \<in> G'" and c: "c = i.lcf g'" unfolding G''_def ..
	+ from \<open>g' \<in> G'\<close> obtain g where "g \<in> G" and g': "g' = focus X g" unfolding G'_def ..
	+ from this(1) show "c \<in> P[{x}]" unfolding c g' by (rule lcf_in)
	+ qed
	+ define P where "P = poly_of_pm x ` G''"
	+ from fin_G' have fin_P: "finite P" by (simp add: P_def G''_def)
	+ have "0 \<notin> P"
	+ proof
	+ assume "0 \<in> P"
	+ then obtain g'' where "g'' \<in> G''" and "0 = poly_of_pm x g''" unfolding P_def ..
	+ from this(2) have *: "keys g'' \<inter> .[{x}] = {}" by (simp add: poly_of_pm_eq_zero_iff)
	+ from \<open>g'' \<in> G''\<close> G''_sub have "g'' \<in> P[{x}]" ..
	+ hence "keys g'' \<subseteq> .[{x}]" by (rule PolysD)
	+ with * have "keys g'' = {}" by blast
	+ with \<open>g'' \<in> G''\<close> \<open>0 \<notin> G''\<close> show False by simp
	+ qed
	+ define Z where "Z = (\<Union>p\<in>P. {z. poly p z = 0})"
	+ have "finite Z" unfolding Z_def using fin_P
	+ proof (rule finite_UN_I)
	+ fix p
	+ assume "p \<in> P"
	+ with \<open>0 \<notin> P\<close> have "p \<noteq> 0" by blast
	+ thus "finite {z. poly p z = 0}" by (rule poly_roots_finite)
	+ qed
	+ with infinite_UNIV[where 'a='a] have "- Z \<noteq> {}" using finite_compl by fastforce
	+ then obtain a where "a \<notin> Z" by blast
	+
	+ have a_nz: "poly_eval (\<lambda>_. a) (i.lcf (focus X g)) \<noteq> 0" if "g \<in> G" for g
	+ proof -
	+ from that G_sub have "g \<in> P[insert x X]" ..
	+ have "poly_eval (\<lambda>_. a) (i.lcf (focus X g)) = poly (poly_of_pm x (i.lcf (focus X g))) a"
	+ by (rule sym, intro poly_eq_poly_eval' lcf_in that)
	+ moreover have "poly_of_pm x (i.lcf (focus X g)) \<in> P"
	+ by (auto simp: P_def G''_def G'_def that intro!: imageI)
	+ ultimately show ?thesis using \<open>a \<notin> Z\<close> by (simp add: Z_def)
	+ qed
	+
	+ let ?e = "poly_eval (\<lambda>_. monomial a 0)"
	+ have lookup_e_focus: "lookup (?e (focus {x} g)) t = poly_eval (\<lambda>_. a) (lookup (focus X g) t)"
	+ if "g \<in> P[insert x X]" for g t
	+ proof -
	+ have "focus (- {x}) g = focus (- {x} \<inter> insert x X) g" by (rule sym) (rule focus_Int, fact)
	+ also have "\<dots> = focus X g" by (simp add: Int_commute eq1 flip: Diff_eq)
	+ finally show ?thesis by (simp add: lookup_poly_eval_focus)
	+ qed
	+ have lpp_e_focus: "i.lpp (?e (focus {x} g)) = except (i.lpp g) {x}" if "g \<in> G" for g
	+ proof (rule i.punit.lt_eqI_keys)
	+ from that G_sub have "g \<in> P[insert x X]" ..
	+ hence "lookup (?e (focus {x} g)) (except (i.lpp g) {x}) = poly_eval (\<lambda>_. a) (i.lcf (focus X g))"
	+ by (simp only: lookup_e_focus lpp_focus i.punit.lc_def)
	+ also from that have "\<dots> \<noteq> 0" by (rule a_nz)
	+ finally show "except (i.lpp g) {x} \<in> keys (?e (focus {x} g))" by (simp add: in_keys_iff)
	+
	+ fix t
	+ assume "t \<in> keys (?e (focus {x} g))"
	+ hence "0 \<noteq> lookup (?e (focus {x} g)) t" by (simp add: in_keys_iff)
	+ also from \<open>g \<in> P[_]\<close> have "lookup (?e (focus {x} g)) t = poly_eval (\<lambda>_. a) (lookup (focus X g) t)"
	+ by (rule lookup_e_focus)
	+ finally have "t \<in> keys (focus X g)" by (auto simp flip: lookup_not_eq_zero_eq_in_keys)
	+ hence "lex_pm t (i.lpp (focus X g))" by (rule i.punit.lt_max_keys)
	+ with \<open>g \<in> P[_]\<close> show "lex_pm t (except (i.lpp g) {x})" by (simp only: lpp_focus)
	+ qed
	+
	+ show ?thesis
	+ proof
	+ define G3 where "G3 = ?e ` focus {x} ` G"
	+ have "G3 \<subseteq> P[X]"
	+ proof
	+ fix h
	+ assume "h \<in> G3"
	+ then obtain h0 where "h0 \<in> G" and h: "h = ?e (focus {x} h0)" by (auto simp: G3_def)
	+ from this(1) G_sub have "h0 \<in> P[insert x X]" ..
	+ hence "h \<in> P[insert x X - {x}]" unfolding h by (rule poly_eval_focus_in_Polys)
	+ thus "h \<in> P[X]" by (simp only: eq1)
	+ qed
	+ from fin_G have "finite G3" by (simp add: G3_def)
	+
	+ have "ideal G3 \<inter> P[- {x}] = ?e ` focus {x} ` ideal G"
	+ by (simp only: G3_def image_poly_eval_focus_ideal)
	+ also have "\<dots> = ideal (?e ` focus {x} ` F) \<inter> P[- {x}]"
	+ by (simp only: ideal_G image_poly_eval_focus_ideal)
	+ finally have eq3: "ideal G3 \<inter> P[- {x}] = ideal (?e ` focus {x} ` F) \<inter> P[- {x}]" .
	+ from assms(1) \<open>G3 \<subseteq> P[X]\<close> \<open>finite G3\<close> have G3_isGB: "i.punit.is_Groebner_basis G3"
	+ proof (rule i.punit.isGB_I_spoly_rep[simplified, OF dickson_grading_varnum,
	+ where m=0, simplified i.dgrad_p_set_varnum])
	+ fix g1 g2
	+ assume "g1 \<in> G3"
	+ then obtain g1' where "g1' \<in> G" and g1: "g1 = ?e (focus {x} g1')"
	+ unfolding G3_def by blast
	+ from this(1) have lpp1: "i.lpp g1 = except (i.lpp g1') {x}" unfolding g1 by (rule lpp_e_focus)
	+ from \<open>g1' \<in> G\<close> G_sub have "g1' \<in> P[insert x X]" ..
	+ assume "g2 \<in> G3"
	+ then obtain g2' where "g2' \<in> G" and g2: "g2 = ?e (focus {x} g2')"
	+ unfolding G3_def by blast
	+ from this(1) have lpp2: "i.lpp g2 = except (i.lpp g2') {x}" unfolding g2 by (rule lpp_e_focus)
	+ from \<open>g2' \<in> G\<close> G_sub have "g2' \<in> P[insert x X]" ..
	+
	+ define l where "l = lcs (except (i.lpp g1') {x}) (except (i.lpp g2') {x})"
	+ define c1 where "c1 = i.lcf (focus X g1')"
	+ define c2 where "c2 = i.lcf (focus X g2')"
	+ define c where "c = poly_eval (\<lambda>_. a) c1 * poly_eval (\<lambda>_. a) c2"
	+ define s where "s = c2 * punit.monom_mult 1 (l - except (i.lpp g1') {x}) g1' -
	+ c1 * punit.monom_mult 1 (l - except (i.lpp g2') {x}) g2'"
	+ have "c1 \<in> P[{x}]" unfolding c1_def using \<open>g1' \<in> G\<close> by (rule lcf_in)
	+ hence eval_c1: "poly_eval (\<lambda>_. monomial a 0) (focus {x} c1) = monomial (poly_eval (\<lambda>_. a) c1) 0"
	+ by (simp add: focus_Polys poly_eval_sum poly_eval_monomial monomial_power_map_scale
	+ times_monomial_monomial flip: punit.monomial_prod_sum monomial_sum)
	+ (simp add: poly_eval_alt)
	+ have "c2 \<in> P[{x}]" unfolding c2_def using \<open>g2' \<in> G\<close> by (rule lcf_in)
	+ hence eval_c2: "poly_eval (\<lambda>_. monomial a 0) (focus {x} c2) = monomial (poly_eval (\<lambda>_. a) c2) 0"
	+ by (simp add: focus_Polys poly_eval_sum poly_eval_monomial monomial_power_map_scale
	+ times_monomial_monomial flip: punit.monomial_prod_sum monomial_sum)
	+ (simp add: poly_eval_alt)
	+
	+ assume spoly_nz: "i.punit.spoly g1 g2 \<noteq> 0"
	+ assume "g1 \<noteq> 0" and "g2 \<noteq> 0"
	+ hence "g1' \<noteq> 0" and "g2' \<noteq> 0" by (auto simp: g1 g2)
	+ have c1_nz: "poly_eval (\<lambda>_. a) c1 \<noteq> 0" unfolding c1_def using \<open>g1' \<in> G\<close> by (rule a_nz)
	+ moreover have c2_nz: "poly_eval (\<lambda>_. a) c2 \<noteq> 0" unfolding c2_def using \<open>g2' \<in> G\<close> by (rule a_nz)
	+ ultimately have "c \<noteq> 0" by (simp add: c_def)
	+ hence "inverse c \<noteq> 0" by simp
	+ from \<open>g1' \<in> P[_]\<close> have "except (i.lpp g1') {x} \<in> .[insert x X - {x}]"
	+ by (intro PPs_closed_except' i.PPs_closed_lpp)
	+ moreover from \<open>g2' \<in> P[_]\<close> have "except (i.lpp g2') {x} \<in> .[insert x X - {x}]"
	+ by (intro PPs_closed_except' i.PPs_closed_lpp)
	+ ultimately have "l \<in> .[insert x X - {x}]" unfolding l_def by (rule PPs_closed_lcs)
	+ hence "l \<in> .[X]" by (simp only: eq1)
	+ hence "l \<in> .[insert x X]" by rule (rule PPs_mono, blast)
	+ moreover from \<open>c1 \<in> P[{x}]\<close> have "c1 \<in> P[insert x X]" by rule (intro Polys_mono, simp)
	+ moreover from \<open>c2 \<in> P[{x}]\<close> have "c2 \<in> P[insert x X]" by rule (intro Polys_mono, simp)
	+ ultimately have "s \<in> P[insert x X]" using \<open>g1' \<in> P[_]\<close> \<open>g2' \<in> P[_]\<close> unfolding s_def
	+ by (intro Polys_closed_minus Polys_closed_times Polys_closed_monom_mult PPs_closed_minus)
	+ have "s \<in> ideal G" unfolding s_def times_monomial_left[symmetric]
	+ by (intro ideal.span_diff ideal.span_scale ideal.span_base \<open>g1' \<in> G\<close> \<open>g2' \<in> G\<close>)
	+ with G_isGB have "(i.punit.red G)\<^sup>\<^sup> s 0" by (rule i.punit.GB_imp_zero_reducibility[simplified])
	+ with \<open>finite (insert x X)\<close> G_sub fin_G \<open>s \<in> P[_]\<close>
	+ obtain q0 where 1: "s = 0 + (\<Sum>g\<in>G. q0 g * g)" and 2: "\<And>g. q0 g \<in> P[insert x X]"
	+ and 3: "\<And>g. lex_pm (i.lpp (q0 g * g)) (i.lpp s)"
	+ by (rule i.punit.red_rtrancl_repE[simplified, OF dickson_grading_varnum, where m=0,
	+ simplified i.dgrad_p_set_varnum]) blast
	+
	+ define q where "q = (\<lambda>g. inverse c \<cdot> (\<Sum>h\<in>{y\<in>G. ?e (focus {x} y) = g}. ?e (focus {x} (q0 h))))"
	+
	+ have eq4: "?e (focus {x} (monomial 1 (l - t))) = monomial 1 (l - t)" for t
	+ proof -
	+ have "focus {x} (monomial (1::'a) (l - t)) = monomial (monomial 1 (l - t)) 0"
	+ proof (intro focus_Polys_Compl Polys_closed_monomial PPs_closed_minus)
	+ from \<open>x \<notin> X\<close> have "X \<subseteq> - {x}" by simp
	+ hence ".[X] \<subseteq> .[- {x}]" by (rule PPs_mono)
	+ with \<open>l \<in> .[X]\<close> show "l \<in> .[- {x}]" ..
	+ qed
	+ thus ?thesis by (simp add: poly_eval_monomial)
	+ qed
	+ from c2_nz have eq5: "inverse c * poly_eval (\<lambda>_. a) c2 = 1 / lookup g1 (i.lpp g1)"
	+ unfolding lpp1 using \<open>g1' \<in> P[_]\<close>
	+ by (simp add: c_def mult.assoc divide_inverse_commute g1 lookup_e_focus
	+ flip: lpp_focus i.punit.lc_def c1_def)
	+ from c1_nz have eq6: "inverse c * poly_eval (\<lambda>_. a) c1 = 1 / lookup g2 (i.lpp g2)"
	+ unfolding lpp2 using \<open>g2' \<in> P[_]\<close>
	+ by (simp add: c_def mult.assoc mult.left_commute[of "inverse (poly_eval (\<lambda>_. a) c1)"]
	+ divide_inverse_commute g2 lookup_e_focus flip: lpp_focus i.punit.lc_def c2_def)
	+ have l_alt: "l = lcs (i.lpp g1) (i.lpp g2)" by (simp only: l_def lpp1 lpp2)
	+ have spoly_eq: "i.punit.spoly g1 g2 = (inverse c) \<cdot> ?e (focus {x} s)"
	+ by (simp add: s_def focus_minus focus_times poly_eval_minus poly_eval_times eval_c1 eval_c2
	+ eq4 eq5 eq6 map_scale_eq_times times_monomial_monomial right_diff_distrib
	+ i.punit.spoly_def Let_def
	+ flip: mult.assoc times_monomial_left g1 g2 lpp1 lpp2 l_alt)
	+ also have "\<dots> = (\<Sum>g\<in>G. inverse c \<cdot> (?e (focus {x} (q0 g)) * ?e (focus {x} g)))"
	+ by (simp add: 1 focus_sum poly_eval_sum focus_times poly_eval_times map_scale_sum_distrib_left)
	+ also have "\<dots> = (\<Sum>g\<in>G3. \<Sum>h\<in>{y\<in>G. ?e (focus{x} y) = g}.
	+ inverse c \<cdot> (?e (focus {x} (q0 h)) * ?e (focus {x} h)))"
	+ unfolding G3_def image_image using fin_G by (rule sum.image_gen)
	+ also have "\<dots> = (\<Sum>g\<in>G3. inverse c \<cdot> (\<Sum>h\<in>{y\<in>G. ?e (focus{x} y) = g}. ?e (focus {x} (q0 h))) * g)"
	+ by (intro sum.cong refl) (simp add: map_scale_eq_times sum_distrib_left sum_distrib_right mult.assoc)
	+ also from refl have "\<dots> = (\<Sum>g\<in>G3. q g * g)" by (rule sum.cong) (simp add: q_def sum_distrib_right)
	+ finally have "i.punit.spoly g1 g2 = (\<Sum>g\<in>G3. q g * g)" .
	+ thus "i.punit.spoly_rep (varnum X) 0 G3 g1 g2"
	+ proof (rule i.punit.spoly_repI[simplified, where m=0 and d="varnum X",
	+ simplified i.dgrad_p_set_varnum])
	+ fix g
	+ show "q g \<in> P[X]" unfolding q_def
	+ proof (intro Polys_closed_map_scale Polys_closed_sum)
	+ fix g0
	+ from \<open>q0 g0 \<in> P[insert x X]\<close> have "?e (focus {x} (q0 g0)) \<in> P[insert x X - {x}]"
	+ by (rule poly_eval_focus_in_Polys)
	+ thus "?e (focus {x} (q0 g0)) \<in> P[X]" by (simp only: eq1)
	+ qed
	+
	+ assume "q g \<noteq> 0 \<and> g \<noteq> 0"
	+ hence "q g \<noteq> 0" ..
	+ have "i.lpp (q g * g) = i.lpp (\<Sum>h\<in>{y\<in>G. ?e (focus {x} y) = g}. inverse c \<cdot> ?e (focus {x} (q0 h)) * g)"
	+ by (simp add: q_def map_scale_sum_distrib_left sum_distrib_right)
	+ also have "lex_pm \<dots> (i.ordered_powerprod_lin.Max
	+ {i.lpp (inverse c \<cdot> ?e (focus {x} (q0 h)) * g) \| h. h \<in> {y\<in>G. ?e (focus {x} y) = g}})"
	+ (is "lex_pm _ (i.ordered_powerprod_lin.Max ?A)") by (fact i.punit.lt_sum_le_Max)
	+ also have "lex_pm \<dots> (i.lpp s)"
	+ proof (rule i.ordered_powerprod_lin.Max.boundedI)
	+ from fin_G show "finite ?A" by simp
	+ next
	+ show "?A \<noteq> {}"
	+ proof
	+ assume "?A = {}"
	+ hence "{h \<in> G. ?e (focus {x} h) = g} = {}" by simp
	+ hence "q g = 0" by (simp only: q_def sum.empty map_scale_zero_right)
	+ with \<open>q g \<noteq> 0\<close> show False ..
	+ qed
	+ next
	+ fix t
	+ assume "t \<in> ?A"
	+ then obtain h where "h \<in> G" and g[symmetric]: "?e (focus {x} h) = g"
	+ and "t = i.lpp (inverse c \<cdot> ?e (focus {x} (q0 h)) * g)" by blast
	+ note this(3)
	+ also have "i.lpp (inverse c \<cdot> ?e (focus {x} (q0 h)) * g) =
	+ i.lpp (inverse c \<cdot> (?e (focus {x} (q0 h * h))))"
	+ by (simp only: map_scale_eq_times mult.assoc g poly_eval_times focus_times)
	+ also from \<open>inverse c \<noteq> 0\<close> have "\<dots> = i.lpp (?e (focus {x} (q0 h * h)))"
	+ by (rule i.punit.lt_map_scale)
	+ also have "lex_pm \<dots> (i.lpp (q0 h * h))"
	+ proof (rule i.punit.lt_le, rule ccontr)
	+ fix u
	+ assume "lookup (?e (focus {x} (q0 h * h))) u \<noteq> 0"
	+ hence "u \<in> keys (?e (focus {x} (q0 h * h)))" by (simp add: in_keys_iff)
	+ with keys_poly_eval_focus_subset have "u \<in> (\<lambda>v. except v {x}) ` keys (q0 h * h)" ..
	+ then obtain v where "v \<in> keys (q0 h * h)" and u: "u = except v {x}" ..
	+ have "lex_pm u (Poly_Mapping.single x (lookup v x) + u)"
	+ by (metis add.commute add.right_neutral i.plus_monotone_left lex_pm_zero_min)
	+ also have "\<dots> = v" by (simp only: u flip: plus_except)
	+ also from \<open>v \<in> _\<close> have "lex_pm v (i.lpp (q0 h * h))" by (rule i.punit.lt_max_keys)
	+ finally have "lex_pm u (i.lpp (q0 h * h))" .
	+ moreover assume "lex_pm_strict (i.lpp (q0 h * h)) u"
	+ ultimately show False by simp
	+ qed
	+ also have "lex_pm \<dots> (i.lpp s)" by fact
	+ finally show "lex_pm t (i.lpp s)" .
	+ qed
	+ also have "lex_pm_strict \<dots> l"
	+ proof (rule i.punit.lt_less)
	+ from spoly_nz show "s \<noteq> 0" by (auto simp: spoly_eq)
	+ next
	+ fix t
	+ assume "lex_pm l t"
	+
	+ have "g1' = flatten (focus X g1')" by simp
	+ also have "\<dots> = flatten (monomial c1 (i.lpp (focus X g1')) + i.punit.tail (focus X g1'))"
	+ by (simp only: c1_def flip: i.punit.leading_monomial_tail)
	+ also from \<open>g1' \<in> P[_]\<close> have "\<dots> = punit.monom_mult 1 (except (i.lpp g1') {x}) c1 +
	+ flatten (i.punit.tail (focus X g1'))"
	+ by (simp only: flatten_plus flatten_monomial lpp_focus)
	+ finally have "punit.monom_mult 1 (except (i.lpp g1') {x}) c1 +
	+ flatten (i.punit.tail (focus X g1')) = g1'" (is "?l = _") by (rule sym)
	+ moreover have "c2 * punit.monom_mult 1 (l - except (i.lpp g1') {x}) ?l =
	+ punit.monom_mult 1 l (c1 * c2) +
	+ c2 * punit.monom_mult 1 (l - i.lpp (focus X g1'))
	+ (flatten (i.punit.tail (focus X g1')))"
	+ (is "_ = punit.monom_mult 1 l (c1 * c2) + ?a")
	+ by (simp add: punit.monom_mult_dist_right punit.monom_mult_assoc l_def minus_plus adds_lcs)
	+ (simp add: distrib_left lpp_focus \<open>g1' \<in> P[_]\<close> flip: times_monomial_left)
	+ ultimately have a: "c2 * punit.monom_mult 1 (l - except (i.lpp g1') {x}) g1' =
	+ punit.monom_mult 1 l (c1 * c2) + ?a" by simp
	+
	+ have "g2' = flatten (focus X g2')" by simp
	+ also have "\<dots> = flatten (monomial c2 (i.lpp (focus X g2')) + i.punit.tail (focus X g2'))"
	+ by (simp only: c2_def flip: i.punit.leading_monomial_tail)
	+ also from \<open>g2' \<in> P[_]\<close> have "\<dots> = punit.monom_mult 1 (except (i.lpp g2') {x}) c2 +
	+ flatten (i.punit.tail (focus X g2'))"
	+ by (simp only: flatten_plus flatten_monomial lpp_focus)
	+ finally have "punit.monom_mult 1 (except (i.lpp g2') {x}) c2 +
	+ flatten (i.punit.tail (focus X g2')) = g2'" (is "?l = _") by (rule sym)
	+ moreover have "c1 * punit.monom_mult 1 (l - except (i.lpp g2') {x}) ?l =
	+ punit.monom_mult 1 l (c1 * c2) +
	+ c1 * punit.monom_mult 1 (l - i.lpp (focus X g2'))
	+ (flatten (i.punit.tail (focus X g2')))"
	+ (is "_ = punit.monom_mult 1 l (c1 * c2) + ?b")
	+ by (simp add: punit.monom_mult_dist_right punit.monom_mult_assoc l_def minus_plus adds_lcs_2)
	+ (simp add: distrib_left lpp_focus \<open>g2' \<in> P[_]\<close> flip: times_monomial_left)
	+ ultimately have b: "c1 * punit.monom_mult 1 (l - except (i.lpp g2') {x}) g2' =
	+ punit.monom_mult 1 l (c1 * c2) + ?b" by simp
	+
	+ have lex_pm_strict_t: "lex_pm_strict t (l - i.lpp (focus X h) + i.lpp (focus X h))"
	+ if "t \<in> keys (d * punit.monom_mult 1 (l - i.lpp (focus X h))
	+ (flatten (i.punit.tail (focus X h))))"
	+ and "h \<in> G" and "d \<in> P[{x}]" for d h
	+ proof -
	+ have 0: "lex_pm_strict (u + v) w" if "lex_pm_strict v w" and "w \<in> .[X]" and "u \<in> .[{x}]"
	+ for u v w using that(1)
	+ proof (rule lex_pm_strict_plus_left)
	+ fix y z
	+ assume "y \<in> keys w"
	+ also from that(2) have "\<dots> \<subseteq> X" by (rule PPsD)
	+ also have "\<dots> \<subseteq> {..<x}" by fact
	+ finally have "y < x" by simp
	+ assume "z \<in> keys u"
	+ also from that(3) have "\<dots> \<subseteq> {x}" by (rule PPsD)
	+ finally show "y < z" using \<open>y < x\<close> by simp
	+ qed
	+ let ?h = "focus X h"
	+ from that(2) have "?h \<in> G'" by (simp add: G'_def)
	+ with \<open>G' \<subseteq> P[X]\<close> have "?h \<in> P[X]" ..
	+ hence "i.lpp ?h \<in> .[X]" by (rule i.PPs_closed_lpp)
	+ from that(1) obtain t1 t2 where "t1 \<in> keys d"
	+ and "t2 \<in> keys (punit.monom_mult 1 (l - i.lpp ?h) (flatten (i.punit.tail ?h)))"
	+ and t: "t = t1 + t2" by (rule in_keys_timesE)
	+ from this(2) obtain t3 where "t3 \<in> keys (flatten (i.punit.tail ?h))"
	+ and t2: "t2 = l - i.lpp ?h + t3" by (auto simp: punit.keys_monom_mult)
	+ from this(1) obtain t4 t5 where "t4 \<in> keys (i.punit.tail ?h)"
	+ and t5_in: "t5 \<in> keys (lookup (i.punit.tail ?h) t4)" and t3: "t3 = t4 + t5"
	+ using keys_flatten_subset by blast
	+ from this(1) have 1: "lex_pm_strict t4 (i.lpp ?h)" by (rule i.punit.keys_tail_less_lt)
	+ from that(2) have "lookup ?h t4 \<in> P[{x}]" by (rule lookup_focus_in)
	+ hence "keys (lookup ?h t4) \<subseteq> .[{x}]" by (rule PolysD)
	+ moreover from t5_in have t5_in: "t5 \<in> keys (lookup ?h t4)"
	+ by (simp add: i.punit.lookup_tail split: if_split_asm)
	+ ultimately have "t5 \<in> .[{x}]" ..
	+ with 1 \<open>i.lpp ?h \<in> _\<close> have "lex_pm_strict (t5 + t4) (i.lpp ?h)" by (rule 0)
	+ hence "lex_pm_strict t3 (i.lpp ?h)" by (simp only: t3 add.commute)
	+ hence "lex_pm_strict t2 (l - i.lpp ?h + i.lpp ?h)" unfolding t2
	+ by (rule i.plus_monotone_strict_left)
	+ moreover from \<open>l \<in> .[X]\<close> \<open>i.lpp ?h \<in> .[X]\<close> have "l - i.lpp ?h + i.lpp ?h \<in> .[X]"
	+ by (intro PPs_closed_plus PPs_closed_minus)
	+ moreover from \<open>t1 \<in> keys d\<close> that(3) have "t1 \<in> .[{x}]" by (auto dest: PolysD)
	+ ultimately show ?thesis unfolding t by (rule 0)
	+ qed
	+ show "lookup s t = 0"
	+ proof (rule ccontr)
	+ assume "lookup s t \<noteq> 0"
	+ hence "t \<in> keys s" by (simp add: in_keys_iff)
	+ also have "\<dots> = keys (?a - ?b)" by (simp add: s_def a b)
	+ also have "\<dots> \<subseteq> keys ?a \<union> keys ?b" by (fact keys_minus)
	+ finally show False
	+ proof
	+ assume "t \<in> keys ?a"
	+ hence "lex_pm_strict t (l - i.lpp (focus X g1') + i.lpp (focus X g1'))"
	+ using \<open>g1' \<in> G\<close> \<open>c2 \<in> P[{x}]\<close> by (rule lex_pm_strict_t)
	+ with \<open>g1' \<in> P[_]\<close> have "lex_pm_strict t l"
	+ by (simp add: lpp_focus l_def minus_plus adds_lcs)
	+ with \<open>lex_pm l t\<close> show ?thesis by simp
	+ next
	+ assume "t \<in> keys ?b"
	+ hence "lex_pm_strict t (l - i.lpp (focus X g2') + i.lpp (focus X g2'))"
	+ using \<open>g2' \<in> G\<close> \<open>c1 \<in> P[{x}]\<close> by (rule lex_pm_strict_t)
	+ with \<open>g2' \<in> P[_]\<close> have "lex_pm_strict t l"
	+ by (simp add: lpp_focus l_def minus_plus adds_lcs_2)
	+ with \<open>lex_pm l t\<close> show ?thesis by simp
	+ qed
	+ qed
	+ qed
	+ also have "\<dots> = lcs (i.lpp g1) (i.lpp g2)" by (simp only: l_def lpp1 lpp2)
	+ finally show "lex_pm_strict (i.lpp (q g * g)) (lcs (i.lpp g1) (i.lpp g2))" .
	+ qed
	+ qed
	+ have "1 \<in> ideal (?e ` focus {x} ` F) \<longleftrightarrow> 1 \<in> ideal (?e ` focus {x} ` F) \<inter> P[- {x}]"
	+ by (simp add: one_in_Polys)
	+ also have "\<dots> \<longleftrightarrow> 1 \<in> ideal G3" by (simp add: one_in_Polys flip: eq3)
	+ also have "\<not> \<dots>"
	+ proof
	+ note G3_isGB
	+ moreover assume "1 \<in> ideal G3"
	+ moreover have "1 \<noteq> (0::_ \<Rightarrow>\<^sub>0 'a)" by simp
	+ ultimately obtain g where "g \<in> G3" and "g \<noteq> 0" and "i.lpp g adds i.lpp (1::_ \<Rightarrow>\<^sub>0 'a)"
	+ by (rule i.punit.GB_adds_lt[simplified])
	+ from this(3) have "i.lpp g = 0" by (simp add: i.punit.lt_monomial adds_zero flip: single_one)
	+ hence "monomial (i.lcf g) 0 = g" by (rule i.punit.lt_eq_min_term_monomial[simplified])
	+ from \<open>g \<in> G3\<close> obtain g' where "g' \<in> G" and g: "g = ?e (focus {x} g')" by (auto simp: G3_def)
	+ from this(1) have "i.lpp g = except (i.lpp g') {x}" unfolding g by (rule lpp_e_focus)
	+ hence "keys (i.lpp g') \<subseteq> {x}" by (simp add: \<open>i.lpp g = 0\<close> except_eq_zero_iff)
	+ have "g' \<in> P[{x}]"
	+ proof (intro PolysI subsetI PPsI)
	+ fix t y
	+ assume "t \<in> keys g'"
	+ hence "lex_pm t (i.lpp g')" by (rule i.punit.lt_max_keys)
	+ moreover assume "y \<in> keys t"
	+ ultimately obtain z where "z \<in> keys (i.lpp g')" and "z \<le> y" by (rule lex_pm_keys_leE)
	+ with \<open>keys (i.lpp g') \<subseteq> {x}\<close> have "x \<le> y" by blast
	+ from \<open>g' \<in> G\<close> G_sub have "g' \<in> P[insert x X]" ..
	+ hence "indets g' \<subseteq> insert x X" by (rule PolysD)
	+ moreover from \<open>y \<in> _\<close> \<open>t \<in> _\<close> have "y \<in> indets g'" by (rule in_indetsI)
	+ ultimately have "y \<in> insert x X" ..
	+ thus "y \<in> {x}"
	+ proof
	+ assume "y \<in> X"
	+ with assms(3) have "y \<in> {..<x}" ..
	+ with \<open>x \<le> y\<close> show ?thesis by simp
	+ qed simp
	+ qed
	+ moreover from \<open>g' \<in> G\<close> have "g' \<in> ideal G" by (rule ideal.span_base)
	+ ultimately have "g' \<in> ideal F \<inter> P[{x}]" by (simp add: ideal_G)
	+ with assms(5) have "g' = 0" by blast
	+ hence "g = 0" by (simp add: g)
	+ with \<open>g \<noteq> 0\<close> show False ..
	+ qed
	+ finally show "1 \<notin> ideal (?e ` focus {x} ` F)" .
	+ qed
	+qed
	+
	+lemma weak_Nullstellensatz_aux_3:
	+ assumes "F \<subseteq> P[insert x X]" and "x \<notin> X" and "1 \<notin> ideal F" and "\<not> ideal F \<inter> P[{x}] \<subseteq> {0}"
	+ obtains a::"'a::alg_closed_field" where "1 \<notin> ideal (poly_eval (\<lambda>_. monomial a 0) ` focus {x} ` F)"
	+proof -
	+ let ?x = "monomial 1 (Poly_Mapping.single x 1)"
	+ from assms(4) obtain f where "f \<in> ideal F" and "f \<in> P[{x}]" and "f \<noteq> 0" by blast
	+ define p where "p = poly_of_pm x f"
	+ from \<open>f \<in> P[{x}]\<close> \<open>f \<noteq> 0\<close> have "p \<noteq> 0"
	+ by (auto simp: p_def poly_of_pm_eq_zero_iff simp flip: keys_eq_empty dest!: PolysD(1))
	+ obtain c A m where A: "finite A" and p: "p = Polynomial.smult c (\<Prod>a\<in>A. [:- a, 1:] ^ m a)"
	+ and "\<And>x. m x = 0 \<longleftrightarrow> x \<notin> A" and "c = 0 \<longleftrightarrow> p = 0" and "\<And>z. poly p z = 0 \<longleftrightarrow> (c = 0 \<or> z \<in> A)"
	+ by (rule linear_factorsE) blast
	+ from this(4, 5) have "c \<noteq> 0" and "\<And>z. poly p z = 0 \<longleftrightarrow> z \<in> A" by (simp_all add: \<open>p \<noteq> 0\<close>)
	+ have "\<exists>a\<in>A. 1 \<notin> ideal (poly_eval (\<lambda>_. monomial a 0) ` focus {x} ` F)"
	+ proof (rule ccontr)
	+ assume asm: "\<not> (\<exists>a\<in>A. 1 \<notin> ideal (poly_eval (\<lambda>_. monomial a 0) ` focus {x} ` F))"
	+ obtain g h where "g a \<in> ideal F" and 1: "h a * (?x - monomial a 0) + g a = 1"
	+ if "a \<in> A" for a
	+ proof -
	+ define P where "P = (\<lambda>gh a. fst gh \<in> ideal F \<and> fst gh + snd gh * (?x - monomial a 0) = 1)"
	+ define gh where "gh = (\<lambda>a. SOME gh. P gh a)"
	+ show ?thesis
	+ proof
	+ fix a
	+ assume "a \<in> A"
	+ with asm have "1 \<in> ideal (poly_eval (\<lambda>_. monomial a 0) ` focus {x} ` F)" by blast
	+ hence "1 \<in> poly_eval (\<lambda>_. monomial a 0) ` focus {x} ` ideal F"
	+ by (simp add: image_poly_eval_focus_ideal one_in_Polys)
	+ then obtain g where "g \<in> ideal F" and "1 = poly_eval (\<lambda>_. monomial a 0) (focus {x} g)"
	+ unfolding image_image ..
	+ note this(2)
	+ also have "poly_eval (\<lambda>_. monomial a 0) (focus {x} g) = poly (poly_of_focus x g) (monomial a 0)"
	+ by (simp only: poly_poly_of_focus)
	+ also have "\<dots> = poly (poly_of_focus x g) (?x - (?x - monomial a 0))" by simp
	+ also obtain h where "\<dots> = poly (poly_of_focus x g) ?x - h * (?x - monomial a 0)"
	+ by (rule poly_minus_rightE)
	+ also have "\<dots> = g - h * (?x - monomial a 0)" by (simp only: poly_poly_of_focus_monomial)
	+ finally have "g - h * (?x - monomial a 0) = 1" by (rule sym)
	+ with \<open>g \<in> ideal F\<close> have "P (g, - h) a" by (simp add: P_def)
	+ hence "P (gh a) a" unfolding gh_def by (rule someI)
	+ thus "fst (gh a) \<in> ideal F" and "snd (gh a) * (?x - monomial a 0) + fst (gh a) = 1"
	+ by (simp_all only: P_def add.commute)
	+ qed
	+ qed
	+ from this(1) obtain g' where "g' \<in> ideal F"
	+ and 2: "(\<Prod>a\<in>A. (h a * (?x - monomial a 0) + g a) ^ m a) =
	+ (\<Prod>a\<in>A. (h a * (?x - monomial a 0)) ^ m a) + g'"
	+ by (rule weak_Nullstellensatz_aux_1)
	+ have "1 = (\<Prod>a\<in>A. (h a * (?x - monomial a 0) + g a) ^ m a)"
	+ by (rule sym) (intro prod.neutral ballI, simp only: 1 power_one)
	+ also have "\<dots> = (\<Prod>a\<in>A. h a ^ m a) * (\<Prod>a\<in>A. (?x - monomial a 0) ^ m a) + g'"
	+ by (simp only: 2 power_mult_distrib prod.distrib)
	+ also have "(\<Prod>a\<in>A. (?x - monomial a 0) ^ m a) = pm_of_poly x (\<Prod>a\<in>A. [:- a, 1:] ^ m a)"
	+ by (simp add: pm_of_poly_prod pm_of_poly_pCons single_uminus punit.monom_mult_monomial
	+ flip: single_one)
	+ also from \<open>c \<noteq> 0\<close> have "\<dots> = monomial (inverse c) 0 * pm_of_poly x p"
	+ by (simp add: p map_scale_assoc flip: map_scale_eq_times)
	+ also from \<open>f \<in> P[{x}]\<close> have "\<dots> = monomial (inverse c) 0 * f"
	+ by (simp only: \<open>p = poly_of_pm x f\<close> pm_of_poly_of_pm)
	+ finally have "1 = ((\<Prod>a\<in>A. h a ^ m a) * monomial (inverse c) 0) * f + g'"
	+ by (simp only: mult.assoc)
	+ also from \<open>f \<in> ideal F\<close> \<open>g' \<in> ideal F\<close> have "\<dots> \<in> ideal F" by (intro ideal.span_add ideal.span_scale)
	+ finally have "1 \<in> ideal F" .
	+ with assms(3) show False ..
	+ qed
	+ then obtain a where "1 \<notin> ideal (poly_eval (\<lambda>_. monomial a 0) ` focus {x} ` F)" ..
	+ thus ?thesis ..
	+qed
	+
	+theorem weak_Nullstellensatz:
	+ assumes "finite X" and "F \<subseteq> P[X]" and "\<V> F = ({}::('x::{countable,linorder} \<Rightarrow> 'a::alg_closed_field) set)"
	+ shows "ideal F = UNIV"
	+ unfolding ideal_eq_UNIV_iff_contains_one
	+proof (rule ccontr)
	+ assume "1 \<notin> ideal F"
	+ with assms(1, 2) obtain a where "1 \<notin> ideal (poly_eval a ` F)"
	+ proof (induct X arbitrary: F thesis rule: finite_linorder_induct)
	+ case empty
	+ have "F \<subseteq> {0}"
	+ proof
	+ fix f
	+ assume "f \<in> F"
	+ with empty.prems(2) have "f \<in> P[{}]" ..
	+ then obtain c where f: "f = monomial c 0" unfolding Polys_empty ..
	+ also have "c = 0"
	+ proof (rule ccontr)
	+ assume "c \<noteq> 0"
	+ from \<open>f \<in> F\<close> have "f \<in> ideal F" by (rule ideal.span_base)
	+ hence "monomial (inverse c) 0 * f \<in> ideal F" by (rule ideal.span_scale)
	+ with \<open>c \<noteq> 0\<close> have "1 \<in> ideal F" by (simp add: f times_monomial_monomial)
	+ with empty.prems(3) show False ..
	+ qed
	+ finally show "f \<in> {0}" by simp
	+ qed
	+ hence "poly_eval 0 ` F \<subseteq> {0}" by auto
	+ hence "ideal (poly_eval 0 ` F) = {0}" by simp
	+ hence "1 \<notin> ideal (poly_eval 0 ` F)" by (simp del: ideal_eq_zero_iff)
	+ thus ?case by (rule empty.prems)
	+ next
	+ case (insert x X)
	+ obtain a0 where "1 \<notin> ideal (poly_eval (\<lambda>_. monomial a0 0) ` focus {x} ` F)" (is "_ \<notin> ideal ?F")
	+ proof (cases "ideal F \<inter> P[{x}] \<subseteq> {0}")
	+ case True
	+ with insert.hyps(1) insert.prems(2) insert.hyps(2) insert.prems(3) obtain a0
	+ where "1 \<notin> ideal (poly_eval (\<lambda>_. monomial a0 0) ` focus {x} ` F)"
	+ by (rule weak_Nullstellensatz_aux_2)
	+ thus ?thesis ..
	+ next
	+ case False
	+ from insert.hyps(2) have "x \<notin> X" by blast
	+ with insert.prems(2) obtain a0 where "1 \<notin> ideal (poly_eval (\<lambda>_. monomial a0 0) ` focus {x} ` F)"
	+ using insert.prems(3) False by (rule weak_Nullstellensatz_aux_3)
	+ thus ?thesis ..
	+ qed
	+ moreover have "?F \<subseteq> P[X]"
	+ proof -
	+ {
	+ fix f
	+ assume "f \<in> F"
	+ with insert.prems(2) have "f \<in> P[insert x X]" ..
	+ hence "poly_eval (\<lambda>_. monomial a0 0) (focus {x} f) \<in> P[insert x X - {x}]"
	+ by (rule poly_eval_focus_in_Polys)
	+ also have "\<dots> \<subseteq> P[X]" by (rule Polys_mono) simp
	+ finally have "poly_eval (\<lambda>_. monomial a0 0) (focus {x} f) \<in> P[X]" .
	+ }
	+ thus ?thesis by blast
	+ qed
	+ ultimately obtain a1 where "1 \<notin> ideal (poly_eval a1 ` ?F)" using insert.hyps(3) by blast
	+ also have "poly_eval a1 ` ?F = poly_eval (a1(x := poly_eval a1 (monomial a0 0))) ` F"
	+ by (simp add: image_image poly_eval_poly_eval_focus fun_upd_def)
	+ finally show ?case by (rule insert.prems)
	+ qed
	+ hence "ideal (poly_eval a ` F) \<noteq> UNIV" by (simp add: ideal_eq_UNIV_iff_contains_one)
	+ hence "ideal (poly_eval a ` F) = {0}" using ideal_field_disj[of "poly_eval a ` F"] by blast
	+ hence "poly_eval a ` F \<subseteq> {0}" by simp
	+ hence "a \<in> \<V> F" by (rule variety_ofI_alt)
	+ thus False by (simp add: assms(3))
	+qed
	+
	+lemma radical_idealI:
	+ assumes "finite X" and "F \<subseteq> P[X]" and "f \<in> P[X]" and "x \<notin> X"
	+ and "\<V> (insert (1 - punit.monom_mult 1 (Poly_Mapping.single x 1) f) F) = {}"
	+ shows "(f::('x::{countable,linorder} \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::alg_closed_field) \<in> \<surd>ideal F"
	+proof (cases "f = 0")
	+ case True
	+ thus ?thesis by simp
	+next
	+ case False
	+ from assms(4) have "P[X] \<subseteq> P[- {x}]" by (auto simp: Polys_alt)
	+ with assms(3) have "f \<in> P[- {x}]" ..
	+ let ?x = "Poly_Mapping.single x 1"
	+ let ?f = "punit.monom_mult 1 ?x f"
	+ from assms(1) have "finite (insert x X)" by simp
	+ moreover have "insert (1 - ?f) F \<subseteq> P[insert x X]" unfolding insert_subset
	+ proof (intro conjI Polys_closed_minus one_in_Polys Polys_closed_monom_mult PPs_closed_single)
	+ have "P[X] \<subseteq> P[insert x X]" by (rule Polys_mono) blast
	+ with assms(2, 3) show "f \<in> P[insert x X]" and "F \<subseteq> P[insert x X]" by blast+
	+ qed simp
	+ ultimately have "ideal (insert (1 - ?f) F) = UNIV"
	+ using assms(5) by (rule weak_Nullstellensatz)
	+ hence "1 \<in> ideal (insert (1 - ?f) F)" by simp
	+ then obtain F' q where fin': "finite F'" and F'_sub: "F' \<subseteq> insert (1 - ?f) F"
	+ and eq: "1 = (\<Sum>f'\<in>F'. q f' * f')" by (rule ideal.spanE)
	+ show "f \<in> \<surd>ideal F"
	+ proof (cases "1 - ?f \<in> F'")
	+ case True
	+ define g where "g = (\<lambda>x::('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a. Fract x 1)"
	+ define F'' where "F'' = F' - {1 - ?f}"
	+ define q0 where "q0 = q (1 - ?f)"
	+ have g_0: "g 0 = 0" by (simp add: g_def fract_collapse)
	+ have g_1: "g 1 = 1" by (simp add: g_def fract_collapse)
	+ have g_plus: "g (a + b) = g a + g b" for a b by (simp add: g_def)
	+ have g_minus: "g (a - b) = g a - g b" for a b by (simp add: g_def)
	+ have g_times: "g (a * b) = g a * g b" for a b by (simp add: g_def)
	+ from fin' have fin'': "finite F''" by (simp add: F''_def)
	+ from F'_sub have F''_sub: "F'' \<subseteq> F" by (auto simp: F''_def)
	+
	+ have "focus {x} ?f = monomial 1 ?x * focus {x} f"
	+ by (simp add: focus_times focus_monomial except_single flip: times_monomial_left)
	+ also from \<open>f \<in> P[- {x}]\<close> have "focus {x} f = monomial f 0" by (rule focus_Polys_Compl)
	+ finally have "focus {x} ?f = monomial f ?x" by (simp add: times_monomial_monomial)
	+ hence eq1: "poly (map_poly g (poly_of_focus x (1 - ?f))) (Fract 1 f) = 0"
	+ by (simp add: poly_of_focus_def focus_minus poly_of_pm_minus poly_of_pm_monomial
	+ PPs_closed_single map_poly_minus g_0 g_1 g_minus map_poly_monom poly_monom)
	+ (simp add: g_def Fract_same \<open>f \<noteq> 0\<close>)
	+ have eq2: "poly (map_poly g (poly_of_focus x f')) (Fract 1 f) = Fract f' 1" if "f' \<in> F''" for f'
	+ proof -
	+ from that F''_sub have "f' \<in> F" ..
	+ with assms(2) have "f' \<in> P[X]" ..
	+ with \<open>P[X] \<subseteq> _\<close> have "f' \<in> P[- {x}]" ..
	+ hence "focus {x} f' = monomial f' 0" by (rule focus_Polys_Compl)
	+ thus ?thesis
	+ by (simp add: poly_of_focus_def focus_minus poly_of_pm_minus poly_of_pm_monomial
	+ zero_in_PPs map_poly_minus g_0 g_1 g_minus map_poly_monom poly_monom)
	+ (simp only: g_def)
	+ qed
	+
	+ define p0m0 where "p0m0 = (\<lambda>f'. SOME z. poly (map_poly g (poly_of_focus x (q f'))) (Fract 1 f) =
	+ Fract (fst z) (f ^ snd z))"
	+ define p0 where "p0 = fst \<circ> p0m0"
	+ define m0 where "m0 = snd \<circ> p0m0"
	+ define m where "m = Max (m0 ` F'')"
	+ have eq3: "poly (map_poly g (poly_of_focus x (q f'))) (Fract 1 f) = Fract (p0 f') (f ^ m0 f')"
	+ for f'
	+ proof -
	+ have "g a = 0 \<longleftrightarrow> a = 0" for a by (simp add: g_def Fract_eq_zero_iff)
	+ hence "set (Polynomial.coeffs (map_poly g (poly_of_focus x (q f')))) \<subseteq> range (\<lambda>x. Fract x 1)"
	+ by (auto simp: set_coeffs_map_poly g_def)
	+ then obtain p m' where "poly (map_poly g (poly_of_focus x (q f'))) (Fract 1 f) = Fract p (f ^ m')"
	+ by (rule poly_Fract)
	+ hence "poly (map_poly g (poly_of_focus x (q f'))) (Fract 1 f) = Fract (fst (p, m')) (f ^ snd (p, m'))"
	+ by simp
	+ thus ?thesis unfolding p0_def m0_def p0m0_def o_def by (rule someI)
	+ qed
	+
	+ note eq
	+ also from True fin' have "(\<Sum>f'\<in>F'. q f' * f') = q0 * (1 - ?f) + (\<Sum>f'\<in>F''. q f' * f')"
	+ by (simp add: q0_def F''_def sum.remove)
	+ finally have "poly_of_focus x 1 = poly_of_focus x (q0 * (1 - ?f) + (\<Sum>f'\<in>F''. q f' * f'))"
	+ by (rule arg_cong)
	+ hence "1 = poly (map_poly g (poly_of_focus x (q0 * (1 - ?f) + (\<Sum>f'\<in>F''. q f' * f')))) (Fract 1 f)"
	+ by (simp add: g_1)
	+ also have "\<dots> = poly (map_poly g (poly_of_focus x (\<Sum>f'\<in>F''. q f' * f'))) (Fract 1 f)"
	+ by (simp only: poly_of_focus_plus map_poly_plus g_0 g_plus g_times poly_add
	+ poly_of_focus_times map_poly_times poly_mult eq1 mult_zero_right add_0_left)
	+ also have "\<dots> = (\<Sum>f'\<in>F''. Fract (p0 f') (f ^ m0 f') * Fract f' 1)"
	+ by (simp only: poly_of_focus_sum poly_of_focus_times map_poly_sum map_poly_times
	+ g_0 g_plus g_times poly_sum poly_mult eq2 eq3 cong: sum.cong)
	+ finally have "Fract (f ^ m) 1 = Fract (f ^ m) 1 * (\<Sum>f'\<in>F''. Fract (p0 f' * f') (f ^ m0 f'))"
	+ by simp
	+ also have "\<dots> = (\<Sum>f'\<in>F''. Fract (f ^ m * (p0 f' * f')) (f ^ m0 f'))"
	+ by (simp add: sum_distrib_left)
	+ also from refl have "\<dots> = (\<Sum>f'\<in>F''. Fract ((f ^ (m - m0 f') * p0 f') * f') 1)"
	+ proof (rule sum.cong)
	+ fix f'
	+ assume "f' \<in> F''"
	+ hence "m0 f' \<in> m0 ` F''" by (rule imageI)
	+ with _ have "m0 f' \<le> m" unfolding m_def by (rule Max_ge) (simp add: fin'')
	+ hence "f ^ m = f ^ (m0 f') * f ^ (m - m0 f')" by (simp flip: power_add)
	+ hence "Fract (f ^ m * (p0 f' * f')) (f ^ m0 f') = Fract (f ^ m0 f') (f ^ m0 f') *
	+ Fract (f ^ (m - m0 f') * (p0 f' * f')) 1"
	+ by (simp add: ac_simps)
	+ also from \<open>f \<noteq> 0\<close> have "Fract (f ^ m0 f') (f ^ m0 f') = 1" by (simp add: Fract_same)
	+ finally show "Fract (f ^ m * (p0 f' * f')) (f ^ m0 f') = Fract (f ^ (m - m0 f') * p0 f' * f') 1"
	+ by (simp add: ac_simps)
	+ qed
	+ also from fin'' have "\<dots> = Fract (\<Sum>f'\<in>F''. (f ^ (m - m0 f') * p0 f') * f') 1"
	+ by (induct F'') (simp_all add: fract_collapse)
	+ finally have "f ^ m = (\<Sum>f'\<in>F''. (f ^ (m - m0 f') * p0 f') * f')"
	+ by (simp add: eq_fract)
	+ also have "\<dots> \<in> ideal F''" by (rule ideal.sum_in_spanI)
	+ also from \<open>F'' \<subseteq> F\<close> have "\<dots> \<subseteq> ideal F" by (rule ideal.span_mono)
	+ finally show "f \<in> \<surd>ideal F" by (rule radicalI)
	+ next
	+ case False
	+ with F'_sub have "F' \<subseteq> F" by blast
	+ have "1 \<in> ideal F'" unfolding eq by (rule ideal.sum_in_spanI)
	+ also from \<open>F' \<subseteq> F\<close> have "\<dots> \<subseteq> ideal F" by (rule ideal.span_mono)
	+ finally have "ideal F = UNIV" by (simp only: ideal_eq_UNIV_iff_contains_one)
	+ thus ?thesis by simp
	+ qed
	+qed
	+
	+corollary radical_idealI_extend_indets:
	+ assumes "finite X" and "F \<subseteq> P[X]"
	+ and "\<V> (insert (1 - punit.monom_mult 1 (Poly_Mapping.single None 1) (extend_indets f))
	+ (extend_indets ` F)) = {}"
	+ shows "(f::(_::{countable,linorder} \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 _::alg_closed_field) \<in> \<surd>ideal F"
	+proof -
	+ define Y where "Y = X \<union> indets f"
	+ from assms(1) have fin_Y: "finite Y" by (simp add: Y_def finite_indets)
	+ have "P[X] \<subseteq> P[Y]" by (rule Polys_mono) (simp add: Y_def)
	+ with assms(2) have F_sub: "F \<subseteq> P[Y]" by (rule subset_trans)
	+ have f_in: "f \<in> P[Y]" by (simp add: Y_def Polys_alt)
	+
	+ let ?F = "extend_indets ` F"
	+ let ?f = "extend_indets f"
	+ let ?X = "Some ` Y"
	+ from fin_Y have "finite ?X" by (rule finite_imageI)
	+ moreover from F_sub have "?F \<subseteq> P[?X]"
	+ by (auto simp: indets_extend_indets intro!: PolysI_alt imageI dest!: PolysD(2) subsetD[of F])
	+ moreover from f_in have "?f \<in> P[?X]"
	+ by (auto simp: indets_extend_indets intro!: PolysI_alt imageI dest!: PolysD(2))
	+ moreover have "None \<notin> ?X" by simp
	+ ultimately have "?f \<in> \<surd>ideal ?F" using assms(3) by (rule radical_idealI)
	+ also have "?f \<in> \<surd>ideal ?F \<longleftrightarrow> f \<in> \<surd>ideal F"
	+ proof
	+ assume "f \<in> \<surd>ideal F"
	+ then obtain m where "f ^ m \<in> ideal F" by (rule radicalE)
	+ hence "extend_indets (f ^ m) \<in> extend_indets ` ideal F" by (rule imageI)
	+ with extend_indets_ideal_subset have "?f ^ m \<in> ideal ?F" unfolding extend_indets_power ..
	+ thus "?f \<in> \<surd>ideal ?F" by (rule radicalI)
	+ next
	+ assume "?f \<in> \<surd>ideal ?F"
	+ then obtain m where "?f ^ m \<in> ideal ?F" by (rule radicalE)
	+ moreover have "?f ^ m \<in> P[- {None}]"
	+ by (rule Polys_closed_power) (auto intro!: PolysI_alt simp: indets_extend_indets)
	+ ultimately have "extend_indets (f ^ m) \<in> extend_indets ` ideal F"
	+ by (simp add: extend_indets_ideal extend_indets_power)
	+ hence "f ^ m \<in> ideal F" by (simp only: inj_image_mem_iff[OF inj_extend_indets])
	+ thus "f \<in> \<surd>ideal F" by (rule radicalI)
	+ qed
	+ finally show ?thesis .
	+qed
	+
	+theorem Nullstellensatz:
	+ assumes "finite X" and "F \<subseteq> P[X]"
	+ and "(f::(_::{countable,linorder} \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 _::alg_closed_field) \<in> \<I> (\<V> F)"
	+ shows "f \<in> \<surd>ideal F"
	+ using assms(1, 2)
	+proof (rule radical_idealI_extend_indets)
	+ let ?f = "punit.monom_mult 1 (monomial 1 None) (extend_indets f)"
	+ show "\<V> (insert (1 - ?f) (extend_indets ` F)) = {}"
	+ proof (intro subset_antisym subsetI)
	+ fix a
	+ assume "a \<in> \<V> (insert (1 - ?f) (extend_indets ` F))"
	+ moreover have "1 - ?f \<in> insert (1 - ?f) (extend_indets ` F)" by simp
	+ ultimately have "poly_eval a (1 - ?f) = 0" by (rule variety_ofD)
	+ hence "poly_eval a (extend_indets f) \<noteq> 0"
	+ by (auto simp: poly_eval_minus poly_eval_times simp flip: times_monomial_left)
	+ hence "poly_eval (a \<circ> Some) f \<noteq> 0" by (simp add: poly_eval_extend_indets)
	+ have "a \<circ> Some \<in> \<V> F"
	+ proof (rule variety_ofI)
	+ fix f'
	+ assume "f' \<in> F"
	+ hence "extend_indets f' \<in> insert (1 - ?f) (extend_indets ` F)" by simp
	+ with \<open>a \<in> _\<close> have "poly_eval a (extend_indets f') = 0" by (rule variety_ofD)
	+ thus "poly_eval (a \<circ> Some) f' = 0" by (simp only: poly_eval_extend_indets)
	+ qed
	+ with assms(3) have "poly_eval (a \<circ> Some) f = 0" by (rule ideal_ofD)
	+ with \<open>poly_eval (a \<circ> Some) f \<noteq> 0\<close> show "a \<in> {}" ..
	+ qed simp
	+qed
	+
	+theorem strong_Nullstellensatz:
	+ assumes "finite X" and "F \<subseteq> P[X]"
	+ shows "\<I> (\<V> F) = \<surd>ideal (F::((_::{countable,linorder} \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 _::alg_closed_field) set)"
	+proof (intro subset_antisym subsetI)
	+ fix f
	+ assume "f \<in> \<I> (\<V> F)"
	+ with assms show "f \<in> \<surd>ideal F" by (rule Nullstellensatz)
	+qed (metis ideal_ofI variety_ofD variety_of_radical_ideal)
	+
	+text \<open>The following lemma can be used for actually \<^emph>\<open>deciding\<close> whether a polynomial is contained in
	+ the radical of an ideal or not.\<close>
	+
	+lemma radical_ideal_iff:
	+ assumes "finite X" and "F \<subseteq> P[X]" and "f \<in> P[X]" and "x \<notin> X"
	+ shows "(f::(_::{countable,linorder} \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 _::alg_closed_field) \<in> \<surd>ideal F \<longleftrightarrow>
	+ 1 \<in> ideal (insert (1 - punit.monom_mult 1 (Poly_Mapping.single x 1) f) F)"
	+proof -
	+ let ?f = "punit.monom_mult 1 (Poly_Mapping.single x 1) f"
	+ show ?thesis
	+ proof
	+ assume "f \<in> \<surd>ideal F"
	+ then obtain m where "f ^ m \<in> ideal F" by (rule radicalE)
	+ from assms(1) have "finite (insert x X)" by simp
	+ moreover have "insert (1 - ?f) F \<subseteq> P[insert x X]" unfolding insert_subset
	+ proof (intro conjI Polys_closed_minus one_in_Polys Polys_closed_monom_mult PPs_closed_single)
	+ have "P[X] \<subseteq> P[insert x X]" by (rule Polys_mono) blast
	+ with assms(2, 3) show "f \<in> P[insert x X]" and "F \<subseteq> P[insert x X]" by blast+
	+ qed simp
	+ moreover have "\<V> (insert (1 - ?f) F) = {}"
	+ proof (intro subset_antisym subsetI)
	+ fix a
	+ assume "a \<in> \<V> (insert (1 - ?f) F)"
	+ moreover have "1 - ?f \<in> insert (1 - ?f) F" by simp
	+ ultimately have "poly_eval a (1 - ?f) = 0" by (rule variety_ofD)
	+ hence "poly_eval a (f ^ m) \<noteq> 0"
	+ by (auto simp: poly_eval_minus poly_eval_times poly_eval_power simp flip: times_monomial_left)
	+ from \<open>a \<in> _\<close> have "a \<in> \<V> (ideal (insert (1 - ?f) F))" by (simp only: variety_of_ideal)
	+ moreover from \<open>f ^ m \<in> ideal F\<close> ideal.span_mono have "f ^ m \<in> ideal (insert (1 - ?f) F)"
	+ by (rule rev_subsetD) blast
	+ ultimately have "poly_eval a (f ^ m) = 0" by (rule variety_ofD)
	+ with \<open>poly_eval a (f ^ m) \<noteq> 0\<close> show "a \<in> {}" ..
	+ qed simp
	+ ultimately have "ideal (insert (1 - ?f) F) = UNIV" by (rule weak_Nullstellensatz)
	+ thus "1 \<in> ideal (insert (1 - ?f) F)" by simp
	+ next
	+ assume "1 \<in> ideal (insert (1 - ?f) F)"
	+ have "\<V> (insert (1 - ?f) F) = {}"
	+ proof (intro subset_antisym subsetI)
	+ fix a
	+ assume "a \<in> \<V> (insert (1 - ?f) F)"
	+ hence "a \<in> \<V> (ideal (insert (1 - ?f) F))" by (simp only: variety_of_ideal)
	+ hence "poly_eval a 1 = 0" using \<open>1 \<in> _\<close> by (rule variety_ofD)
	+ thus "a \<in> {}" by simp
	+ qed simp
	+ with assms show "f \<in> \<surd>ideal F" by (rule radical_idealI)
	+ qed
	+qed
	+
	+end (* theory *)
	diff --git a/thys/Nullstellensatz/Nullstellensatz_Field.thy b/thys/Nullstellensatz/Nullstellensatz_Field.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Nullstellensatz/Nullstellensatz_Field.thy
	@@ -0,0 +1,613 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Field-Theoretic Version of Hilbert's Nullstellensatz\<close>
	+
	+theory Nullstellensatz_Field
	+ imports Nullstellensatz "HOL-Types_To_Sets.Types_To_Sets"
	+begin
	+
	+text \<open>Building upon the geometric version of Hilbert's Nullstellensatz in
	+ @{theory Nullstellensatz.Nullstellensatz}, we prove its field-theoretic version here. To that end we employ
	+ the `types to sets' methodology.\<close>
	+
	+subsection \<open>Getting Rid of Sort Constraints in Geometric Version\<close>
	+
	+text \<open>We can use the `types to sets' approach to get rid of the @{class countable} and @{class linorder}
	+ sort constraints on the type of indeterminates in the geometric version of the Nullstellensatz.
	+ Once the `types to sets' methodology is integrated as a standard component into the main library of
	+ Isabelle, the theorems in @{theory Nullstellensatz.Nullstellensatz} could be replaced by their counterparts
	+ in this section.\<close>
	+
	+lemmas radical_idealI_internalized = radical_idealI[unoverload_type 'x]
	+
	+lemma radical_idealI:
	+ assumes "finite X" and "F \<subseteq> P[X]" and "f \<in> P[X]" and "x \<notin> X"
	+ and "\<V> (insert (1 - punit.monom_mult 1 (Poly_Mapping.single x 1) f) F) = {}"
	+ shows "(f::('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::alg_closed_field) \<in> \<surd>ideal F"
	+proof -
	+ define Y where "Y = insert x X"
	+ from assms(1) have fin_Y: "finite Y" by (simp add: Y_def)
	+ have "X \<subseteq> Y" by (auto simp: Y_def)
	+ hence "P[X] \<subseteq> P[Y]" by (rule Polys_mono)
	+ with assms(2, 3) have F_sub: "F \<subseteq> P[Y]" and "f \<in> P[Y]" by auto
	+ {
	+ text \<open>We define the type @{typ 'y} to be isomorphic to @{term Y}.\<close>
	+ assume "\<exists>(Rep :: 'y \<Rightarrow> 'x) Abs. type_definition Rep Abs Y"
	+ then obtain rep :: "'y \<Rightarrow> 'x" and abs :: "'x \<Rightarrow> 'y" where t: "type_definition rep abs Y"
	+ by blast
	+ then interpret y: type_definition rep abs Y .
	+
	+ from well_ordering obtain le_y'::"('y \<times> 'y) set" where fld: "Field le_y' = UNIV"
	+ and wo: "Well_order le_y'" by meson
	+ define le_y where "le_y = (\<lambda>a b::'y. (a, b) \<in> le_y')"
	+
	+ from \<open>f \<in> P[Y]\<close> have 0: "map_indets rep (map_indets abs f) = f" unfolding map_indets_map_indets
	+ by (intro map_indets_id) (auto intro!: y.Abs_inverse dest: PolysD)
	+ have 1: "map_indets (rep \<circ> abs) ` F = F"
	+ proof
	+ from F_sub show "map_indets (rep \<circ> abs) ` F \<subseteq> F"
	+ by (smt PolysD(2) comp_apply image_subset_iff map_indets_id subsetD y.Abs_inverse)
	+ next
	+ from F_sub show "F \<subseteq> map_indets (rep \<circ> abs) ` F"
	+ by (smt PolysD(2) comp_apply image_eqI map_indets_id subsetD subsetI y.Abs_inverse)
	+ qed
	+ have 2: "inj rep" by (meson inj_onI y.Rep_inject)
	+ hence 3: "inj (map_indets rep)" by (rule map_indets_injI)
	+ from fin_Y have 4: "finite (abs ` Y)" by (rule finite_imageI)
	+ from wo have le_y_refl: "le_y x x" for x
	+ by (simp add: le_y_def well_order_on_def linear_order_on_def partial_order_on_def
	+ preorder_on_def refl_on_def fld)
	+ have le_y_total: "le_y x y \<or> le_y y x" for x y
	+ proof (cases "x = y")
	+ case True
	+ thus ?thesis by (simp add: le_y_refl)
	+ next
	+ case False
	+ with wo show ?thesis
	+ by (simp add: le_y_def well_order_on_def linear_order_on_def total_on_def
	+ Relation.total_on_def fld)
	+ qed
	+
	+ from 4 finite_imp_inj_to_nat_seg y.Abs_image have "class.countable TYPE('y)"
	+ by unfold_locales fastforce
	+ moreover have "class.linorder le_y (strict le_y)"
	+ apply standard
	+ subgoal by (fact refl)
	+ subgoal by (fact le_y_refl)
	+ subgoal using wo
	+ by (auto simp: le_y_def well_order_on_def linear_order_on_def partial_order_on_def
	+ preorder_on_def fld dest: transD)
	+ subgoal using wo
	+ by (simp add: le_y_def well_order_on_def linear_order_on_def partial_order_on_def
	+ preorder_on_def antisym_def fld)
	+ subgoal by (fact le_y_total)
	+ done
	+ moreover from assms(1) have "finite (abs ` X)" by (rule finite_imageI)
	+ moreover have "map_indets abs ` F \<subseteq> P[abs ` X]"
	+ proof (rule subset_trans)
	+ from assms(2) show "map_indets abs ` F \<subseteq> map_indets abs ` P[X]" by (rule image_mono)
	+ qed (simp only: image_map_indets_Polys)
	+ moreover have "map_indets abs f \<in> P[abs ` X]"
	+ proof
	+ from assms(3) show "map_indets abs f \<in> map_indets abs ` P[X]" by (rule imageI)
	+ qed (simp only: image_map_indets_Polys)
	+ moreover from assms(4) y.Abs_inject have "abs x \<notin> abs ` X" unfolding Y_def by blast
	+ moreover have "\<V> (insert (1 - punit.monom_mult 1 (Poly_Mapping.single (abs x) (Suc 0))
	+ (map_indets abs f)) (map_indets abs ` F)) = {}"
	+ proof (intro set_eqI iffI)
	+ fix a
	+ assume "a \<in> \<V> (insert (1 - punit.monom_mult 1 (Poly_Mapping.single (abs x) (Suc 0))
	+ (map_indets abs f)) (map_indets abs ` F))"
	+ also have "\<dots> = (\<lambda>b. b \<circ> abs) -` \<V> (insert (1 - punit.monom_mult 1 (Poly_Mapping.single x 1) f) F)"
	+ by (simp add: map_indets_minus map_indets_times map_indets_monomial
	+ flip: variety_of_map_indets times_monomial_left)
	+ finally show "a \<in> {}" by (simp only: assms(5) vimage_empty)
	+ qed simp
	+ ultimately have "map_indets abs f \<in> \<surd>ideal (map_indets abs ` F)"
	+ by (rule radical_idealI_internalized[where 'x='y, untransferred, simplified])
	+ hence "map_indets rep (map_indets abs f) \<in> map_indets rep ` \<surd>ideal (map_indets abs ` F)"
	+ by (rule imageI)
	+ also from 2 have "\<dots> = \<surd>(ideal F \<inter> P[Y]) \<inter> P[Y]"
	+ by (simp add: image_map_indets_ideal image_map_indets_radical image_image map_indets_map_indets
	+ 1 y.Rep_range)
	+ also have "\<dots> \<subseteq> \<surd>ideal F" using radical_mono by blast
	+ finally have ?thesis by (simp only: 0)
	+ }
	+ note rl = this[cancel_type_definition]
	+ have "Y \<noteq> {}" by (simp add: Y_def)
	+ thus ?thesis by (rule rl)
	+qed
	+
	+corollary radical_idealI_extend_indets:
	+ assumes "finite X" and "F \<subseteq> P[X]"
	+ and "\<V> (insert (1 - punit.monom_mult 1 (Poly_Mapping.single None 1) (extend_indets f))
	+ (extend_indets ` F)) = {}"
	+ shows "(f::_ \<Rightarrow>\<^sub>0 _::alg_closed_field) \<in> \<surd>ideal F"
	+proof -
	+ define Y where "Y = X \<union> indets f"
	+ from assms(1) have fin_Y: "finite Y" by (simp add: Y_def finite_indets)
	+ have "P[X] \<subseteq> P[Y]" by (rule Polys_mono) (simp add: Y_def)
	+ with assms(2) have F_sub: "F \<subseteq> P[Y]" by (rule subset_trans)
	+ have f_in: "f \<in> P[Y]" by (simp add: Y_def Polys_alt)
	+
	+ let ?F = "extend_indets ` F"
	+ let ?f = "extend_indets f"
	+ let ?X = "Some ` Y"
	+ from fin_Y have "finite ?X" by (rule finite_imageI)
	+ moreover from F_sub have "?F \<subseteq> P[?X]"
	+ by (auto simp: indets_extend_indets intro!: PolysI_alt imageI dest!: PolysD(2) subsetD[of F])
	+ moreover from f_in have "?f \<in> P[?X]"
	+ by (auto simp: indets_extend_indets intro!: PolysI_alt imageI dest!: PolysD(2))
	+ moreover have "None \<notin> ?X" by simp
	+ ultimately have "?f \<in> \<surd>ideal ?F" using assms(3) by (rule radical_idealI)
	+ also have "?f \<in> \<surd>ideal ?F \<longleftrightarrow> f \<in> \<surd>ideal F"
	+ proof
	+ assume "f \<in> \<surd>ideal F"
	+ then obtain m where "f ^ m \<in> ideal F" by (rule radicalE)
	+ hence "extend_indets (f ^ m) \<in> extend_indets ` ideal F" by (rule imageI)
	+ with extend_indets_ideal_subset have "?f ^ m \<in> ideal ?F" unfolding extend_indets_power ..
	+ thus "?f \<in> \<surd>ideal ?F" by (rule radicalI)
	+ next
	+ assume "?f \<in> \<surd>ideal ?F"
	+ then obtain m where "?f ^ m \<in> ideal ?F" by (rule radicalE)
	+ moreover have "?f ^ m \<in> P[- {None}]"
	+ by (rule Polys_closed_power) (auto intro!: PolysI_alt simp: indets_extend_indets)
	+ ultimately have "extend_indets (f ^ m) \<in> extend_indets ` ideal F"
	+ by (simp add: extend_indets_ideal extend_indets_power)
	+ hence "f ^ m \<in> ideal F" by (simp only: inj_image_mem_iff[OF inj_extend_indets])
	+ thus "f \<in> \<surd>ideal F" by (rule radicalI)
	+ qed
	+ finally show ?thesis .
	+qed
	+
	+theorem Nullstellensatz:
	+ assumes "finite X" and "F \<subseteq> P[X]"
	+ and "(f::_ \<Rightarrow>\<^sub>0 _::alg_closed_field) \<in> \<I> (\<V> F)"
	+ shows "f \<in> \<surd>ideal F"
	+ using assms(1, 2)
	+proof (rule radical_idealI_extend_indets)
	+ let ?f = "punit.monom_mult 1 (monomial 1 None) (extend_indets f)"
	+ show "\<V> (insert (1 - ?f) (extend_indets ` F)) = {}"
	+ proof (intro subset_antisym subsetI)
	+ fix a
	+ assume "a \<in> \<V> (insert (1 - ?f) (extend_indets ` F))"
	+ moreover have "1 - ?f \<in> insert (1 - ?f) (extend_indets ` F)" by simp
	+ ultimately have "poly_eval a (1 - ?f) = 0" by (rule variety_ofD)
	+ hence "poly_eval a (extend_indets f) \<noteq> 0"
	+ by (auto simp: poly_eval_minus poly_eval_times simp flip: times_monomial_left)
	+ hence "poly_eval (a \<circ> Some) f \<noteq> 0" by (simp add: poly_eval_extend_indets)
	+ have "a \<circ> Some \<in> \<V> F"
	+ proof (rule variety_ofI)
	+ fix f'
	+ assume "f' \<in> F"
	+ hence "extend_indets f' \<in> insert (1 - ?f) (extend_indets ` F)" by simp
	+ with \<open>a \<in> _\<close> have "poly_eval a (extend_indets f') = 0" by (rule variety_ofD)
	+ thus "poly_eval (a \<circ> Some) f' = 0" by (simp only: poly_eval_extend_indets)
	+ qed
	+ with assms(3) have "poly_eval (a \<circ> Some) f = 0" by (rule ideal_ofD)
	+ with \<open>poly_eval (a \<circ> Some) f \<noteq> 0\<close> show "a \<in> {}" ..
	+ qed simp
	+qed
	+
	+theorem strong_Nullstellensatz:
	+ assumes "finite X" and "F \<subseteq> P[X]"
	+ shows "\<I> (\<V> F) = \<surd>ideal (F::(_ \<Rightarrow>\<^sub>0 _::alg_closed_field) set)"
	+proof (intro subset_antisym subsetI)
	+ fix f
	+ assume "f \<in> \<I> (\<V> F)"
	+ with assms show "f \<in> \<surd>ideal F" by (rule Nullstellensatz)
	+qed (metis ideal_ofI variety_ofD variety_of_radical_ideal)
	+
	+theorem weak_Nullstellensatz:
	+ assumes "finite X" and "F \<subseteq> P[X]" and "\<V> F = ({}::(_ \<Rightarrow> _::alg_closed_field) set)"
	+ shows "ideal F = UNIV"
	+proof -
	+ from assms(1, 2) have "\<I> (\<V> F) = \<surd>ideal F" by (rule strong_Nullstellensatz)
	+ thus ?thesis by (simp add: assms(3) flip: radical_ideal_eq_UNIV_iff)
	+qed
	+
	+lemma radical_ideal_iff:
	+ assumes "finite X" and "F \<subseteq> P[X]" and "f \<in> P[X]" and "x \<notin> X"
	+ shows "(f::_ \<Rightarrow>\<^sub>0 _::alg_closed_field) \<in> \<surd>ideal F \<longleftrightarrow>
	+ 1 \<in> ideal (insert (1 - punit.monom_mult 1 (Poly_Mapping.single x 1) f) F)"
	+proof -
	+ let ?f = "punit.monom_mult 1 (Poly_Mapping.single x 1) f"
	+ show ?thesis
	+ proof
	+ assume "f \<in> \<surd>ideal F"
	+ then obtain m where "f ^ m \<in> ideal F" by (rule radicalE)
	+ from assms(1) have "finite (insert x X)" by simp
	+ moreover have "insert (1 - ?f) F \<subseteq> P[insert x X]" unfolding insert_subset
	+ proof (intro conjI Polys_closed_minus one_in_Polys Polys_closed_monom_mult PPs_closed_single)
	+ have "P[X] \<subseteq> P[insert x X]" by (rule Polys_mono) blast
	+ with assms(2, 3) show "f \<in> P[insert x X]" and "F \<subseteq> P[insert x X]" by blast+
	+ qed simp
	+ moreover have "\<V> (insert (1 - ?f) F) = {}"
	+ proof (intro subset_antisym subsetI)
	+ fix a
	+ assume "a \<in> \<V> (insert (1 - ?f) F)"
	+ moreover have "1 - ?f \<in> insert (1 - ?f) F" by simp
	+ ultimately have "poly_eval a (1 - ?f) = 0" by (rule variety_ofD)
	+ hence "poly_eval a (f ^ m) \<noteq> 0"
	+ by (auto simp: poly_eval_minus poly_eval_times poly_eval_power simp flip: times_monomial_left)
	+ from \<open>a \<in> _\<close> have "a \<in> \<V> (ideal (insert (1 - ?f) F))" by (simp only: variety_of_ideal)
	+ moreover from \<open>f ^ m \<in> ideal F\<close> ideal.span_mono have "f ^ m \<in> ideal (insert (1 - ?f) F)"
	+ by (rule rev_subsetD) blast
	+ ultimately have "poly_eval a (f ^ m) = 0" by (rule variety_ofD)
	+ with \<open>poly_eval a (f ^ m) \<noteq> 0\<close> show "a \<in> {}" ..
	+ qed simp
	+ ultimately have "ideal (insert (1 - ?f) F) = UNIV" by (rule weak_Nullstellensatz)
	+ thus "1 \<in> ideal (insert (1 - ?f) F)" by simp
	+ next
	+ assume "1 \<in> ideal (insert (1 - ?f) F)"
	+ have "\<V> (insert (1 - ?f) F) = {}"
	+ proof (intro subset_antisym subsetI)
	+ fix a
	+ assume "a \<in> \<V> (insert (1 - ?f) F)"
	+ hence "a \<in> \<V> (ideal (insert (1 - ?f) F))" by (simp only: variety_of_ideal)
	+ hence "poly_eval a 1 = 0" using \<open>1 \<in> _\<close> by (rule variety_ofD)
	+ thus "a \<in> {}" by simp
	+ qed simp
	+ with assms show "f \<in> \<surd>ideal F" by (rule radical_idealI)
	+ qed
	+qed
	+
	+subsection \<open>Field-Theoretic Version of the Nullstellensatz\<close>
	+
	+text \<open>Due to the possibility of infinite indeterminate-types, we have to explicitly add the set of
	+ indeterminates under consideration to the definition of maximal ideals.\<close>
	+
	+definition generates_max_ideal :: "'x set \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::comm_ring_1) set \<Rightarrow> bool"
	+ where "generates_max_ideal X F \<longleftrightarrow> (ideal F \<noteq> UNIV \<and>
	+ (\<forall>F'. F' \<subseteq> P[X] \<longrightarrow> ideal F \<subset> ideal F' \<longrightarrow> ideal F' = UNIV))"
	+
	+lemma generates_max_idealI:
	+ assumes "ideal F \<noteq> UNIV" and "\<And>F'. F' \<subseteq> P[X] \<Longrightarrow> ideal F \<subset> ideal F' \<Longrightarrow> ideal F' = UNIV"
	+ shows "generates_max_ideal X F"
	+ using assms by (simp add: generates_max_ideal_def)
	+
	+lemma generates_max_idealI_alt:
	+ assumes "ideal F \<noteq> UNIV" and "\<And>p. p \<in> P[X] \<Longrightarrow> p \<notin> ideal F \<Longrightarrow> 1 \<in> ideal (insert p F)"
	+ shows "generates_max_ideal X F"
	+ using assms(1)
	+proof (rule generates_max_idealI)
	+ fix F'
	+ assume "F' \<subseteq> P[X]" and sub: "ideal F \<subset> ideal F'"
	+ from this(2) ideal.span_subset_spanI have "\<not> F' \<subseteq> ideal F" by blast
	+ then obtain p where "p \<in> F'" and "p \<notin> ideal F" by blast
	+ from this(1) \<open>F' \<subseteq> P[X]\<close> have "p \<in> P[X]" ..
	+ hence "1 \<in> ideal (insert p F)" using \<open>p \<notin> _\<close> by (rule assms(2))
	+ also have "\<dots> \<subseteq> ideal (F' \<union> F)" by (rule ideal.span_mono) (simp add: \<open>p \<in> F'\<close>)
	+ also have "\<dots> = ideal (ideal F' \<union> ideal F)" by (simp add: ideal.span_Un ideal.span_span)
	+ also from sub have "ideal F' \<union> ideal F = ideal F'" by blast
	+ finally show "ideal F' = UNIV" by (simp only: ideal_eq_UNIV_iff_contains_one ideal.span_span)
	+qed
	+
	+lemma generates_max_idealD:
	+ assumes "generates_max_ideal X F"
	+ shows "ideal F \<noteq> UNIV" and "F' \<subseteq> P[X] \<Longrightarrow> ideal F \<subset> ideal F' \<Longrightarrow> ideal F' = UNIV"
	+ using assms by (simp_all add: generates_max_ideal_def)
	+
	+lemma generates_max_ideal_cases:
	+ assumes "generates_max_ideal X F" and "F' \<subseteq> P[X]" and "ideal F \<subseteq> ideal F'"
	+ obtains "ideal F = ideal F'" \| "ideal F' = UNIV"
	+ using assms by (auto simp: generates_max_ideal_def)
	+
	+lemma max_ideal_UNIV_radical:
	+ assumes "generates_max_ideal UNIV F"
	+ shows "\<surd>ideal F = ideal F"
	+proof (rule ccontr)
	+ assume "\<surd>ideal F \<noteq> ideal F"
	+ with radical_superset have "ideal F \<subset> \<surd>ideal F" by blast
	+ also have "\<dots> = ideal (\<surd>ideal F)" by simp
	+ finally have "ideal F \<subset> ideal (\<surd>ideal F)" .
	+ with assms _ have "ideal (\<surd>ideal F) = UNIV" by (rule generates_max_idealD) simp
	+ hence "\<surd>ideal F = UNIV" by simp
	+ hence "1 \<in> \<surd>ideal F" by simp
	+ hence "1 \<in> ideal F" by (auto elim: radicalE)
	+ hence "ideal F = UNIV" by (simp only: ideal_eq_UNIV_iff_contains_one)
	+ moreover from assms have "ideal F \<noteq> UNIV" by (rule generates_max_idealD)
	+ ultimately show False by simp
	+qed
	+
	+lemma max_ideal_shape_aux:
	+ "(\<lambda>x. monomial 1 (Poly_Mapping.single x 1) - monomial (a x) 0) ` X \<subseteq> P[X]"
	+ by (auto intro!: Polys_closed_minus Polys_closed_monomial PPs_closed_single zero_in_PPs)
	+
	+lemma max_ideal_shapeI:
	+ "generates_max_ideal X ((\<lambda>x. monomial (1::'a::field) (Poly_Mapping.single x 1) - monomial (a x) 0) ` X)"
	+ (is "generates_max_ideal X ?F")
	+proof (rule generates_max_idealI_alt)
	+ (* Proof modeled after https://math.stackexchange.com/a/1028331. *)
	+
	+ show "ideal ?F \<noteq> UNIV"
	+ proof
	+ assume "ideal ?F = UNIV"
	+ hence "\<V> (ideal ?F) = \<V> UNIV" by (rule arg_cong)
	+ hence "\<V> ?F = {}" by simp
	+ moreover have "a \<in> \<V> ?F" by (rule variety_ofI) (auto simp: poly_eval_minus poly_eval_monomial)
	+ ultimately show False by simp
	+ qed
	+next
	+ fix p
	+ assume "p \<in> P[X]" and "p \<notin> ideal ?F"
	+ have "p \<in> ideal (insert p ?F)" by (rule ideal.span_base) simp
	+ let ?f = "\<lambda>x. monomial (1::'a) (Poly_Mapping.single x 1) - monomial (a x) 0"
	+ let ?g = "\<lambda>x. monomial (1::'a) (Poly_Mapping.single x 1) + monomial (a x) 0"
	+ define q where "q = poly_subst ?g p"
	+ have "p = poly_subst ?f q" unfolding q_def poly_subst_poly_subst
	+ by (rule sym, rule poly_subst_id)
	+ (simp add: poly_subst_plus poly_subst_monomial subst_pp_single flip: times_monomial_left)
	+ also have "\<dots> = (\<Sum>t\<in>keys q. punit.monom_mult (lookup q t) 0 (subst_pp ?f t))" by (fact poly_subst_def)
	+ also have "\<dots> = punit.monom_mult (lookup q 0) 0 (subst_pp ?f 0) +
	+ (\<Sum>t\<in>keys q - {0}. monomial (lookup q t) 0 * subst_pp ?f t)"
	+ (is "_ = _ + ?r")
	+ by (cases "0 \<in> keys q") (simp_all add: sum.remove in_keys_iff flip: times_monomial_left)
	+ also have "\<dots> = monomial (lookup q 0) 0 + ?r" by (simp flip: times_monomial_left)
	+ finally have eq: "p - ?r = monomial (lookup q 0) 0" by simp
	+ have "?r \<in> ideal ?F"
	+ proof (intro ideal.span_sum ideal.span_scale)
	+ fix t
	+ assume "t \<in> keys q - {0}"
	+ hence "t \<in> keys q" and "keys t \<noteq> {}" by simp_all
	+ from this(2) obtain x where "x \<in> keys t" by blast
	+ hence "x \<in> indets q" using \<open>t \<in> keys q\<close> by (rule in_indetsI)
	+ then obtain y where "y \<in> indets p" and "x \<in> indets (?g y)" unfolding q_def
	+ by (rule in_indets_poly_substE)
	+ from this(2) indets_plus_subset have "x \<in> indets (monomial (1::'a) (Poly_Mapping.single y 1)) \<union>
	+ indets (monomial (a y) 0)" ..
	+ with \<open>y \<in> indets p\<close> have "x \<in> indets p" by (simp add: indets_monomial)
	+ also from \<open>p \<in> P[X]\<close> have "\<dots> \<subseteq> X" by (rule PolysD)
	+ finally have "x \<in> X" .
	+ from \<open>x \<in> keys t\<close> have "lookup t x \<noteq> 0" by (simp add: in_keys_iff)
	+ hence eq: "b ^ lookup t x = b ^ Suc (lookup t x - 1)" for b by simp
	+
	+ have "subst_pp ?f t = (\<Prod>y\<in>keys t. ?f y ^ lookup t y)" by (fact subst_pp_def)
	+ also from \<open>x \<in> keys t\<close> have "\<dots> = ((\<Prod>y\<in>keys t - {x}. ?f y ^ lookup t y) * ?f x ^ (lookup t x - 1)) * ?f x"
	+ by (simp add: prod.remove mult.commute eq)
	+ also from \<open>x \<in> X\<close> have "\<dots> \<in> ideal ?F" by (intro ideal.span_scale ideal.span_base imageI)
	+ finally show "subst_pp ?f t \<in> ideal ?F" .
	+ qed
	+ also have "\<dots> \<subseteq> ideal (insert p ?F)" by (rule ideal.span_mono) blast
	+ finally have "?r \<in> ideal (insert p ?F)" .
	+ with \<open>p \<in> ideal _\<close> have "p - ?r \<in> ideal (insert p ?F)" by (rule ideal.span_diff)
	+ hence "monomial (lookup q 0) 0 \<in> ideal (insert p ?F)" by (simp only: eq)
	+ hence "monomial (inverse (lookup q 0)) 0 * monomial (lookup q 0) 0 \<in> ideal (insert p ?F)"
	+ by (rule ideal.span_scale)
	+ hence "monomial (inverse (lookup q 0) * lookup q 0) 0 \<in> ideal (insert p ?F)"
	+ by (simp add: times_monomial_monomial)
	+ moreover have "lookup q 0 \<noteq> 0"
	+ proof
	+ assume "lookup q 0 = 0"
	+ with eq \<open>?r \<in> ideal ?F\<close> have "p \<in> ideal ?F" by simp
	+ with \<open>p \<notin> ideal ?F\<close> show False ..
	+ qed
	+ ultimately show "1 \<in> ideal (insert p ?F)" by simp
	+qed
	+
	+text \<open>We first prove the following lemma assuming that the type of indeterminates is finite, and then
	+ transfer the result to arbitrary types of indeterminates by using the `types to sets' methodology.
	+ This approach facilitates the proof considerably.\<close>
	+
	+lemma max_ideal_shapeD_finite:
	+ assumes "generates_max_ideal UNIV (F::(('x::finite \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::alg_closed_field) set)"
	+ obtains a where "ideal F = ideal (range (\<lambda>x. monomial 1 (Poly_Mapping.single x 1) - monomial (a x) 0))"
	+proof -
	+ have fin: "finite (UNIV::'x set)" by simp
	+ have "(\<Inter>a\<in>\<V> F. ideal (range (\<lambda>x. monomial 1 (Poly_Mapping.single x 1) - monomial (a x) 0))) = \<I> (\<V> F)"
	+ (is "?A = _")
	+ proof (intro set_eqI iffI ideal_ofI INT_I)
	+ fix p a
	+ assume "p \<in> ?A" and "a \<in> \<V> F"
	+ hence "p \<in> ideal (range (\<lambda>x. monomial 1 (Poly_Mapping.single x 1) - monomial (a x) 0))"
	+ (is "_ \<in> ideal ?B") ..
	+ have "a \<in> \<V> ?B"
	+ proof (rule variety_ofI)
	+ fix f
	+ assume "f \<in> ?B"
	+ then obtain x where "f = monomial 1 (Poly_Mapping.single x 1) - monomial (a x) 0" ..
	+ thus "poly_eval a f = 0" by (simp add: poly_eval_minus poly_eval_monomial)
	+ qed
	+ hence "a \<in> \<V> (ideal ?B)" by (simp only: variety_of_ideal)
	+ thus "poly_eval a p = 0" using \<open>p \<in> ideal _\<close> by (rule variety_ofD)
	+ next
	+ fix p a
	+ assume "p \<in> \<I> (\<V> F)" and "a \<in> \<V> F"
	+ hence eq: "poly_eval a p = 0" by (rule ideal_ofD)
	+ have "p \<in> \<surd>ideal (range (\<lambda>x. monomial 1 (monomial 1 x) - monomial (a x) 0))" (is "_ \<in> \<surd>ideal ?B")
	+ using fin max_ideal_shape_aux
	+ proof (rule Nullstellensatz)
	+ show "p \<in> \<I> (\<V> ?B)"
	+ proof (rule ideal_ofI)
	+ fix a0
	+ assume "a0 \<in> \<V> ?B"
	+ have "a0 = a"
	+ proof
	+ fix x
	+ have "monomial 1 (monomial 1 x) - monomial (a x) 0 \<in> ?B" by (rule rangeI)
	+ with \<open>a0 \<in> _\<close> have "poly_eval a0 (monomial 1 (monomial 1 x) - monomial (a x) 0) = 0"
	+ by (rule variety_ofD)
	+ thus "a0 x = a x" by (simp add: poly_eval_minus poly_eval_monomial)
	+ qed
	+ thus "poly_eval a0 p = 0" by (simp only: eq)
	+ qed
	+ qed
	+ also have "\<dots> = ideal (range (\<lambda>x. monomial 1 (monomial 1 x) - monomial (a x) 0))"
	+ using max_ideal_shapeI by (rule max_ideal_UNIV_radical)
	+ finally show "p \<in> ideal (range (\<lambda>x. monomial 1 (monomial 1 x) - monomial (a x) 0))" .
	+ qed
	+ also from fin have "\<dots> = \<surd>ideal F" by (rule strong_Nullstellensatz) simp
	+ also from assms have "\<dots> = ideal F" by (rule max_ideal_UNIV_radical)
	+ finally have eq: "?A = ideal F" .
	+ also from assms have "\<dots> \<noteq> UNIV" by (rule generates_max_idealD)
	+ finally obtain a where "a \<in> \<V> F"
	+ and "ideal (range (\<lambda>x. monomial 1 (Poly_Mapping.single x (1::nat)) - monomial (a x) 0)) \<noteq> UNIV"
	+ (is "?B \<noteq> _") by auto
	+ from \<open>a \<in> \<V> F\<close> have "ideal F \<subseteq> ?B" by (auto simp flip: eq)
	+ with assms max_ideal_shape_aux show ?thesis
	+ proof (rule generates_max_ideal_cases)
	+ assume "ideal F = ?B"
	+ thus ?thesis ..
	+ next
	+ assume "?B = UNIV"
	+ with \<open>?B \<noteq> UNIV\<close> show ?thesis ..
	+ qed
	+qed
	+
	+lemmas max_ideal_shapeD_internalized = max_ideal_shapeD_finite[unoverload_type 'x]
	+
	+lemma max_ideal_shapeD:
	+ assumes "finite X" and "F \<subseteq> P[X]"
	+ and "generates_max_ideal X (F::(('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::alg_closed_field) set)"
	+ obtains a where "ideal F = ideal ((\<lambda>x. monomial 1 (Poly_Mapping.single x 1) - monomial (a x) 0) ` X)"
	+proof (cases "X = {}")
	+ case True
	+ from assms(3) have "ideal F \<noteq> UNIV" by (rule generates_max_idealD)
	+ hence "1 \<notin> ideal F" by (simp add: ideal_eq_UNIV_iff_contains_one)
	+ have "F \<subseteq> {0}"
	+ proof
	+ fix f
	+ assume "f \<in> F"
	+ with assms(2) have "f \<in> P[X]" ..
	+ then obtain c where f: "f = monomial c 0" by (auto simp: True Polys_empty)
	+ with \<open>f \<in> F\<close> have "monomial c 0 \<in> ideal F" by (simp only: ideal.span_base)
	+ hence "monomial (inverse c) 0 * monomial c 0 \<in> ideal F" by (rule ideal.span_scale)
	+ hence "monomial (inverse c * c) 0 \<in> ideal F" by (simp add: times_monomial_monomial)
	+ with \<open>1 \<notin> ideal F\<close> left_inverse have "c = 0" by fastforce
	+ thus "f \<in> {0}" by (simp add: f)
	+ qed
	+ hence "ideal F = ideal ((\<lambda>x. monomial 1 (Poly_Mapping.single x 1) - monomial (undefined x) 0) ` X)"
	+ by (simp add: True)
	+ thus ?thesis ..
	+next
	+ case False
	+ {
	+ text \<open>We define the type @{typ 'y} to be isomorphic to @{term X}.\<close>
	+ assume "\<exists>(Rep :: 'y \<Rightarrow> 'x) Abs. type_definition Rep Abs X"
	+ then obtain rep :: "'y \<Rightarrow> 'x" and abs :: "'x \<Rightarrow> 'y" where t: "type_definition rep abs X"
	+ by blast
	+ then interpret y: type_definition rep abs X .
	+
	+ have 1: "map_indets (rep \<circ> abs) ` A = A" if "A \<subseteq> P[X]" for A::"(_ \<Rightarrow>\<^sub>0 'a) set"
	+ proof
	+ from that show "map_indets (rep \<circ> abs) ` A \<subseteq> A"
	+ by (smt PolysD(2) comp_apply image_subset_iff map_indets_id subsetD y.Abs_inverse)
	+ next
	+ from that show "A \<subseteq> map_indets (rep \<circ> abs) ` A"
	+ by (smt PolysD(2) comp_apply image_eqI map_indets_id subsetD subsetI y.Abs_inverse)
	+ qed
	+ have 2: "inj rep" by (meson inj_onI y.Rep_inject)
	+ hence 3: "inj (map_indets rep)" by (rule map_indets_injI)
	+
	+ have "class.finite TYPE('y)"
	+ proof
	+ from assms(1) have "finite (abs ` X)" by (rule finite_imageI)
	+ thus "finite (UNIV::'y set)" by (simp only: y.Abs_image)
	+ qed
	+ moreover have "generates_max_ideal UNIV (map_indets abs ` F)"
	+ proof (intro generates_max_idealI notI)
	+ assume "ideal (map_indets abs ` F) = UNIV"
	+ hence "1 \<in> ideal (map_indets abs ` F)" by simp
	+ hence "map_indets rep 1 \<in> map_indets rep ` ideal (map_indets abs ` F)" by (rule imageI)
	+ also from map_indets_plus map_indets_times have "\<dots> \<subseteq> ideal (map_indets rep ` map_indets abs ` F)"
	+ by (rule image_ideal_subset)
	+ also from assms(2) have "map_indets rep ` map_indets abs ` F = F"
	+ by (simp only: image_image map_indets_map_indets 1)
	+ finally have "1 \<in> ideal F" by simp
	+ moreover from assms(3) have "ideal F \<noteq> UNIV" by (rule generates_max_idealD)
	+ ultimately show False by (simp add: ideal_eq_UNIV_iff_contains_one)
	+ next
	+ fix F'
	+ assume "ideal (map_indets abs ` F) \<subset> ideal F'"
	+ with inj_on_subset have "map_indets rep ` ideal (map_indets abs ` F) \<subset> map_indets rep ` ideal F'"
	+ by (rule inj_on_strict_subset) (fact 3, fact subset_UNIV)
	+ hence sub: "ideal F \<inter> P[X] \<subset> ideal (map_indets rep ` F') \<inter> P[X]" using 2 assms(2)
	+ by (simp add: image_map_indets_ideal image_image map_indets_map_indets 1 y.Rep_range)
	+ have "ideal F \<subset> ideal (map_indets rep ` F')"
	+ proof (intro psubsetI notI ideal.span_subset_spanI subsetI)
	+ fix p
	+ assume "p \<in> F"
	+ with assms(2) ideal.span_base sub show "p \<in> ideal (map_indets rep ` F')" by blast
	+ next
	+ assume "ideal F = ideal (map_indets rep ` F')"
	+ with sub show False by simp
	+ qed
	+ with assms(3) _ have "ideal (map_indets rep ` F') = UNIV"
	+ proof (rule generates_max_idealD)
	+ from subset_UNIV have "map_indets rep ` F' \<subseteq> range (map_indets rep)" by (rule image_mono)
	+ also have "\<dots> = P[X]" by (simp only: range_map_indets y.Rep_range)
	+ finally show "map_indets rep ` F' \<subseteq> P[X]" .
	+ qed
	+ hence "P[range rep] = ideal (map_indets rep ` F') \<inter> P[range rep]" by simp
	+ also from 2 have "\<dots> = map_indets rep ` ideal F'" by (simp only: image_map_indets_ideal)
	+ finally have "map_indets rep ` ideal F' = range (map_indets rep)"
	+ by (simp only: range_map_indets)
	+ with 3 show "ideal F' = UNIV" by (metis inj_image_eq_iff)
	+ qed
	+ ultimately obtain a
	+ where *: "ideal (map_indets abs ` F) =
	+ ideal (range (\<lambda>x. monomial 1 (Poly_Mapping.single x (Suc 0)) - monomial (a x) 0))"
	+ (is "_ = ?A")
	+ by (rule max_ideal_shapeD_internalized[where 'x='y, untransferred, simplified])
	+ hence "map_indets rep ` ideal (map_indets abs ` F) = map_indets rep ` ?A" by simp
	+ with 2 assms(2) have "ideal F \<inter> P[X] =
	+ ideal (range (\<lambda>x. monomial 1 (Poly_Mapping.single (rep x) 1) - monomial (a x) 0)) \<inter> P[X]"
	+ (is "_ = ideal ?B \<inter> _")
	+ by (simp add: image_map_indets_ideal y.Rep_range image_image map_indets_map_indets
	+ map_indets_minus map_indets_monomial 1)
	+ also have "?B = (\<lambda>x. monomial 1 (Poly_Mapping.single x 1) - monomial ((a \<circ> abs) x) 0) ` X"
	+ (is "_ = ?C")
	+ proof
	+ show "?B \<subseteq> ?C" by (smt comp_apply image_iff image_subset_iff y.Abs_image y.Abs_inverse)
	+ next
	+ from y.Rep_inverse y.Rep_range show "?C \<subseteq> ?B" by auto
	+ qed
	+ finally have eq: "ideal F \<inter> P[X] = ideal ?C \<inter> P[X]" .
	+ have "ideal F = ideal ?C"
	+ proof (intro subset_antisym ideal.span_subset_spanI subsetI)
	+ fix p
	+ assume "p \<in> F"
	+ with assms(2) ideal.span_base have "p \<in> ideal F \<inter> P[X]" by blast
	+ thus "p \<in> ideal ?C" by (simp add: eq)
	+ next
	+ fix p
	+ assume "p \<in> ?C"
	+ then obtain x where "x \<in> X" and "p = monomial 1 (monomial 1 x) - monomial ((a \<circ> abs) x) 0" ..
	+ note this(2)
	+ also from \<open>x \<in> X\<close> have "\<dots> \<in> P[X]"
	+ by (intro Polys_closed_minus Polys_closed_monomial PPs_closed_single zero_in_PPs)
	+ finally have "p \<in> P[X]" .
	+ with \<open>p \<in> ?C\<close> have "p \<in> ideal ?C \<inter> P[X]" by (simp add: ideal.span_base)
	+ also have "\<dots> = ideal F \<inter> P[X]" by (simp only: eq)
	+ finally show "p \<in> ideal F" by simp
	+ qed
	+ hence ?thesis ..
	+ }
	+ note rl = this[cancel_type_definition]
	+ from False show ?thesis by (rule rl)
	+qed
	+
	+theorem Nullstellensatz_field:
	+ assumes "finite X" and "F \<subseteq> P[X]" and "generates_max_ideal X (F::(_ \<Rightarrow>\<^sub>0 _::alg_closed_field) set)"
	+ and "x \<in> X"
	+ shows "{0} \<subset> ideal F \<inter> P[{x}]"
	+ unfolding subset_not_subset_eq
	+proof (intro conjI notI)
	+ show "{0} \<subseteq> ideal F \<inter> P[{x}]" by (auto intro: ideal.span_zero zero_in_Polys)
	+next
	+ from assms(1, 2, 3) obtain a
	+ where eq: "ideal F = ideal ((\<lambda>x. monomial 1 (monomial 1 x) - monomial (a x) 0) ` X)"
	+ by (rule max_ideal_shapeD)
	+ let ?p = "\<lambda>x. monomial 1 (monomial 1 x) - monomial (a x) 0"
	+ from assms(4) have "?p x \<in> ?p ` X" by (rule imageI)
	+ also have "\<dots> \<subseteq> ideal F" unfolding eq by (rule ideal.span_superset)
	+ finally have "?p x \<in> ideal F" .
	+ moreover have "?p x \<in> P[{x}]"
	+ by (auto intro!: Polys_closed_minus Polys_closed_monomial PPs_closed_single zero_in_PPs)
	+ ultimately have "?p x \<in> ideal F \<inter> P[{x}]" ..
	+ also assume "\<dots> \<subseteq> {0}"
	+ finally show False
	+ by (metis diff_eq_diff_eq diff_self monomial_0D monomial_inj one_neq_zero singletonD)
	+qed
	+
	+end (* theory *)
	diff --git a/thys/Nullstellensatz/ROOT b/thys/Nullstellensatz/ROOT
	new file mode 100755
	--- /dev/null
	+++ b/thys/Nullstellensatz/ROOT
	@@ -0,0 +1,12 @@
	+chapter AFP
	+
	+session Nullstellensatz (AFP) = Groebner_Bases +
	+ options [timeout = 3600]
	+ sessions
	+ "HOL-Types_To_Sets"
	+ theories
	+ "HOL-Types_To_Sets.Types_To_Sets"
	+ Nullstellensatz_Field
	+ document_files
	+ "root.tex"
	+ "root.bib"
	diff --git a/thys/Nullstellensatz/Univariate_PM.thy b/thys/Nullstellensatz/Univariate_PM.thy
	new file mode 100755
	--- /dev/null
	+++ b/thys/Nullstellensatz/Univariate_PM.thy
	@@ -0,0 +1,482 @@
	+(* Author: Alexander Maletzky *)
	+
	+section \<open>Polynomial Mappings and Univariate Polynomials\<close>
	+
	+theory Univariate_PM
	+ imports "HOL-Computational_Algebra.Polynomial" Polynomials.MPoly_PM
	+begin
	+
	+subsection \<open>Morphisms \<open>pm_of_poly\<close> and \<open>poly_of_pm\<close>\<close>
	+
	+text \<open>Many things in this section are copied from theory \<open>Polynomials.MPoly_Type_Univariate\<close>.\<close>
	+
	+lemma pm_of_poly_aux:
	+ "{t. (poly.coeff p (lookup t x) when t \<in> .[{x}]) \<noteq> 0} =
	+ Poly_Mapping.single x ` {d. poly.coeff p d \<noteq> 0}" (is "?M = _")
	+proof (intro subset_antisym subsetI)
	+ fix t
	+ assume "t \<in> ?M"
	+ hence "\<And>y. y \<noteq> x \<Longrightarrow> Poly_Mapping.lookup t y = 0" by (fastforce simp: PPs_def in_keys_iff)
	+ hence "t = Poly_Mapping.single x (lookup t x)"
	+ using poly_mapping_eqI by (metis (full_types) lookup_single_eq lookup_single_not_eq)
	+ then show "t \<in> (Poly_Mapping.single x) ` {d. poly.coeff p d \<noteq> 0}" using \<open>t \<in> ?M\<close> by auto
	+qed (auto split: if_splits simp: PPs_def)
	+
	+lift_definition pm_of_poly :: "'x \<Rightarrow> 'a poly \<Rightarrow> ('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::comm_monoid_add"
	+ is "\<lambda>x p t. (poly.coeff p (lookup t x)) when t \<in> .[{x}]"
	+proof -
	+ fix x::'x and p::"'a poly"
	+ show "finite {t. (poly.coeff p (lookup t x) when t \<in> .[{x}]) \<noteq> 0}" unfolding pm_of_poly_aux
	+ using finite_surj[OF MOST_coeff_eq_0[unfolded eventually_cofinite]] by blast
	+qed
	+
	+definition poly_of_pm :: "'x \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<Rightarrow> 'a::comm_monoid_add poly"
	+ where "poly_of_pm x p = Abs_poly (\<lambda>d. lookup p (Poly_Mapping.single x d))"
	+
	+lemma lookup_pm_of_poly_single [simp]:
	+ "lookup (pm_of_poly x p) (Poly_Mapping.single x d) = poly.coeff p d"
	+ by (simp add: pm_of_poly.rep_eq PPs_closed_single)
	+
	+lemma keys_pm_of_poly: "keys (pm_of_poly x p) = Poly_Mapping.single x ` {d. poly.coeff p d \<noteq> 0}"
	+proof -
	+ have "keys (pm_of_poly x p) = {t. (poly.coeff p (lookup t x) when t \<in> .[{x}]) \<noteq> 0}"
	+ by (rule set_eqI) (simp add: pm_of_poly.rep_eq flip: lookup_not_eq_zero_eq_in_keys)
	+ also have "\<dots> = Poly_Mapping.single x ` {d. poly.coeff p d \<noteq> 0}" by (fact pm_of_poly_aux)
	+ finally show ?thesis .
	+qed
	+
	+lemma coeff_poly_of_pm [simp]: "poly.coeff (poly_of_pm x p) k = lookup p (Poly_Mapping.single x k)"
	+proof -
	+ have 0:"Poly_Mapping.single x ` {d. lookup p (Poly_Mapping.single x d) \<noteq> 0} \<subseteq> {d. lookup p d \<noteq> 0}"
	+ by auto
	+ have "\<forall>\<^sub>\<infinity> k. lookup p (Poly_Mapping.single x k) = 0" unfolding coeff_def eventually_cofinite
	+ using finite_imageD[OF finite_subset[OF 0 Poly_Mapping.finite_lookup]] inj_single
	+ by (metis inj_eq inj_onI)
	+ then show ?thesis by (simp add: poly_of_pm_def Abs_poly_inverse)
	+qed
	+
	+lemma pm_of_poly_of_pm:
	+ assumes "p \<in> P[{x}]"
	+ shows "pm_of_poly x (poly_of_pm x p) = p"
	+proof (rule poly_mapping_eqI)
	+ fix t
	+ from assms have "keys p \<subseteq> .[{x}]" by (rule PolysD)
	+ show "lookup (pm_of_poly x (poly_of_pm x p)) t = lookup p t"
	+ proof (simp add: pm_of_poly.rep_eq when_def, intro conjI impI)
	+ assume "t \<in> .[{x}]"
	+ hence "Poly_Mapping.single x (lookup t x) = t"
	+ by (simp add: PPsD keys_subset_singleton_imp_monomial)
	+ thus "lookup p (Poly_Mapping.single x (lookup t x)) = lookup p t" by simp
	+ next
	+ assume "t \<notin> .[{x}]"
	+ with assms PolysD have "t \<notin> keys p" by blast
	+ thus "lookup p t = 0" by (simp add: in_keys_iff)
	+ qed
	+qed
	+
	+lemma poly_of_pm_of_poly [simp]: "poly_of_pm x (pm_of_poly x p) = p"
	+ by (simp add: poly_of_pm_def coeff_inverse)
	+
	+lemma pm_of_poly_in_Polys: "pm_of_poly x p \<in> P[{x}]"
	+ by (auto simp: keys_pm_of_poly PPs_closed_single intro!: PolysI)
	+
	+lemma pm_of_poly_zero [simp]: "pm_of_poly x 0 = 0"
	+ by (rule poly_mapping_eqI) (simp add: pm_of_poly.rep_eq)
	+
	+lemma pm_of_poly_eq_zero_iff [iff]: "pm_of_poly x p = 0 \<longleftrightarrow> p = 0"
	+ by (metis poly_of_pm_of_poly pm_of_poly_zero)
	+
	+lemma pm_of_poly_monom: "pm_of_poly x (Polynomial.monom c d) = monomial c (Poly_Mapping.single x d)"
	+proof (rule poly_mapping_eqI)
	+ fix t
	+ show "lookup (pm_of_poly x (Polynomial.monom c d)) t = lookup (monomial c (monomial d x)) t"
	+ proof (cases "t \<in> .[{x}]")
	+ case True
	+ thus ?thesis
	+ by (auto simp: pm_of_poly.rep_eq lookup_single PPs_singleton when_def dest: monomial_inj)
	+ next
	+ case False
	+ thus ?thesis by (auto simp add: pm_of_poly.rep_eq lookup_single PPs_singleton)
	+ qed
	+qed
	+
	+lemma pm_of_poly_plus: "pm_of_poly x (p + q) = pm_of_poly x p + pm_of_poly x q"
	+ by (rule poly_mapping_eqI) (simp add: pm_of_poly.rep_eq lookup_add when_add_distrib)
	+
	+lemma pm_of_poly_uminus [simp]: "pm_of_poly x (- p) = - pm_of_poly x p"
	+ by (rule poly_mapping_eqI) (simp add: pm_of_poly.rep_eq when_distrib)
	+
	+lemma pm_of_poly_minus: "pm_of_poly x (p - q) = pm_of_poly x p - pm_of_poly x q"
	+ by (rule poly_mapping_eqI) (simp add: pm_of_poly.rep_eq lookup_minus when_diff_distrib)
	+
	+lemma pm_of_poly_one [simp]: "pm_of_poly x 1 = 1"
	+ by (simp add: pm_of_poly_monom flip: single_one monom_eq_1)
	+
	+lemma pm_of_poly_pCons:
	+ "pm_of_poly x (pCons c p) =
	+ monomial c 0 + punit.monom_mult (1::_::monoid_mult) (Poly_Mapping.single x 1) (pm_of_poly x p)"
	+ (is "?l = ?r")
	+proof (rule poly_mapping_eqI)
	+ fix t
	+ let ?x = "Poly_Mapping.single x (Suc 0)"
	+ show "lookup ?l t = lookup ?r t"
	+ proof (cases "?x adds t")
	+ case True
	+ have 1: "t - ?x \<in> .[{x}] \<longleftrightarrow> t \<in> .[{x}]"
	+ proof
	+ assume "t - ?x \<in> .[{x}]"
	+ moreover have "?x \<in> .[{x}]" by (rule PPs_closed_single) simp
	+ ultimately have "(t - ?x) + ?x \<in> .[{x}]" by (rule PPs_closed_plus)
	+ with True show "t \<in> .[{x}]" by (simp add: adds_minus)
	+ qed (rule PPs_closed_minus)
	+ from True have "0 < lookup t x"
	+ by (metis adds_minus lookup_add lookup_single_eq n_not_Suc_n neq0_conv plus_eq_zero_2)
	+ moreover from this have "t \<noteq> 0" by auto
	+ ultimately show ?thesis using True
	+ by (simp add: pm_of_poly.rep_eq lookup_add lookup_single punit.lookup_monom_mult 1 coeff_pCons
	+ lookup_minus split: nat.split)
	+ next
	+ case False
	+ moreover have "t \<in> .[{x}] \<longleftrightarrow> t = 0"
	+ proof
	+ assume "t \<in> .[{x}]"
	+ hence "keys t \<subseteq> {x}" by (rule PPsD)
	+ show "t = 0"
	+ proof (rule ccontr)
	+ assume "t \<noteq> 0"
	+ hence "keys t \<noteq> {}" by simp
	+ then obtain y where "y \<in> keys t" by blast
	+ with \<open>keys t \<subseteq> {x}\<close> have "y \<in> {x}" ..
	+ hence "y = x" by simp
	+ with \<open>y \<in> keys t\<close> have "Suc 0 \<le> lookup t x" by (simp add: in_keys_iff)
	+ hence "?x adds t"
	+ by (metis adds_poly_mappingI le0 le_funI lookup_single_eq lookup_single_not_eq)
	+ with False show False ..
	+ qed
	+ qed (simp only: zero_in_PPs)
	+ ultimately show ?thesis
	+ by (simp add: pm_of_poly.rep_eq lookup_add lookup_single punit.lookup_monom_mult when_def)
	+ qed
	+qed
	+
	+lemma pm_of_poly_smult [simp]: "pm_of_poly x (Polynomial.smult c p) = c \<cdot> pm_of_poly x p"
	+ by (rule poly_mapping_eqI) (simp add: pm_of_poly.rep_eq when_distrib)
	+
	+lemma pm_of_poly_times: "pm_of_poly x (p * q) = pm_of_poly x p * pm_of_poly x (q::_::ring_1 poly)"
	+proof (induct p)
	+ case 0
	+ show ?case by simp
	+next
	+ case (pCons a p)
	+ show ?case
	+ by (simp add: pm_of_poly_plus pm_of_poly_pCons map_scale_eq_times pCons(2) algebra_simps
	+ flip: times_monomial_left)
	+qed
	+
	+lemma pm_of_poly_sum: "pm_of_poly x (sum f I) = (\<Sum>i\<in>I. pm_of_poly x (f i))"
	+ by (induct I rule: infinite_finite_induct) (simp_all add: pm_of_poly_plus)
	+
	+lemma pm_of_poly_prod: "pm_of_poly x (prod f I) = (\<Prod>i\<in>I. pm_of_poly x (f i :: _::ring_1 poly))"
	+ by (induct I rule: infinite_finite_induct) (simp_all add: pm_of_poly_times)
	+
	+lemma pm_of_poly_power [simp]: "pm_of_poly x (p ^ m) = pm_of_poly x (p::_::ring_1 poly) ^ m"
	+ by (induct m) (simp_all add: pm_of_poly_times)
	+
	+lemma poly_of_pm_zero [simp]: "poly_of_pm x 0 = 0"
	+ by (metis poly_of_pm_of_poly pm_of_poly_zero)
	+
	+lemma poly_of_pm_eq_zero_iff: "poly_of_pm x p = 0 \<longleftrightarrow> keys p \<inter> .[{x}] = {}"
	+proof
	+ assume eq: "poly_of_pm x p = 0"
	+ {
	+ fix t
	+ assume "t \<in> .[{x}]"
	+ then obtain d where "t = Poly_Mapping.single x d" unfolding PPs_singleton ..
	+ moreover assume "t \<in> keys p"
	+ ultimately have "0 \<noteq> lookup p (Poly_Mapping.single x d)" by (simp add: in_keys_iff)
	+ also have "lookup p (Poly_Mapping.single x d) = Polynomial.coeff (poly_of_pm x p) d"
	+ by simp
	+ also have "\<dots> = 0" by (simp add: eq)
	+ finally have False by blast
	+ }
	+ thus "keys p \<inter> .[{x}] = {}" by blast
	+next
	+ assume *: "keys p \<inter> .[{x}] = {}"
	+ {
	+ fix d
	+ have "Poly_Mapping.single x d \<in> .[{x}]" (is "?x \<in> _") by (rule PPs_closed_single) simp
	+ with * have "?x \<notin> keys p" by blast
	+ hence "Polynomial.coeff (poly_of_pm x p) d = 0" by (simp add: in_keys_iff)
	+ }
	+ thus "poly_of_pm x p = 0" using leading_coeff_0_iff by blast
	+qed
	+
	+lemma poly_of_pm_monomial:
	+ "poly_of_pm x (monomial c t) = (Polynomial.monom c (lookup t x) when t \<in> .[{x}])"
	+proof (cases "t \<in> .[{x}]")
	+ case True
	+ moreover from this obtain d where "t = Poly_Mapping.single x d"
	+ by (metis PPsD keys_subset_singleton_imp_monomial)
	+ ultimately show ?thesis unfolding Polynomial.monom.abs_eq coeff_poly_of_pm
	+ by (auto simp: poly_of_pm_def lookup_single when_def
	+ dest!: monomial_inj intro!: arg_cong[where f=Abs_poly])
	+next
	+ case False
	+ moreover from this have "t \<noteq> monomial d x" for d by (auto simp: PPs_closed_single)
	+ ultimately show ?thesis unfolding Polynomial.monom.abs_eq coeff_poly_of_pm
	+ by (auto simp: poly_of_pm_def lookup_single when_def zero_poly.abs_eq)
	+qed
	+
	+lemma poly_of_pm_plus: "poly_of_pm x (p + q) = poly_of_pm x p + poly_of_pm x q"
	+ unfolding Polynomial.plus_poly.abs_eq coeff_poly_of_pm by (simp add: poly_of_pm_def lookup_add)
	+
	+lemma poly_of_pm_uminus [simp]: "poly_of_pm x (- p) = - poly_of_pm x p"
	+ unfolding Polynomial.uminus_poly.abs_eq coeff_poly_of_pm by (simp add: poly_of_pm_def)
	+
	+lemma poly_of_pm_minus: "poly_of_pm x (p - q) = poly_of_pm x p - poly_of_pm x q"
	+ unfolding Polynomial.minus_poly.abs_eq coeff_poly_of_pm by (simp add: poly_of_pm_def lookup_minus)
	+
	+lemma poly_of_pm_one [simp]: "poly_of_pm x 1 = 1"
	+ by (simp add: poly_of_pm_monomial zero_in_PPs flip: single_one monom_eq_1)
	+
	+lemma poly_of_pm_times:
	+ "poly_of_pm x (p * q) = poly_of_pm x p * poly_of_pm x (q::_ \<Rightarrow>\<^sub>0 'a::comm_semiring_1)"
	+proof -
	+ have eq: "poly_of_pm x (monomial c t * q) = poly_of_pm x (monomial c t) * poly_of_pm x q"
	+ if "c \<noteq> 0" for c t
	+ proof (cases "t \<in> .[{x}]")
	+ case True
	+ then obtain d where t: "t = Poly_Mapping.single x d" unfolding PPs_singleton ..
	+ have "poly_of_pm x (monomial c t) * poly_of_pm x q = Polynomial.monom c (lookup t x) * poly_of_pm x q"
	+ by (simp add: True poly_of_pm_monomial)
	+ also have "\<dots> = poly_of_pm x (monomial c t * q)" unfolding t
	+ proof (induct d)
	+ case 0
	+ have "Polynomial.smult c (poly_of_pm x q) = poly_of_pm x (c \<cdot> q)"
	+ unfolding Polynomial.smult.abs_eq coeff_poly_of_pm by (simp add: poly_of_pm_def)
	+ with that show ?case by (simp add: Polynomial.times_poly_def flip: map_scale_eq_times)
	+ next
	+ case (Suc d)
	+ have 1: "Poly_Mapping.single x a adds Poly_Mapping.single x b \<longleftrightarrow> a \<le> b" for a b :: nat
	+ by (metis adds_def deg_pm_mono deg_pm_single le_Suc_ex single_add)
	+ have 2: "poly_of_pm x (punit.monom_mult 1 (Poly_Mapping.single x 1) r) = pCons 0 (poly_of_pm x r)"
	+ for r :: "_ \<Rightarrow>\<^sub>0 'a" unfolding poly.coeff_inject[symmetric]
	+ by (rule ext) (simp add: coeff_pCons punit.lookup_monom_mult adds_zero monomial_0_iff 1
	+ flip: single_diff split: nat.split)
	+ from Suc that have "Polynomial.monom c (lookup (monomial (Suc d) x) x) * poly_of_pm x q =
	+ poly_of_pm x (punit.monom_mult 1 (Poly_Mapping.single x 1)
	+ ((monomial c (monomial d x)) * q))"
	+ by (simp add: Polynomial.times_poly_def 2 del: One_nat_def)
	+ also have "\<dots> = poly_of_pm x (monomial c (Poly_Mapping.single x (Suc d)) * q)"
	+ by (simp add: ac_simps times_monomial_monomial flip: single_add times_monomial_left)
	+ finally show ?case .
	+ qed
	+ finally show ?thesis by (rule sym)
	+ next
	+ case False
	+ {
	+ fix s
	+ assume "s \<in> keys (monomial c t * q)"
	+ also have "\<dots> \<subseteq> (+) t ` keys q" unfolding times_monomial_left
	+ by (fact punit.keys_monom_mult_subset[simplified])
	+ finally obtain u where s: "s = t + u" ..
	+ assume "s \<in> .[{x}]"
	+ hence "s - u \<in> .[{x}]" by (rule PPs_closed_minus)
	+ hence "t \<in> .[{x}]" by (simp add: s)
	+ with False have False ..
	+ }
	+ hence "poly_of_pm x (monomial c t * q) = 0" by (auto simp: poly_of_pm_eq_zero_iff)
	+ with False show ?thesis by (simp add: poly_of_pm_monomial)
	+ qed
	+ show ?thesis
	+ by (induct p rule: poly_mapping_plus_induct) (simp_all add: poly_of_pm_plus eq distrib_right)
	+qed
	+
	+lemma poly_of_pm_sum: "poly_of_pm x (sum f I) = (\<Sum>i\<in>I. poly_of_pm x (f i))"
	+ by (induct I rule: infinite_finite_induct) (simp_all add: poly_of_pm_plus)
	+
	+lemma poly_of_pm_prod: "poly_of_pm x (prod f I) = (\<Prod>i\<in>I. poly_of_pm x (f i))"
	+ by (induct I rule: infinite_finite_induct) (simp_all add: poly_of_pm_times)
	+
	+lemma poly_of_pm_power [simp]: "poly_of_pm x (p ^ m) = poly_of_pm x p ^ m"
	+ by (induct m) (simp_all add: poly_of_pm_times)
	+
	+subsection \<open>Evaluating Polynomials\<close>
	+
	+lemma poly_eq_poly_eval: "poly (poly_of_pm x p) a = poly_eval (\<lambda>y. a when y = x) p"
	+proof (induction p rule: poly_mapping_plus_induct)
	+ case 1
	+ show ?case by simp
	+next
	+ case (2 p c t)
	+ show ?case
	+ proof (cases "t \<in> .[{x}]")
	+ case True
	+ have "poly_eval (\<lambda>y. a when y = x) (monomial c t) = c * (\<Prod>y\<in>keys t. (a when y = x) ^ lookup t y)"
	+ by (simp only: poly_eval_monomial)
	+ also from True have "(\<Prod>y\<in>keys t. (a when y = x) ^ lookup t y) = (\<Prod>y\<in>{x}. (a when y = x) ^ lookup t y)"
	+ by (intro prod.mono_neutral_left ballI) (auto simp: in_keys_iff dest: PPsD)
	+ also have "\<dots> = a ^ lookup t x" by simp
	+ finally show ?thesis
	+ by (simp add: poly_of_pm_plus poly_of_pm_monomial poly_monom poly_eval_plus True 2(3))
	+ next
	+ case False
	+ have "poly_eval (\<lambda>y. a when y = x) (monomial c t) = c * (\<Prod>y\<in>keys t. (a when y = x) ^ lookup t y)"
	+ by (simp only: poly_eval_monomial)
	+ also from finite_keys have "(\<Prod>y\<in>keys t. (a when y = x) ^ lookup t y) = 0"
	+ proof (rule prod_zero)
	+ from False obtain y where "y \<in> keys t" and "y \<noteq> x" by (auto simp: PPs_def)
	+ from this(1) show "\<exists>y\<in>keys t. (a when y = x) ^ lookup t y = 0"
	+ proof
	+ from \<open>y \<in> keys t\<close> have "0 < lookup t y" by (simp add: in_keys_iff)
	+ with \<open>y \<noteq> x\<close> show "(a when y = x) ^ lookup t y = 0" by (simp add: zero_power)
	+ qed
	+ qed
	+ finally show ?thesis
	+ by (simp add: poly_of_pm_plus poly_of_pm_monomial poly_monom poly_eval_plus False 2(3))
	+ qed
	+qed
	+
	+corollary poly_eq_poly_eval':
	+ assumes "p \<in> P[{x}]"
	+ shows "poly (poly_of_pm x p) a = poly_eval (\<lambda>_. a) p"
	+ unfolding poly_eq_poly_eval using refl
	+proof (rule poly_eval_cong)
	+ fix y
	+ assume "y \<in> indets p"
	+ also from assms have "\<dots> \<subseteq> {x}" by (rule PolysD)
	+ finally show "(a when y = x) = a" by simp
	+qed
	+
	+lemma poly_eval_eq_poly: "poly_eval a (pm_of_poly x p) = poly p (a x)"
	+ by (induct p)
	+ (simp_all add: pm_of_poly_pCons poly_eval_plus poly_eval_times poly_eval_monomial
	+ flip: times_monomial_left)
	+
	+subsection \<open>Morphisms \<open>flat_pm_of_poly\<close> and \<open>poly_of_focus\<close>\<close>
	+
	+definition flat_pm_of_poly :: "'x \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) poly \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::semiring_1)"
	+ where "flat_pm_of_poly x = flatten \<circ> pm_of_poly x"
	+
	+definition poly_of_focus :: "'x \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a) \<Rightarrow> (('x \<Rightarrow>\<^sub>0 nat) \<Rightarrow>\<^sub>0 'a::comm_monoid_add) poly"
	+ where "poly_of_focus x = poly_of_pm x \<circ> focus {x}"
	+
	+lemma flat_pm_of_poly_in_Polys:
	+ assumes "range (poly.coeff p) \<subseteq> P[Y]"
	+ shows "flat_pm_of_poly x p \<in> P[insert x Y]"
	+proof -
	+ let ?p = "pm_of_poly x p"
	+ from assms have "lookup ?p ` keys ?p \<subseteq> P[Y]" by (simp add: keys_pm_of_poly image_image) blast
	+ with pm_of_poly_in_Polys have "flatten ?p \<in> P[{x} \<union> Y]" by (rule flatten_in_Polys)
	+ thus ?thesis by (simp add: flat_pm_of_poly_def)
	+qed
	+
	+corollary indets_flat_pm_of_poly_subset:
	+ "indets (flat_pm_of_poly x p) \<subseteq> insert x (\<Union> (indets ` range (poly.coeff p)))"
	+proof -
	+ let ?p = "pm_of_poly x p"
	+ let ?Y = "\<Union> (indets ` range (poly.coeff p))"
	+ have "range (poly.coeff p) \<subseteq> P[?Y]" by (auto intro: PolysI_alt)
	+ hence "flat_pm_of_poly x p \<in> P[insert x ?Y]" by (rule flat_pm_of_poly_in_Polys)
	+ thus ?thesis by (rule PolysD)
	+qed
	+
	+lemma
	+ shows flat_pm_of_poly_zero [simp]: "flat_pm_of_poly x 0 = 0"
	+ and flat_pm_of_poly_monom: "flat_pm_of_poly x (Polynomial.monom c d) =
	+ punit.monom_mult 1 (Poly_Mapping.single x d) c"
	+ and flat_pm_of_poly_plus: "flat_pm_of_poly x (p + q) =
	+ flat_pm_of_poly x p + flat_pm_of_poly x q"
	+ and flat_pm_of_poly_one [simp]: "flat_pm_of_poly x 1 = 1"
	+ and flat_pm_of_poly_sum: "flat_pm_of_poly x (sum f I) = (\<Sum>i\<in>I. flat_pm_of_poly x (f i))"
	+ by (simp_all add: flat_pm_of_poly_def pm_of_poly_monom flatten_monomial pm_of_poly_plus
	+ flatten_plus pm_of_poly_sum flatten_sum)
	+
	+lemma
	+ shows flat_pm_of_poly_uminus [simp]: "flat_pm_of_poly x (- p) = - flat_pm_of_poly x p"
	+ and flat_pm_of_poly_minus: "flat_pm_of_poly x (p - q) =
	+ flat_pm_of_poly x p - flat_pm_of_poly x (q::_::ring poly)"
	+ by (simp_all add: flat_pm_of_poly_def pm_of_poly_minus flatten_minus)
	+
	+lemma flat_pm_of_poly_pCons:
	+ "flat_pm_of_poly x (pCons c p) =
	+ c + punit.monom_mult 1 (Poly_Mapping.single x 1) (flat_pm_of_poly x (p::_::comm_semiring_1 poly))"
	+ by (simp add: flat_pm_of_poly_def pm_of_poly_pCons flatten_plus flatten_monomial flatten_times
	+ flip: times_monomial_left)
	+
	+lemma flat_pm_of_poly_smult [simp]:
	+ "flat_pm_of_poly x (Polynomial.smult c p) = c * flat_pm_of_poly x (p::_::comm_semiring_1 poly)"
	+ by (simp add: flat_pm_of_poly_def map_scale_eq_times flatten_times flatten_monomial pm_of_poly_times)
	+
	+lemma
	+ shows flat_pm_of_poly_times: "flat_pm_of_poly x (p * q) = flat_pm_of_poly x p * flat_pm_of_poly x q"
	+ and flat_pm_of_poly_prod: "flat_pm_of_poly x (prod f I) =
	+ (\<Prod>i\<in>I. flat_pm_of_poly x (f i :: _::comm_ring_1 poly))"
	+ and flat_pm_of_poly_power: "flat_pm_of_poly x (p ^ m) = flat_pm_of_poly x (p::_::comm_ring_1 poly) ^ m"
	+ by (simp_all add: flat_pm_of_poly_def flatten_times pm_of_poly_times flatten_prod pm_of_poly_prod)
	+
	+lemma coeff_poly_of_focus_subset_Polys:
	+ assumes "p \<in> P[X]"
	+ shows "range (poly.coeff (poly_of_focus x p)) \<subseteq> P[X - {x}]"
	+proof -
	+ have "range (poly.coeff (poly_of_focus x p)) \<subseteq> range (lookup (focus {x} p))"
	+ by (auto simp: poly_of_focus_def)
	+ also from assms have "\<dots> \<subseteq> P[X - {x}]" by (rule focus_coeffs_subset_Polys')
	+ finally show ?thesis .
	+qed
	+
	+lemma
	+ shows poly_of_focus_zero [simp]: "poly_of_focus x 0 = 0"
	+ and poly_of_focus_uminus [simp]: "poly_of_focus x (- p) = - poly_of_focus x p"
	+ and poly_of_focus_plus: "poly_of_focus x (p + q) = poly_of_focus x p + poly_of_focus x q"
	+ and poly_of_focus_minus: "poly_of_focus x (p - q) = poly_of_focus x p - poly_of_focus x q"
	+ and poly_of_focus_one [simp]: "poly_of_focus x 1 = 1"
	+ and poly_of_focus_sum: "poly_of_focus x (sum f I) = (\<Sum>i\<in>I. poly_of_focus x (f i))"
	+ by (simp_all add: poly_of_focus_def keys_focus poly_of_pm_plus focus_plus poly_of_pm_minus focus_minus
	+ poly_of_pm_sum focus_sum)
	+
	+lemma poly_of_focus_eq_zero_iff [iff]: "poly_of_focus x p = 0 \<longleftrightarrow> p = 0"
	+ using focus_in_Polys[of "{x}" p]
	+ by (auto simp: poly_of_focus_def poly_of_pm_eq_zero_iff Int_absorb2 dest: PolysD)
	+
	+lemma poly_of_focus_monomial:
	+ "poly_of_focus x (monomial c t) = Polynomial.monom (monomial c (except t {x})) (lookup t x)"
	+ by (simp add: poly_of_focus_def focus_monomial poly_of_pm_monomial PPs_def keys_except lookup_except)
	+
	+lemma
	+ shows poly_of_focus_times: "poly_of_focus x (p * q) = poly_of_focus x p * poly_of_focus x q"
	+ and poly_of_focus_prod: "poly_of_focus x (prod f I) =
	+ (\<Prod>i\<in>I. poly_of_focus x (f i :: _ \<Rightarrow>\<^sub>0 _::comm_semiring_1))"
	+ and poly_of_focus_power: "poly_of_focus x (p ^ m) = poly_of_focus x (p::_ \<Rightarrow>\<^sub>0 _::comm_semiring_1) ^ m"
	+ by (simp_all add: poly_of_focus_def poly_of_pm_times focus_times poly_of_pm_prod focus_prod)
	+
	+lemma flat_pm_of_poly_of_focus [simp]: "flat_pm_of_poly x (poly_of_focus x p) = p"
	+ by (simp add: flat_pm_of_poly_def poly_of_focus_def pm_of_poly_of_pm focus_in_Polys)
	+
	+lemma poly_of_focus_flat_pm_of_poly:
	+ assumes "range (poly.coeff p) \<subseteq> P[- {x}]"
	+ shows "poly_of_focus x (flat_pm_of_poly x p) = p"
	+proof -
	+ from assms have "lookup (pm_of_poly x p) ` keys (pm_of_poly x p) \<subseteq> P[- {x}]"
	+ by (simp add: keys_pm_of_poly image_image) blast
	+ thus ?thesis by (simp add: flat_pm_of_poly_def poly_of_focus_def focus_flatten pm_of_poly_in_Polys)
	+qed
	+
	+lemma flat_pm_of_poly_eq_zeroD:
	+ assumes "flat_pm_of_poly x p = 0" and "range (poly.coeff p) \<subseteq> P[- {x}]"
	+ shows "p = 0"
	+proof -
	+ from assms(2) have "p = poly_of_focus x (flat_pm_of_poly x p)"
	+ by (simp only: poly_of_focus_flat_pm_of_poly)
	+ also have "\<dots> = 0" by (simp add: assms(1))
	+ finally show ?thesis .
	+qed
	+
	+lemma poly_poly_of_focus: "poly (poly_of_focus x p) a = poly_eval (\<lambda>_. a) (focus {x} p)"
	+ by (simp add: poly_of_focus_def poly_eq_poly_eval' focus_in_Polys)
	+
	+corollary poly_poly_of_focus_monomial:
	+ "poly (poly_of_focus x p) (monomial 1 (Poly_Mapping.single x 1)) = (p::_ \<Rightarrow>\<^sub>0 _::comm_semiring_1)"
	+ unfolding poly_poly_of_focus poly_eval_focus by (rule poly_subst_id) simp
	+
	+end (* theory *)
	diff --git a/thys/Nullstellensatz/document/root.bib b/thys/Nullstellensatz/document/root.bib
	new file mode 100755
	--- /dev/null
	+++ b/thys/Nullstellensatz/document/root.bib
	@@ -0,0 +1,10 @@
	+@book{CLO,
	+ author = {David Cox and John Little and Donal O'Shea},
	+ title = {{Ideals, Varieties, and Algorithms}},
	+ publisher = {Springer},
	+ year = {2007},
	+ series = {Undergraduate Texts in Mathematics},
	+ isbn = {978-0-387-35651-8},
	+ doi = {10.1007/978-0-387-35651-8_4},
	+ url = {https://doi.org/10.1007/978-0-387-35651-8_4}
	+}
	diff --git a/thys/Nullstellensatz/document/root.tex b/thys/Nullstellensatz/document/root.tex
	new file mode 100755
	--- /dev/null
	+++ b/thys/Nullstellensatz/document/root.tex
	@@ -0,0 +1,68 @@
	+\documentclass[11pt,a4paper]{article}
	+\usepackage{isabelle,isabellesym,latexsym}
	+
	+% further packages required for unusual symbols (see also
	+% isabellesym.sty), use only when needed
	+
	+\usepackage{amssymb}
	+ %for \<leadsto>, \<box>, \<diamond>, \<sqsupset>, \<mho>, \<Join>,
	+ %\<lhd>, \<lesssim>, \<greatersim>, \<lessapprox>, \<greaterapprox>,
	+ %\<triangleq>, \<yen>, \<lozenge>
	+
	+%\usepackage{eurosym}
	+ %for \<euro>
	+
	+%\usepackage[only,bigsqcap]{stmaryrd}
	+ %for \<Sqinter>
	+
	+%\usepackage{eufrak}
	+ %for \<AA> ... \<ZZ>, \<aa> ... \<zz> (also included in amssymb)
	+
	+%\usepackage{textcomp}
	+ %for \<onequarter>, \<onehalf>, \<threequarters>, \<degree>, \<cent>,
	+ %\<currency>
	+
	+% this should be the last package used
	+\usepackage{pdfsetup}
	+
	+% urls in roman style, theory text in math-similar italics
	+\urlstyle{rm}
	+\isabellestyle{it}
	+
	+% for uniform font size
	+%\renewcommand{\isastyle}{\isastyleminor}
	+
	+
	+\begin{document}
	+
	+\title{Hilbert's Nullstellensatz}
	+\author{Alexander Maletzky\thanks{Funded by the Austrian
	+Science Fund (FWF): grant no. P 29498-N31}}
	+\maketitle
	+
	+\begin{abstract}
	+This entry formalizes Hilbert's Nullstellensatz, an important theorem in algebraic geometry that can be viewed as the generalization of the Fundamental Theorem of Algebra to multivariate polynomials: If a set of (multivariate) polynomials over an algebraically closed field has no common zero, then the ideal it generates is the entire polynomial ring. The formalization proves several equivalent versions of this celebrated theorem: the weak Nullstellensatz, the strong Nullstellensatz (connecting algebraic varieties and radical ideals), and the field-theoretic Nullstellensatz. The formalization follows Chapter~4.1. of \emph{Ideals, Varieties, and Algorithms} by Cox, Little and O'Shea.
	+% https://link.springer.com/book/10.1007/978-0-387-35651-8
	+\end{abstract}
	+
	+\tableofcontents
	+
	+% sane default for proof documents
	+\parindent 0pt\parskip 0.5ex
	+
	+\newpage
	+
	+% generated text of all theories
	+\input{session}
	+
	+% optional bibliography
	+\nocite{CLO}
	+\bibliographystyle{abbrv}
	+\bibliography{root}
	+
	+\end{document}
	+
	+%%% Local Variables:
	+%%% mode: latex
	+%%% TeX-master: t
	+%%% End:
	diff --git a/thys/ROOTS b/thys/ROOTS
	--- a/thys/ROOTS
	+++ b/thys/ROOTS
	@@ -1,475 +1,479 @@
	AODV
	Auto2_HOL
	Auto2_Imperative_HOL
	AVL-Trees
	AWN
	Abortable_Linearizable_Modules
	Abs_Int_ITP2012
	Abstract-Hoare-Logics
	Abstract-Rewriting
	Abstract_Completeness
	Abstract_Soundness
	Affine_Arithmetic
	Aggregation_Algebras
	Akra_Bazzi
	Algebraic_Numbers
	Algebraic_VCs
	Allen_Calculus
	Amortized_Complexity
	AnselmGod
	Applicative_Lifting
	Architectural_Design_Patterns
	ArrowImpossibilityGS
	AutoFocus-Stream
	Automatic_Refinement
	AxiomaticCategoryTheory
	BDD
	BNF_Operations
	Bell_Numbers_Spivey
	Berlekamp_Zassenhaus
	Bernoulli
	Bertrands_Postulate
	BinarySearchTree
	Binding_Syntax_Theory
	Binomial-Heaps
	Binomial-Queues
	BNF_CC
	Bondy
	Boolean_Expression_Checkers
	Bounded_Deducibility_Security
	Buchi_Complementation
	Budan_Fourier
	Buffons_Needle
	Buildings
	BytecodeLogicJmlTypes
	CAVA_Automata
	CAVA_LTL_Modelchecker
	CCS
	CISC-Kernel
	CRDT
	CYK
	CakeML
	Call_Arity
	Card_Equiv_Relations
	Card_Multisets
	Card_Number_Partitions
	Card_Partitions
	Cartan_FP
	Case_Labeling
	Catalan_Numbers
	Category
	Category2
	Category3
	Cauchy
	Cayley_Hamilton
	Certification_Monads
	Chord_Segments
	Circus
	ClockSynchInst
	CofGroups
	Coinductive
	Coinductive_Languages
	Collections
	Comparison_Sort_Lower_Bound
	Compiling-Exceptions-Correctly
	Completeness
	Complx
	ComponentDependencies
	ConcurrentGC
	ConcurrentIMP
	Concurrent_Ref_Alg
	Concurrent_Revisions
	Consensus_Refined
	Constructive_Cryptography
	Constructor_Funs
	Containers
	CoreC++
	Core_DOM
	Count_Complex_Roots
	CryptHOL
	CryptoBasedCompositionalProperties
	DFS_Framework
	DPT-SAT-Solver
	DataRefinementIBP
	Datatype_Order_Generator
	Decl_Sem_Fun_PL
	Decreasing-Diagrams
	Decreasing-Diagrams-II
	Deep_Learning
	Density_Compiler
	Dependent_SIFUM_Refinement
	Dependent_SIFUM_Type_Systems
	Depth-First-Search
	Derangements
	Deriving
	Descartes_Sign_Rule
	Dict_Construction
	Differential_Dynamic_Logic
	Dijkstra_Shortest_Path
	Diophantine_Eqns_Lin_Hom
	Dirichlet_L
	Dirichlet_Series
	Discrete_Summation
	DiscretePricing
	DiskPaxos
	DynamicArchitectures
	Dynamic_Tables
	E_Transcendental
	Echelon_Form
	EdmondsKarp_Maxflow
	Efficient-Mergesort
	Elliptic_Curves_Group_Law
	Encodability_Process_Calculi
	Epistemic_Logic
	Ergodic_Theory
	Error_Function
	Euler_MacLaurin
	Euler_Partition
	Example-Submission
	Factored_Transition_System_Bounding
	Farkas
	FFT
	FLP
	FOL-Fitting
	FOL_Harrison
	Falling_Factorial_Sum
	FeatherweightJava
	Featherweight_OCL
	Fermat3_4
	FileRefinement
	FinFun
	Finger-Trees
	Finite_Automata_HF
	First_Order_Terms
	First_Welfare_Theorem
	Fishburn_Impossibility
	Fisher_Yates
	Flow_Networks
	Floyd_Warshall
	Flyspeck-Tame
	FocusStreamsCaseStudies
	Formal_SSA
	Formula_Derivatives
	Free-Boolean-Algebra
	Free-Groups
	FunWithFunctions
	FunWithTilings
	Functional-Automata
	Functional_Ordered_Resolution_Prover
	GPU_Kernel_PL
	Gabow_SCC
	Game_Based_Crypto
	Gauss-Jordan-Elim-Fun
	Gauss_Jordan
	GenClock
	General-Triangle
	Generic_Deriving
	GewirthPGCProof
	Girth_Chromatic
	GoedelGod
	GraphMarkingIBP
	Graph_Saturation
	Graph_Theory
	Green
	Groebner_Bases
	+Groebner_Macaulay
	Gromov_Hyperbolicity
	Group-Ring-Module
	HOL-CSP
	HOLCF-Prelude
	HRB-Slicing
	Heard_Of
	HereditarilyFinite
	Hermite
	Hidden_Markov_Models
	Higher_Order_Terms
	Hoare_Time
	HotelKeyCards
	Huffman
	Hybrid_Multi_Lane_Spatial_Logic
	HyperCTL
	IEEE_Floating_Point
	IMAP-CRDT
	IMP2
	+IMP2_Binary_Heap
	IP_Addresses
	Imperative_Insertion_Sort
	Impossible_Geometry
	Incompleteness
	Incredible_Proof_Machine
	Inductive_Confidentiality
	InfPathElimination
	InformationFlowSlicing
	InformationFlowSlicing_Inter
	Integration
	Iptables_Semantics
	Irrationality_J_Hancl
	Isabelle_Meta_Model
	Jinja
	JinjaThreads
	JiveDataStoreModel
	Jordan_Hoelder
	Jordan_Normal_Form
	KAD
	KAT_and_DRA
	KBPs
	KD_Tree
	Key_Agreement_Strong_Adversaries
	Kleene_Algebra
	Knot_Theory
	Knuth_Morris_Pratt
	Koenigsberg_Friendship
	Kruskal
	Kuratowski_Closure_Complement
	LLL_Basis_Reduction
	LLL_Factorization
	LOFT
	LTL
	LTL_to_DRA
	LTL_to_GBA
	LTL_Master_Theorem
	Lam-ml-Normalization
	LambdaAuth
	LambdaMu
	Lambda_Free_KBOs
	Lambda_Free_RPOs
	Landau_Symbols
	Latin_Square
	LatticeProperties
	Lambda_Free_EPO
	Launchbury
	Lazy-Lists-II
	Lazy_Case
	Lehmer
	Lifting_Definition_Option
	LightweightJava
	LinearQuantifierElim
	+Linear_Inequalities
	Linear_Recurrences
	Liouville_Numbers
	List-Index
	List-Infinite
	List_Interleaving
	List_Inversions
	List_Update
	LocalLexing
	Localization_Ring
	Locally-Nameless-Sigma
	Lowe_Ontological_Argument
	Lower_Semicontinuous
	Lp
	MFMC_Countable
	MSO_Regex_Equivalence
	Markov_Models
	Marriage
	Mason_Stothers
	Matrix
	Matrix_Tensor
	Matroids
	Max-Card-Matching
	Median_Of_Medians_Selection
	Menger
	MiniML
	Minimal_SSA
	Minkowskis_Theorem
	Minsky_Machines
	Modal_Logics_for_NTS
	Modular_Assembly_Kit_Security
	Monad_Memo_DP
	Monad_Normalisation
	MonoBoolTranAlgebra
	MonoidalCategory
	Monomorphic_Monad
	MuchAdoAboutTwo
	Multirelations
	Multi_Party_Computation
	Myhill-Nerode
	Name_Carrying_Type_Inference
	Nat-Interval-Logic
	Native_Word
	Nested_Multisets_Ordinals
	Network_Security_Policy_Verification
	Neumann_Morgenstern_Utility
	No_FTL_observers
	Nominal2
	Noninterference_CSP
	Noninterference_Concurrent_Composition
	Noninterference_Generic_Unwinding
	Noninterference_Inductive_Unwinding
	Noninterference_Ipurge_Unwinding
	Noninterference_Sequential_Composition
	NormByEval
	+Nullstellensatz
	Octonions
	Open_Induction
	OpSets
	Optics
	Optimal_BST
	Orbit_Stabiliser
	Order_Lattice_Props
	Ordered_Resolution_Prover
	Ordinal
	Ordinals_and_Cardinals
	Ordinary_Differential_Equations
	PCF
	PLM
	Pell
	POPLmark-deBruijn
	PSemigroupsConvolution
	Pairing_Heap
	Paraconsistency
	Parity_Game
	Partial_Function_MR
	Partial_Order_Reduction
	Password_Authentication_Protocol
	Perfect-Number-Thm
	Perron_Frobenius
	Pi_Calculus
	Pi_Transcendental
	Planarity_Certificates
	Polynomial_Factorization
	Polynomial_Interpolation
	Polynomials
	Pop_Refinement
	Posix-Lexing
	Possibilistic_Noninterference
	Pratt_Certificate
	Presburger-Automata
	Prime_Distribution_Elementary
	Prime_Harmonic_Series
	Prime_Number_Theorem
	Priority_Queue_Braun
	Probabilistic_Noninterference
	Probabilistic_Prime_Tests
	Probabilistic_System_Zoo
	Probabilistic_Timed_Automata
	Probabilistic_While
	Projective_Geometry
	Program-Conflict-Analysis
	Promela
	Proof_Strategy_Language
	PropResPI
	Propositional_Proof_Systems
	Prpu_Maxflow
	PseudoHoops
	Psi_Calculi
	Ptolemys_Theorem
	QHLProver
	QR_Decomposition
	Quantales
	Quaternions
	Quick_Sort_Cost
	RIPEMD-160-SPARK
	ROBDD
	RSAPSS
	Ramsey-Infinite
	Random_BSTs
	Randomised_BSTs
	Random_Graph_Subgraph_Threshold
	Randomised_Social_Choice
	Rank_Nullity_Theorem
	Real_Impl
	Recursion-Theory-I
	Refine_Imperative_HOL
	Refine_Monadic
	RefinementReactive
	Regex_Equivalence
	Regular-Sets
	Regular_Algebras
	Relation_Algebra
	Rep_Fin_Groups
	Residuated_Lattices
	Resolution_FOL
	Rewriting_Z
	Ribbon_Proofs
	Robbins-Conjecture
	Root_Balanced_Tree
	Routing
	Roy_Floyd_Warshall
	Safe_OCL
	SATSolverVerification
	SDS_Impossibility
	SIFPL
	SIFUM_Type_Systems
	SPARCv8
	Secondary_Sylow
	Security_Protocol_Refinement
	Selection_Heap_Sort
	SenSocialChoice
	Separata
	Separation_Algebra
	Separation_Logic_Imperative_HOL
	SequentInvertibility
	Shivers-CFA
	ShortestPath
	Show
	Signature_Groebner
	Simpl
	Simple_Firewall
	Simplex
	Skew_Heap
	Slicing
	Smooth_Manifolds
	Sort_Encodings
	Source_Coding_Theorem
	Special_Function_Bounds
	Splay_Tree
	Sqrt_Babylonian
	Stable_Matching
	Statecharts
	Stern_Brocot
	Stewart_Apollonius
	Stirling_Formula
	Stochastic_Matrices
	Stone_Algebras
	Stone_Kleene_Relation_Algebras
	Stone_Relation_Algebras
	Store_Buffer_Reduction
	Stream-Fusion
	Stream_Fusion_Code
	Strong_Security
	Sturm_Sequences
	Sturm_Tarski
	Stuttering_Equivalence
	Subresultants
	SumSquares
	SuperCalc
	Surprise_Paradox
	Symmetric_Polynomials
	TLA
	Tail_Recursive_Functions
	Tarskis_Geometry
	Taylor_Models
	Timed_Automata
	Topology
	TortoiseHare
	Transcendence_Series_Hancl_Rucki
	Transformer_Semantics
	Transition_Systems_and_Automata
	Transitive-Closure
	Transitive-Closure-II
	Treaps
	Tree-Automata
	Tree_Decomposition
	Triangle
	Trie
	Twelvefold_Way
	Tycon
	Types_Tableaus_and_Goedels_God
	Universal_Turing_Machine
	UPF
	UPF_Firewall
	UpDown_Scheme
	UTP
	Valuation
	VectorSpace
	Verified-Prover
	VerifyThis2018
	Vickrey_Clarke_Groves
	VolpanoSmith
	WHATandWHERE_Security
	WebAssembly
	Weight_Balanced_Trees
	Well_Quasi_Orders
	Winding_Number_Eval
	Word_Lib
	WorkerWrapper
	XML
	Zeta_Function
	pGCL
	diff --git a/web/entries/AODV.html b/web/entries/AODV.html
	--- a/web/entries/AODV.html
	+++ b/web/entries/AODV.html
	@@ -1,229 +1,234 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Loop freedom of the (untimed) AODV routing protocol - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>oop

	freedom

	of

	the

	<font class="first">(</font>untimed)

	<font class="first">A</font>ODV

	routing

	protocol

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Loop freedom of the (untimed) AODV routing protocol</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.tbrk.org">Timothy Bourke</a> and
	<a href="http://www.hoefner-online.de/">Peter Höfner</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-10-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	The Ad hoc On-demand Distance Vector (AODV) routing protocol allows
	the nodes in a Mobile Ad hoc Network (MANET) or a Wireless Mesh
	Network (WMN) to know where to forward data packets. Such a protocol
	is ‘loop free’ if it never leads to routing decisions that forward
	packets in circles.
	<p>
	This development mechanises an existing pen-and-paper proof of loop
	freedom of AODV. The protocol is modelled in the Algebra of
	Wireless Networks (AWN), which is the subject of an earlier paper
	and AFP mechanization. The proof relies on a novel compositional
	approach for lifting invariants to networks of nodes.
	</p><p>
	We exploit the mechanization to analyse several variants of AODV and
	show that Isabelle/HOL can re-establish most proof obligations
	automatically and identify exactly the steps that are no longer valid.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{AODV-AFP,
	author = {Timothy Bourke and Peter Höfner},
	title = {Loop freedom of the (untimed) AODV routing protocol},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/AODV.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="AWN.html">AWN</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AODV/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/AODV/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AODV/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-AODV-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-AODV-2018-08-16.tar.gz">
	+ afp-AODV-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-AODV-2017-10-10.tar.gz">
	afp-AODV-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-AODV-2016-12-17.tar.gz">
	afp-AODV-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-AODV-2016-02-22.tar.gz">
	afp-AODV-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-AODV-2015-05-27.tar.gz">
	afp-AODV-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-AODV-2014-11-03.tar.gz">
	afp-AODV-2014-11-03.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-AODV-2014-11-01.tar.gz">
	afp-AODV-2014-11-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/AVL-Trees.html b/web/entries/AVL-Trees.html
	--- a/web/entries/AVL-Trees.html
	+++ b/web/entries/AVL-Trees.html
	@@ -1,272 +1,277 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>AVL Trees - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>VL

	<font class="first">T</font>rees

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">AVL Trees</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a> and
	Cornelia Pusch
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-03-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Two formalizations of AVL trees with room for extensions. The first formalization is monolithic and shorter, the second one in two stages, longer and a bit simpler. The final implementation is the same. If you are interested in developing this further, please contact <tt>gerwin.klein@nicta.com.au</tt>.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2011-04-11]: Ondrej Kuncar added delete function</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{AVL-Trees-AFP,
	author = {Tobias Nipkow and Cornelia Pusch},
	title = {AVL Trees},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/AVL-Trees.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AVL-Trees/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/AVL-Trees/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AVL-Trees/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-AVL-Trees-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-AVL-Trees-2018-08-16.tar.gz">
	+ afp-AVL-Trees-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-AVL-Trees-2017-10-10.tar.gz">
	afp-AVL-Trees-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-AVL-Trees-2016-12-17.tar.gz">
	afp-AVL-Trees-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-AVL-Trees-2016-02-22.tar.gz">
	afp-AVL-Trees-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-AVL-Trees-2015-05-27.tar.gz">
	afp-AVL-Trees-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-AVL-Trees-2014-08-28.tar.gz">
	afp-AVL-Trees-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-AVL-Trees-2013-12-11.tar.gz">
	afp-AVL-Trees-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-AVL-Trees-2013-11-17.tar.gz">
	afp-AVL-Trees-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-AVL-Trees-2013-02-16.tar.gz">
	afp-AVL-Trees-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-AVL-Trees-2012-05-24.tar.gz">
	afp-AVL-Trees-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-AVL-Trees-2011-10-11.tar.gz">
	afp-AVL-Trees-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-AVL-Trees-2011-02-11.tar.gz">
	afp-AVL-Trees-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-AVL-Trees-2010-06-30.tar.gz">
	afp-AVL-Trees-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-AVL-Trees-2009-12-12.tar.gz">
	afp-AVL-Trees-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-AVL-Trees-2009-04-29.tar.gz">
	afp-AVL-Trees-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-AVL-Trees-2008-06-10.tar.gz">
	afp-AVL-Trees-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-AVL-Trees-2007-11-27.tar.gz">
	afp-AVL-Trees-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-AVL-Trees-2005-10-14.tar.gz">
	afp-AVL-Trees-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-AVL-Trees-2004-05-21.tar.gz">
	afp-AVL-Trees-2004-05-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-AVL-Trees-2004-04-20.tar.gz">
	afp-AVL-Trees-2004-04-20.tar.gz
	</a>
	</li>
	<li>Isabelle 2003:
	<a href="../release/afp-AVL-Trees-2004-03-19.tar.gz">
	afp-AVL-Trees-2004-03-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/AWN.html b/web/entries/AWN.html
	--- a/web/entries/AWN.html
	+++ b/web/entries/AWN.html
	@@ -1,230 +1,235 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Mechanization of the Algebra for Wireless Networks (AWN) - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>echanization

	of

	the

	<font class="first">A</font>lgebra

	for

	<font class="first">W</font>ireless

	<font class="first">N</font>etworks

	<font class="first">(</font>AWN)

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Mechanization of the Algebra for Wireless Networks (AWN)</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.tbrk.org">Timothy Bourke</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-03-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	AWN is a process algebra developed for modelling and analysing
	protocols for Mobile Ad hoc Networks (MANETs) and Wireless Mesh
	Networks (WMNs). AWN models comprise five distinct layers:
	sequential processes, local parallel compositions, nodes, partial
	networks, and complete networks.</p>
	<p>
	This development mechanises the original operational semantics of
	AWN and introduces a variant 'open' operational semantics that
	enables the compositional statement and proof of invariants across
	distinct network nodes. It supports labels (for weakening
	invariants) and (abstract) data state manipulations. A framework for
	compositional invariant proofs is developed, including a tactic
	(inv_cterms) for inductive invariant proofs of sequential processes,
	lifting rules for the open versions of the higher layers, and a rule
	for transferring lifted properties back to the standard semantics. A
	notion of 'control terms' reduces proof obligations to the subset of
	subterms that act directly (in contrast to operators for combining
	terms and joining processes).</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{AWN-AFP,
	author = {Timothy Bourke},
	title = {Mechanization of the Algebra for Wireless Networks (AWN)},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/AWN.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="AODV.html">AODV</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AWN/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/AWN/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AWN/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-AWN-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-AWN-2018-08-16.tar.gz">
	+ afp-AWN-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-AWN-2017-10-10.tar.gz">
	afp-AWN-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-AWN-2016-12-17.tar.gz">
	afp-AWN-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-AWN-2016-02-22.tar.gz">
	afp-AWN-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-AWN-2015-05-27.tar.gz">
	afp-AWN-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-AWN-2014-08-28.tar.gz">
	afp-AWN-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-AWN-2014-03-15.tar.gz">
	afp-AWN-2014-03-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Abortable_Linearizable_Modules.html b/web/entries/Abortable_Linearizable_Modules.html
	--- a/web/entries/Abortable_Linearizable_Modules.html
	+++ b/web/entries/Abortable_Linearizable_Modules.html
	@@ -1,232 +1,237 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Abortable Linearizable Modules - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>bortable

	<font class="first">L</font>inearizable

	<font class="first">M</font>odules

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Abortable Linearizable Modules</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Rachid Guerraoui (rachid /dot/ guerraoui /at/ epfl /dot/ ch),
	<a href="http://lara.epfl.ch/~kuncak/">Viktor Kuncak</a> and
	Giuliano Losa (giuliano /dot/ losa /at/ epfl /dot/ ch)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-03-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We define the Abortable Linearizable Module automaton (ALM for short)
	and prove its key composition property using the IOA theory of
	HOLCF. The ALM is at the heart of the Speculative Linearizability
	framework. This framework simplifies devising correct speculative
	algorithms by enabling their decomposition into independent modules
	that can be analyzed and proved correct in isolation. It is
	particularly useful when working in a distributed environment, where
	the need to tolerate faults and asynchrony has made current
	monolithic protocols so intricate that it is no longer tractable to
	check their correctness. Our theory contains a typical example of a
	refinement proof in the I/O-automata framework of Lynch and Tuttle.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Abortable_Linearizable_Modules-AFP,
	author = {Rachid Guerraoui and Viktor Kuncak and Giuliano Losa},
	title = {Abortable Linearizable Modules},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Abortable_Linearizable_Modules.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abortable_Linearizable_Modules/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Abortable_Linearizable_Modules/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abortable_Linearizable_Modules/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Abortable_Linearizable_Modules-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Abortable_Linearizable_Modules-2018-08-16.tar.gz">
	+ afp-Abortable_Linearizable_Modules-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Abortable_Linearizable_Modules-2017-10-10.tar.gz">
	afp-Abortable_Linearizable_Modules-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Abortable_Linearizable_Modules-2016-12-17.tar.gz">
	afp-Abortable_Linearizable_Modules-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Abortable_Linearizable_Modules-2016-02-22.tar.gz">
	afp-Abortable_Linearizable_Modules-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Abortable_Linearizable_Modules-2015-05-27.tar.gz">
	afp-Abortable_Linearizable_Modules-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Abortable_Linearizable_Modules-2014-08-28.tar.gz">
	afp-Abortable_Linearizable_Modules-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Abortable_Linearizable_Modules-2013-12-11.tar.gz">
	afp-Abortable_Linearizable_Modules-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Abortable_Linearizable_Modules-2013-11-17.tar.gz">
	afp-Abortable_Linearizable_Modules-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Abortable_Linearizable_Modules-2013-02-16.tar.gz">
	afp-Abortable_Linearizable_Modules-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Abortable_Linearizable_Modules-2012-05-24.tar.gz">
	afp-Abortable_Linearizable_Modules-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Abortable_Linearizable_Modules-2012-03-02.tar.gz">
	afp-Abortable_Linearizable_Modules-2012-03-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Abs_Int_ITP2012.html b/web/entries/Abs_Int_ITP2012.html
	--- a/web/entries/Abs_Int_ITP2012.html
	+++ b/web/entries/Abs_Int_ITP2012.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Abstract Interpretation of Annotated Commands - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>bstract

	<font class="first">I</font>nterpretation

	of

	<font class="first">A</font>nnotated

	<font class="first">C</font>ommands

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Abstract Interpretation of Annotated Commands</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-11-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This is the Isabelle formalization of the material decribed in the
	eponymous <a href="https://doi.org/10.1007/978-3-642-32347-8_9">ITP 2012 paper</a>.
	It develops a generic abstract interpreter for a
	while-language, including widening and narrowing. The collecting
	semantics and the abstract interpreter operate on annotated commands:
	the program is represented as a syntax tree with the semantic
	information directly embedded, without auxiliary labels. The aim of
	the formalization is simplicity, not efficiency or
	precision. This is motivated by the inclusion of the material in a
	theorem prover based course on semantics. A similar (but more
	polished) development is covered in the book
	<a href="https://doi.org/10.1007/978-3-319-10542-0">Concrete Semantics</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Abs_Int_ITP2012-AFP,
	author = {Tobias Nipkow},
	title = {Abstract Interpretation of Annotated Commands},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Abs_Int_ITP2012.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abs_Int_ITP2012/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Abs_Int_ITP2012/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abs_Int_ITP2012/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Abs_Int_ITP2012-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Abs_Int_ITP2012-2018-08-16.tar.gz">
	+ afp-Abs_Int_ITP2012-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Abs_Int_ITP2012-2017-10-10.tar.gz">
	afp-Abs_Int_ITP2012-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Abs_Int_ITP2012-2016-12-17.tar.gz">
	afp-Abs_Int_ITP2012-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Abstract-Hoare-Logics.html b/web/entries/Abstract-Hoare-Logics.html
	--- a/web/entries/Abstract-Hoare-Logics.html
	+++ b/web/entries/Abstract-Hoare-Logics.html
	@@ -1,249 +1,254 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Abstract Hoare Logics - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>bstract

	<font class="first">H</font>oare

	<font class="first">L</font>ogics

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Abstract Hoare Logics</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2006-08-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">These therories describe Hoare logics for a number of imperative language constructs, from while-loops to mutually recursive procedures. Both partial and total correctness are treated. In particular a proof system for total correctness of recursive procedures in the presence of unbounded nondeterminism is presented.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Abstract-Hoare-Logics-AFP,
	author = {Tobias Nipkow},
	title = {Abstract Hoare Logics},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2006,
	note = {\url{http://isa-afp.org/entries/Abstract-Hoare-Logics.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abstract-Hoare-Logics/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Abstract-Hoare-Logics/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abstract-Hoare-Logics/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Abstract-Hoare-Logics-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Abstract-Hoare-Logics-2018-08-16.tar.gz">
	+ afp-Abstract-Hoare-Logics-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Abstract-Hoare-Logics-2017-10-10.tar.gz">
	afp-Abstract-Hoare-Logics-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Abstract-Hoare-Logics-2016-12-17.tar.gz">
	afp-Abstract-Hoare-Logics-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Abstract-Hoare-Logics-2016-02-22.tar.gz">
	afp-Abstract-Hoare-Logics-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Abstract-Hoare-Logics-2015-05-27.tar.gz">
	afp-Abstract-Hoare-Logics-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Abstract-Hoare-Logics-2014-08-28.tar.gz">
	afp-Abstract-Hoare-Logics-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Abstract-Hoare-Logics-2013-12-11.tar.gz">
	afp-Abstract-Hoare-Logics-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Abstract-Hoare-Logics-2013-11-17.tar.gz">
	afp-Abstract-Hoare-Logics-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Abstract-Hoare-Logics-2013-02-16.tar.gz">
	afp-Abstract-Hoare-Logics-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Abstract-Hoare-Logics-2012-05-24.tar.gz">
	afp-Abstract-Hoare-Logics-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Abstract-Hoare-Logics-2011-10-11.tar.gz">
	afp-Abstract-Hoare-Logics-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Abstract-Hoare-Logics-2011-02-11.tar.gz">
	afp-Abstract-Hoare-Logics-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Abstract-Hoare-Logics-2010-06-30.tar.gz">
	afp-Abstract-Hoare-Logics-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Abstract-Hoare-Logics-2009-12-12.tar.gz">
	afp-Abstract-Hoare-Logics-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Abstract-Hoare-Logics-2009-04-29.tar.gz">
	afp-Abstract-Hoare-Logics-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Abstract-Hoare-Logics-2008-06-10.tar.gz">
	afp-Abstract-Hoare-Logics-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Abstract-Hoare-Logics-2007-11-27.tar.gz">
	afp-Abstract-Hoare-Logics-2007-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Abstract-Rewriting.html b/web/entries/Abstract-Rewriting.html
	--- a/web/entries/Abstract-Rewriting.html
	+++ b/web/entries/Abstract-Rewriting.html
	@@ -1,254 +1,259 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Abstract Rewriting - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>bstract

	<font class="first">R</font>ewriting

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Abstract Rewriting</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-06-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present an Isabelle formalization of abstract rewriting (see, e.g.,
	the book by Baader and Nipkow). First, we define standard relations like
	<i>joinability</i>, <i>meetability</i>, <i>conversion</i>, etc. Then, we
	formalize important properties of abstract rewrite systems, e.g.,
	confluence and strong normalization. Our main concern is on strong
	normalization, since this formalization is the basis of <a
	href="http://cl-informatik.uibk.ac.at/software/ceta">CeTA</a> (which is
	mainly about strong normalization of term rewrite systems). Hence lemmas
	involving strong normalization constitute by far the biggest part of this
	theory. One of those is Newman's lemma.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2010-09-17]: Added theories defining several (ordered)
	semirings related to strong normalization and giving some standard
	instances. <br>
	[2013-10-16]: Generalized delta-orders from rationals to Archimedean fields.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Abstract-Rewriting-AFP,
	author = {Christian Sternagel and René Thiemann},
	title = {Abstract Rewriting},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Abstract-Rewriting.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Regular-Sets.html">Regular-Sets</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Decreasing-Diagrams.html">Decreasing-Diagrams</a>, <a href="Decreasing-Diagrams-II.html">Decreasing-Diagrams-II</a>, <a href="First_Order_Terms.html">First_Order_Terms</a>, <a href="Matrix.html">Matrix</a>, <a href="Minsky_Machines.html">Minsky_Machines</a>, <a href="Myhill-Nerode.html">Myhill-Nerode</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a>, <a href="Polynomials.html">Polynomials</a>, <a href="Rewriting_Z.html">Rewriting_Z</a>, <a href="Well_Quasi_Orders.html">Well_Quasi_Orders</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abstract-Rewriting/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Abstract-Rewriting/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abstract-Rewriting/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Abstract-Rewriting-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Abstract-Rewriting-2018-08-16.tar.gz">
	+ afp-Abstract-Rewriting-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Abstract-Rewriting-2017-10-10.tar.gz">
	afp-Abstract-Rewriting-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Abstract-Rewriting-2016-12-17.tar.gz">
	afp-Abstract-Rewriting-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Abstract-Rewriting-2016-02-22.tar.gz">
	afp-Abstract-Rewriting-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Abstract-Rewriting-2015-05-27.tar.gz">
	afp-Abstract-Rewriting-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Abstract-Rewriting-2014-08-28.tar.gz">
	afp-Abstract-Rewriting-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Abstract-Rewriting-2013-12-11.tar.gz">
	afp-Abstract-Rewriting-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Abstract-Rewriting-2013-11-17.tar.gz">
	afp-Abstract-Rewriting-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Abstract-Rewriting-2013-02-16.tar.gz">
	afp-Abstract-Rewriting-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Abstract-Rewriting-2012-05-24.tar.gz">
	afp-Abstract-Rewriting-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Abstract-Rewriting-2011-10-11.tar.gz">
	afp-Abstract-Rewriting-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Abstract-Rewriting-2011-02-11.tar.gz">
	afp-Abstract-Rewriting-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Abstract-Rewriting-2010-06-30.tar.gz">
	afp-Abstract-Rewriting-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Abstract-Rewriting-2010-06-17.tar.gz">
	afp-Abstract-Rewriting-2010-06-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Abstract_Completeness.html b/web/entries/Abstract_Completeness.html
	--- a/web/entries/Abstract_Completeness.html
	+++ b/web/entries/Abstract_Completeness.html
	@@ -1,204 +1,209 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Abstract Completeness - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>bstract

	<font class="first">C</font>ompleteness

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Abstract Completeness</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl),
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk) and
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-04-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">A formalization of an abstract property of possibly infinite derivation trees (modeled by a codatatype), representing the core of a proof (in Beth/Hintikka style) of the first-order logic completeness theorem, independent of the concrete syntax or inference rules. This work is described in detail in the IJCAR 2014 publication by the authors.
	The abstract proof can be instantiated for a wide range of Gentzen and tableau systems as well as various flavors of FOL---e.g., with or without predicates, equality, or sorts. Here, we give only a toy example instantiation with classical propositional logic. A more serious instance---many-sorted FOL with equality---is described elsewhere [Blanchette and Popescu, FroCoS 2013].</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Abstract_Completeness-AFP,
	author = {Jasmin Christian Blanchette and Andrei Popescu and Dmitriy Traytel},
	title = {Abstract Completeness},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Abstract_Completeness.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Collections.html">Collections</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Abstract_Soundness.html">Abstract_Soundness</a>, <a href="Incredible_Proof_Machine.html">Incredible_Proof_Machine</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abstract_Completeness/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Abstract_Completeness/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abstract_Completeness/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Abstract_Completeness-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Abstract_Completeness-2018-08-16.tar.gz">
	+ afp-Abstract_Completeness-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Abstract_Completeness-2017-10-10.tar.gz">
	afp-Abstract_Completeness-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Abstract_Completeness-2016-12-17.tar.gz">
	afp-Abstract_Completeness-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Abstract_Completeness-2016-02-22.tar.gz">
	afp-Abstract_Completeness-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Abstract_Completeness-2015-05-27.tar.gz">
	afp-Abstract_Completeness-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Abstract_Completeness-2014-08-28.tar.gz">
	afp-Abstract_Completeness-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Abstract_Completeness-2014-04-16.tar.gz">
	afp-Abstract_Completeness-2014-04-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Abstract_Soundness.html b/web/entries/Abstract_Soundness.html
	--- a/web/entries/Abstract_Soundness.html
	+++ b/web/entries/Abstract_Soundness.html
	@@ -1,189 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Abstract Soundness - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>bstract

	<font class="first">S</font>oundness

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Abstract Soundness</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl),
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk) and
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-02-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	A formalized coinductive account of the abstract development of
	Brotherston, Gorogiannis, and Petersen [APLAS 2012], in a slightly
	more general form since we work with arbitrary infinite proofs, which
	may be acyclic. This work is described in detail in an article by the
	authors, published in 2017 in the <em>Journal of Automated
	Reasoning</em>. The abstract proof can be instantiated for
	various formalisms, including first-order logic with inductive
	predicates.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Abstract_Soundness-AFP,
	author = {Jasmin Christian Blanchette and Andrei Popescu and Dmitriy Traytel},
	title = {Abstract Soundness},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Abstract_Soundness.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract_Completeness.html">Abstract_Completeness</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abstract_Soundness/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Abstract_Soundness/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Abstract_Soundness/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Abstract_Soundness-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Abstract_Soundness-2018-08-16.tar.gz">
	+ afp-Abstract_Soundness-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Abstract_Soundness-2017-10-10.tar.gz">
	afp-Abstract_Soundness-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Abstract_Soundness-2017-02-13.tar.gz">
	afp-Abstract_Soundness-2017-02-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Affine_Arithmetic.html b/web/entries/Affine_Arithmetic.html
	--- a/web/entries/Affine_Arithmetic.html
	+++ b/web/entries/Affine_Arithmetic.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Affine Arithmetic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>ffine

	<font class="first">A</font>rithmetic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Affine Arithmetic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-02-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We give a formalization of affine forms as abstract representations of zonotopes.
	We provide affine operations as well as overapproximations of some non-affine operations like multiplication and division.
	Expressions involving those operations can automatically be turned into (executable) functions approximating the original
	expression in affine arithmetic.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-01-31]: added algorithm for zonotope/hyperplane intersection<br>
	[2017-09-20]: linear approximations for all symbols from the floatarith data
	type</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Affine_Arithmetic-AFP,
	author = {Fabian Immler},
	title = {Affine Arithmetic},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Affine_Arithmetic.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Deriving.html">Deriving</a>, <a href="List-Index.html">List-Index</a>, <a href="Show.html">Show</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a>, <a href="Taylor_Models.html">Taylor_Models</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Affine_Arithmetic/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Affine_Arithmetic/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Affine_Arithmetic/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Affine_Arithmetic-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Affine_Arithmetic-2018-08-16.tar.gz">
	+ afp-Affine_Arithmetic-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Affine_Arithmetic-2017-10-10.tar.gz">
	afp-Affine_Arithmetic-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Affine_Arithmetic-2016-12-17.tar.gz">
	afp-Affine_Arithmetic-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Affine_Arithmetic-2016-02-22.tar.gz">
	afp-Affine_Arithmetic-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Affine_Arithmetic-2015-05-27.tar.gz">
	afp-Affine_Arithmetic-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Affine_Arithmetic-2014-08-28.tar.gz">
	afp-Affine_Arithmetic-2014-08-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Aggregation_Algebras.html b/web/entries/Aggregation_Algebras.html
	--- a/web/entries/Aggregation_Algebras.html
	+++ b/web/entries/Aggregation_Algebras.html
	@@ -1,173 +1,179 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Aggregation Algebras - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>ggregation

	<font class="first">A</font>lgebras

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Aggregation Algebras</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-09-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We develop algebras for aggregation and minimisation for weight
	matrices and for edge weights in graphs. We verify the correctness of
	Prim's and Kruskal's minimum spanning tree algorithms based
	on these algebras. We also show numerous instances of these algebras
	based on linearly ordered commutative semigroups.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Aggregation_Algebras-AFP,
	author = {Walter Guttmann},
	title = {Aggregation Algebras},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Aggregation_Algebras.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Stone_Kleene_Relation_Algebras.html">Stone_Kleene_Relation_Algebras</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Aggregation_Algebras/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Aggregation_Algebras/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Aggregation_Algebras/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Aggregation_Algebras-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Aggregation_Algebras-2018-09-16.tar.gz">
	+ afp-Aggregation_Algebras-2018-09-16.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Akra_Bazzi.html b/web/entries/Akra_Bazzi.html
	--- a/web/entries/Akra_Bazzi.html
	+++ b/web/entries/Akra_Bazzi.html
	@@ -1,213 +1,218 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Akra-Bazzi theorem and the Master theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">A</font>kra-Bazzi

	theorem

	and

	the

	<font class="first">M</font>aster

	theorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Akra-Bazzi theorem and the Master theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-07-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This article contains a formalisation of the Akra-Bazzi method
	based on a proof by Leighton. It is a generalisation of the well-known
	Master Theorem for analysing the complexity of Divide & Conquer algorithms.
	We also include a generalised version of the Master theorem based on the
	Akra-Bazzi theorem, which is easier to apply than the Akra-Bazzi theorem
	itself.
	<p>
	Some proof methods that facilitate applying the Master theorem are also
	included. For a more detailed explanation of the formalisation and the
	proof methods, see the accompanying paper (publication forthcoming).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Akra_Bazzi-AFP,
	author = {Manuel Eberl},
	title = {The Akra-Bazzi theorem and the Master theorem},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Akra_Bazzi.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Landau_Symbols.html">Landau_Symbols</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Akra_Bazzi/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Akra_Bazzi/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Akra_Bazzi/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Akra_Bazzi-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Akra_Bazzi-2018-08-16.tar.gz">
	+ afp-Akra_Bazzi-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Akra_Bazzi-2017-10-10.tar.gz">
	afp-Akra_Bazzi-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Akra_Bazzi-2016-12-17.tar.gz">
	afp-Akra_Bazzi-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Akra_Bazzi-2016-02-22.tar.gz">
	afp-Akra_Bazzi-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Akra_Bazzi-2015-07-24.tar.gz">
	afp-Akra_Bazzi-2015-07-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Akra_Bazzi-2015-07-15.tar.gz">
	afp-Akra_Bazzi-2015-07-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Algebraic_Numbers.html b/web/entries/Algebraic_Numbers.html
	--- a/web/entries/Algebraic_Numbers.html
	+++ b/web/entries/Algebraic_Numbers.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Algebraic Numbers in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>lgebraic

	<font class="first">N</font>umbers

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Algebraic Numbers in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>,
	Akihisa Yamada (ayamada /at/ trs /dot/ cm /dot/ is /dot/ nagoya-u /dot/ ac /dot/ jp) and
	<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	</p><p>
	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.
	</p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2016-01-29]: Split off Polynomial Interpolation and Polynomial Factorization<br>
	[2017-04-16]: Use certified Berlekamp-Zassenhaus factorization, use subresultant algorithm for computing resultants, improved bisection algorithm</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Algebraic_Numbers-AFP,
	author = {René Thiemann and Akihisa Yamada and Sebastiaan Joosten},
	title = {Algebraic Numbers in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Algebraic_Numbers.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a>, <a href="Sturm_Sequences.html">Sturm_Sequences</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Linear_Recurrences.html">Linear_Recurrences</a>, <a href="LLL_Basis_Reduction.html">LLL_Basis_Reduction</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Algebraic_Numbers/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Algebraic_Numbers/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Algebraic_Numbers/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Algebraic_Numbers-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Algebraic_Numbers-2018-08-16.tar.gz">
	+ afp-Algebraic_Numbers-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Algebraic_Numbers-2017-10-10.tar.gz">
	afp-Algebraic_Numbers-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Algebraic_Numbers-2016-12-17.tar.gz">
	afp-Algebraic_Numbers-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Algebraic_Numbers-2016-02-22.tar.gz">
	afp-Algebraic_Numbers-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Algebraic_Numbers-2015-12-22.tar.gz">
	afp-Algebraic_Numbers-2015-12-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Algebraic_VCs.html b/web/entries/Algebraic_VCs.html
	--- a/web/entries/Algebraic_VCs.html
	+++ b/web/entries/Algebraic_VCs.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Program Construction and Verification Components Based on Kleene Algebra - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>rogram

	<font class="first">C</font>onstruction

	and

	<font class="first">V</font>erification

	<font class="first">C</font>omponents

	<font class="first">B</font>ased

	on

	<font class="first">K</font>leene

	<font class="first">A</font>lgebra

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Program Construction and Verification Components Based on Kleene Algebra</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Victor B. F. Gomes (vb358 /at/ cl /dot/ cam /dot/ ac /dot/ uk) and
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Variants of Kleene algebra support program construction and
	verification by algebraic reasoning. This entry provides a
	verification component for Hoare logic based on Kleene algebra with
	tests, verification components for weakest preconditions and strongest
	postconditions based on Kleene algebra with domain and a component for
	step-wise refinement based on refinement Kleene algebra with tests. In
	addition to these components for the partial correctness of while
	programs, a verification component for total correctness based on
	divergence Kleene algebras and one for (partial correctness) of
	recursive programs based on domain quantales are provided. Finally we
	have integrated memory models for programs with pointers and a program
	trace semantics into the weakest precondition component.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Algebraic_VCs-AFP,
	author = {Victor B. F. Gomes and Georg Struth},
	title = {Program Construction and Verification Components Based on Kleene Algebra},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Algebraic_VCs.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="KAD.html">KAD</a>, <a href="KAT_and_DRA.html">KAT_and_DRA</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Algebraic_VCs/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Algebraic_VCs/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Algebraic_VCs/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Algebraic_VCs-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Algebraic_VCs-2018-08-16.tar.gz">
	+ afp-Algebraic_VCs-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Algebraic_VCs-2017-10-10.tar.gz">
	afp-Algebraic_VCs-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Algebraic_VCs-2016-12-17.tar.gz">
	afp-Algebraic_VCs-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Algebraic_VCs-2016-06-18.tar.gz">
	afp-Algebraic_VCs-2016-06-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Allen_Calculus.html b/web/entries/Allen_Calculus.html
	--- a/web/entries/Allen_Calculus.html
	+++ b/web/entries/Allen_Calculus.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Allen's Interval Calculus - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>llen's

	<font class="first">I</font>nterval

	<font class="first">C</font>alculus

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Allen's Interval Calculus</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Fadoua Ghourabi
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-09-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Allen’s interval calculus is a qualitative temporal representation of
	time events. Allen introduced 13 binary relations that describe all
	the possible arrangements between two events, i.e. intervals with
	non-zero finite length. The compositions are pertinent to
	reasoning about knowledge of time. In particular, a consistency
	problem of relation constraints is commonly solved with a guideline
	from these compositions. We formalize the relations together with an
	axiomatic system. We proof the validity of the 169 compositions of
	these relations. We also define nests as the sets of intervals that
	share a meeting point. We prove that nests give the ordering
	properties of points without introducing a new datatype for points.
	[1] J.F. Allen. Maintaining Knowledge about Temporal Intervals. In
	Commun. ACM, volume 26, pages 832–843, 1983. [2] J. F. Allen and P. J.
	Hayes. A Common-sense Theory of Time. In Proceedings of the 9th
	International Joint Conference on Artificial Intelligence (IJCAI’85),
	pages 528–531, 1985.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Allen_Calculus-AFP,
	author = {Fadoua Ghourabi},
	title = {Allen's Interval Calculus},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Allen_Calculus.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Allen_Calculus/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Allen_Calculus/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Allen_Calculus/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Allen_Calculus-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Allen_Calculus-2018-08-16.tar.gz">
	+ afp-Allen_Calculus-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Allen_Calculus-2017-10-10.tar.gz">
	afp-Allen_Calculus-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Allen_Calculus-2016-12-17.tar.gz">
	afp-Allen_Calculus-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Allen_Calculus-2016-10-05.tar.gz">
	afp-Allen_Calculus-2016-10-05.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Allen_Calculus-2016-09-29.tar.gz">
	afp-Allen_Calculus-2016-09-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Amortized_Complexity.html b/web/entries/Amortized_Complexity.html
	--- a/web/entries/Amortized_Complexity.html
	+++ b/web/entries/Amortized_Complexity.html
	@@ -1,224 +1,229 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Amortized Complexity Verified - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>mortized

	<font class="first">C</font>omplexity

	<font class="first">V</font>erified

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Amortized Complexity Verified</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-07-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	<p>
	A preliminary version of this work (without pairing heaps) is described
	in a <a href="http://www21.in.tum.de/~nipkow/pubs/itp15.html">paper</a>
	published in the proceedings of the conference on Interactive
	Theorem Proving ITP 2015. An extended version of this publication
	is available <a href="http://www21.in.tum.de/~nipkow/pubs/jfp16.html">here</a>.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-03-17]: Added pairing heaps by Hauke Brinkop.<br>
	[2016-07-12]: Moved splay heaps from here to Splay_Tree<br>
	[2016-07-14]: Moved pairing heaps from here to the new Pairing_Heap</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Amortized_Complexity-AFP,
	author = {Tobias Nipkow},
	title = {Amortized Complexity Verified},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Amortized_Complexity.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Pairing_Heap.html">Pairing_Heap</a>, <a href="Skew_Heap.html">Skew_Heap</a>, <a href="Splay_Tree.html">Splay_Tree</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Dynamic_Tables.html">Dynamic_Tables</a>, <a href="Root_Balanced_Tree.html">Root_Balanced_Tree</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Amortized_Complexity/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Amortized_Complexity/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Amortized_Complexity/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Amortized_Complexity-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Amortized_Complexity-2018-08-16.tar.gz">
	+ afp-Amortized_Complexity-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Amortized_Complexity-2017-10-10.tar.gz">
	afp-Amortized_Complexity-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Amortized_Complexity-2016-12-17.tar.gz">
	afp-Amortized_Complexity-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Amortized_Complexity-2016-02-22.tar.gz">
	afp-Amortized_Complexity-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Amortized_Complexity-2015-05-28.tar.gz">
	afp-Amortized_Complexity-2015-05-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Amortized_Complexity-2015-05-27.tar.gz">
	afp-Amortized_Complexity-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Amortized_Complexity-2015-05-19.tar.gz">
	afp-Amortized_Complexity-2015-05-19.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Amortized_Complexity-2014-08-28.tar.gz">
	afp-Amortized_Complexity-2014-08-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/AnselmGod.html b/web/entries/AnselmGod.html
	--- a/web/entries/AnselmGod.html
	+++ b/web/entries/AnselmGod.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Anselm's God in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>nselm's

	<font class="first">G</font>od

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Anselm's God in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://philpapers.org/profile/805">Ben Blumson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-09-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Paul Oppenheimer and Edward Zalta's formalisation of
	Anselm's ontological argument for the existence of God is
	automated by embedding a free logic for definite descriptions within
	Isabelle/HOL.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{AnselmGod-AFP,
	author = {Ben Blumson},
	title = {Anselm's God in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/AnselmGod.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AnselmGod/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/AnselmGod/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AnselmGod/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-AnselmGod-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-AnselmGod-2018-08-16.tar.gz">
	+ afp-AnselmGod-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-AnselmGod-2017-10-10.tar.gz">
	afp-AnselmGod-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-AnselmGod-2017-09-18.tar.gz">
	afp-AnselmGod-2017-09-18.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-AnselmGod-2017-09-11.tar.gz">
	afp-AnselmGod-2017-09-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-AnselmGod-2017-09-08.tar.gz">
	afp-AnselmGod-2017-09-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Applicative_Lifting.html b/web/entries/Applicative_Lifting.html
	--- a/web/entries/Applicative_Lifting.html
	+++ b/web/entries/Applicative_Lifting.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Applicative Lifting - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>pplicative

	<font class="first">L</font>ifting

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Applicative Lifting</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a> and
	Joshua Schneider (joshua /dot/ schneider /at/ inf /dot/ ethz /dot/ ch)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Applicative functors augment computations with effects by lifting function application to types which model the effects. As the structure of the computation cannot depend on the effects, applicative expressions can be analysed statically. This allows us to lift universally quantified equations to the effectful types, as observed by Hinze. Thus, equational reasoning over effectful computations can be reduced to pure types.
	</p><p>
	This entry provides a package for registering applicative functors and two proof methods for lifting of equations over applicative functors. The first method normalises applicative expressions according to the laws of applicative functors. This way, equations whose two sides contain the same list of variables can be lifted to every applicative functor.
	</p><p>
	To lift larger classes of equations, the second method exploits a number of additional properties (e.g., commutativity of effects) provided the properties have been declared for the concrete applicative functor at hand upon registration.
	</p><p>
	We declare several types from the Isabelle library as applicative functors and illustrate the use of the methods with two examples: the lifting of the arithmetic type class hierarchy to streams and the verification of a relabelling function on binary trees. We also formalise and verify the normalisation algorithm used by the first proof method.
	</p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2016-03-03]: added formalisation of lifting with combinators<br>
	[2016-06-10]:
	implemented automatic derivation of lifted combinator reductions;
	support arbitrary lifted relations using relators;
	improved compatibility with locale interpretation
	(revision ec336f354f37)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Applicative_Lifting-AFP,
	author = {Andreas Lochbihler and Joshua Schneider},
	title = {Applicative Lifting},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Applicative_Lifting.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CryptHOL.html">CryptHOL</a>, <a href="Free-Groups.html">Free-Groups</a>, <a href="Locally-Nameless-Sigma.html">Locally-Nameless-Sigma</a>, <a href="Stern_Brocot.html">Stern_Brocot</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Applicative_Lifting/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Applicative_Lifting/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Applicative_Lifting/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Applicative_Lifting-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Applicative_Lifting-2018-08-16.tar.gz">
	+ afp-Applicative_Lifting-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Applicative_Lifting-2017-10-10.tar.gz">
	afp-Applicative_Lifting-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Applicative_Lifting-2016-12-17.tar.gz">
	afp-Applicative_Lifting-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Applicative_Lifting-2016-02-22.tar.gz">
	afp-Applicative_Lifting-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Applicative_Lifting-2015-12-22.tar.gz">
	afp-Applicative_Lifting-2015-12-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Architectural_Design_Patterns.html b/web/entries/Architectural_Design_Patterns.html
	--- a/web/entries/Architectural_Design_Patterns.html
	+++ b/web/entries/Architectural_Design_Patterns.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Theory of Architectural Design Patterns - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">T</font>heory

	of

	<font class="first">A</font>rchitectural

	<font class="first">D</font>esign

	<font class="first">P</font>atterns

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Theory of Architectural Design Patterns</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://marmsoler.com">Diego Marmsoler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-03-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The following document formalizes and verifies several architectural
	design patterns. Each pattern specification is formalized in terms of
	a locale where the locale assumptions correspond to the assumptions
	which a pattern poses on an architecture. Thus, pattern specifications
	may build on top of each other by interpreting the corresponding
	locale. A pattern is verified using the framework provided by the AFP
	entry Dynamic Architectures. Currently, the document consists of
	formalizations of 4 different patterns: the singleton, the publisher
	subscriber, the blackboard pattern, and the blockchain pattern.
	Thereby, the publisher component of the publisher subscriber pattern
	is modeled as an instance of the singleton pattern and the blackboard
	pattern is modeled as an instance of the publisher subscriber pattern.
	In general, this entry provides the first steps towards an overall
	theory of architectural design patterns.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-05-25]: changing the major assumption for blockchain architectures from alternative minings to relative mining frequencies (revision 5043c5c71685)<br>
	[2019-04-08]: adapting the terminology: honest instead of trusted, dishonest instead of untrusted (revision 7af3431a22ae)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Architectural_Design_Patterns-AFP,
	author = {Diego Marmsoler},
	title = {A Theory of Architectural Design Patterns},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Architectural_Design_Patterns.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="DynamicArchitectures.html">DynamicArchitectures</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Architectural_Design_Patterns/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Architectural_Design_Patterns/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Architectural_Design_Patterns/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Architectural_Design_Patterns-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Architectural_Design_Patterns-2018-08-16.tar.gz">
	+ afp-Architectural_Design_Patterns-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Architectural_Design_Patterns-2018-03-01.tar.gz">
	afp-Architectural_Design_Patterns-2018-03-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/ArrowImpossibilityGS.html b/web/entries/ArrowImpossibilityGS.html
	--- a/web/entries/ArrowImpossibilityGS.html
	+++ b/web/entries/ArrowImpossibilityGS.html
	@@ -1,249 +1,254 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Arrow and Gibbard-Satterthwaite - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>rrow

	and

	<font class="first">G</font>ibbard-Satterthwaite

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Arrow and Gibbard-Satterthwaite</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-09-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This article formalizes two proofs of Arrow's impossibility theorem due to Geanakoplos and derives the Gibbard-Satterthwaite theorem as a corollary. One formalization is based on utility functions, the other one on strict partial orders.<br><br>An article about these proofs is found <a href="http://www21.in.tum.de/~nipkow/pubs/arrow.html">here</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{ArrowImpossibilityGS-AFP,
	author = {Tobias Nipkow},
	title = {Arrow and Gibbard-Satterthwaite},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/ArrowImpossibilityGS.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ArrowImpossibilityGS/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/ArrowImpossibilityGS/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ArrowImpossibilityGS/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-ArrowImpossibilityGS-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-ArrowImpossibilityGS-2018-08-16.tar.gz">
	+ afp-ArrowImpossibilityGS-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-ArrowImpossibilityGS-2017-10-10.tar.gz">
	afp-ArrowImpossibilityGS-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-ArrowImpossibilityGS-2016-12-17.tar.gz">
	afp-ArrowImpossibilityGS-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-ArrowImpossibilityGS-2016-02-22.tar.gz">
	afp-ArrowImpossibilityGS-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-ArrowImpossibilityGS-2015-05-27.tar.gz">
	afp-ArrowImpossibilityGS-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-ArrowImpossibilityGS-2014-08-28.tar.gz">
	afp-ArrowImpossibilityGS-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-ArrowImpossibilityGS-2013-12-11.tar.gz">
	afp-ArrowImpossibilityGS-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-ArrowImpossibilityGS-2013-11-17.tar.gz">
	afp-ArrowImpossibilityGS-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-ArrowImpossibilityGS-2013-03-02.tar.gz">
	afp-ArrowImpossibilityGS-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-ArrowImpossibilityGS-2013-02-16.tar.gz">
	afp-ArrowImpossibilityGS-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-ArrowImpossibilityGS-2012-05-24.tar.gz">
	afp-ArrowImpossibilityGS-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-ArrowImpossibilityGS-2011-10-11.tar.gz">
	afp-ArrowImpossibilityGS-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-ArrowImpossibilityGS-2011-02-11.tar.gz">
	afp-ArrowImpossibilityGS-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-ArrowImpossibilityGS-2010-06-30.tar.gz">
	afp-ArrowImpossibilityGS-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-ArrowImpossibilityGS-2009-12-12.tar.gz">
	afp-ArrowImpossibilityGS-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-ArrowImpossibilityGS-2009-09-29.tar.gz">
	afp-ArrowImpossibilityGS-2009-09-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-ArrowImpossibilityGS-2009-04-29.tar.gz">
	afp-ArrowImpossibilityGS-2009-04-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Auto2_HOL.html b/web/entries/Auto2_HOL.html
	--- a/web/entries/Auto2_HOL.html
	+++ b/web/entries/Auto2_HOL.html
	@@ -1,173 +1,179 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Auto2 Prover - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>uto2

	<font class="first">P</font>rover

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Auto2 Prover</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://lcs.ios.ac.cn/~bzhan/">Bohua Zhan</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-11-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Auto2 is a saturation-based heuristic prover for higher-order logic,
	implemented as a tactic in Isabelle. This entry contains the
	instantiation of auto2 for Isabelle/HOL, along with two basic
	examples: solutions to some of the Pelletier’s problems, and
	elementary number theory of primes.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Auto2_HOL-AFP,
	author = {Bohua Zhan},
	title = {Auto2 Prover},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Auto2_HOL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Auto2_Imperative_HOL.html">Auto2_Imperative_HOL</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Auto2_HOL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Auto2_HOL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Auto2_HOL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Auto2_HOL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Auto2_HOL-2018-11-29.tar.gz">
	+ afp-Auto2_HOL-2018-11-29.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Auto2_Imperative_HOL.html b/web/entries/Auto2_Imperative_HOL.html
	--- a/web/entries/Auto2_Imperative_HOL.html
	+++ b/web/entries/Auto2_Imperative_HOL.html
	@@ -1,184 +1,190 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Verifying Imperative Programs using Auto2 - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erifying

	<font class="first">I</font>mperative

	<font class="first">P</font>rograms

	using

	<font class="first">A</font>uto2

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Verifying Imperative Programs using Auto2</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://lcs.ios.ac.cn/~bzhan/">Bohua Zhan</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-12-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry contains the application of auto2 to verifying functional
	and imperative programs. Algorithms and data structures that are
	verified include linked lists, binary search trees, red-black trees,
	interval trees, priority queue, quicksort, union-find, Dijkstra's
	algorithm, and a sweep-line algorithm for detecting rectangle
	intersection. The imperative verification is based on Imperative HOL
	and its separation logic framework. A major goal of this work is to
	set up automation in order to reduce the length of proof that the user
	needs to provide, both for verifying functional programs and for
	working with separation logic.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Auto2_Imperative_HOL-AFP,
	author = {Bohua Zhan},
	title = {Verifying Imperative Programs using Auto2},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Auto2_Imperative_HOL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Auto2_HOL.html">Auto2_HOL</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Auto2_Imperative_HOL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Auto2_Imperative_HOL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Auto2_Imperative_HOL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Auto2_Imperative_HOL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Auto2_Imperative_HOL-2019-01-22.tar.gz">
	+ afp-Auto2_Imperative_HOL-2019-01-22.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/AutoFocus-Stream.html b/web/entries/AutoFocus-Stream.html
	--- a/web/entries/AutoFocus-Stream.html
	+++ b/web/entries/AutoFocus-Stream.html
	@@ -1,241 +1,246 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>AutoFocus Stream Processing for Single-Clocking and Multi-Clocking Semantics - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>utoFocus

	<font class="first">S</font>tream

	<font class="first">P</font>rocessing

	for

	<font class="first">S</font>ingle-Clocking

	and

	<font class="first">M</font>ulti-Clocking

	<font class="first">S</font>emantics

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">AutoFocus Stream Processing for Single-Clocking and Multi-Clocking Semantics</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	David Trachtenherz
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-02-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalize the AutoFocus Semantics (a time-synchronous subset of the Focus formalism) as stream processing functions on finite and infinite message streams represented as finite/infinite lists. The formalization comprises both the conventional single-clocking semantics (uniform global clock for all components and communications channels) and its extension to multi-clocking semantics (internal execution clocking of a component may be a multiple of the external communication clocking). The semantics is defined by generic stream processing functions making it suitable for simulation/code generation in Isabelle/HOL. Furthermore, a number of AutoFocus semantics properties are formalized using definitions from the IntervalLogic theories.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{AutoFocus-Stream-AFP,
	author = {David Trachtenherz},
	title = {AutoFocus Stream Processing for Single-Clocking and Multi-Clocking Semantics},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/AutoFocus-Stream.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Nat-Interval-Logic.html">Nat-Interval-Logic</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AutoFocus-Stream/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/AutoFocus-Stream/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AutoFocus-Stream/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-AutoFocus-Stream-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-AutoFocus-Stream-2018-08-16.tar.gz">
	+ afp-AutoFocus-Stream-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-AutoFocus-Stream-2017-10-10.tar.gz">
	afp-AutoFocus-Stream-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-AutoFocus-Stream-2016-12-17.tar.gz">
	afp-AutoFocus-Stream-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-AutoFocus-Stream-2016-02-22.tar.gz">
	afp-AutoFocus-Stream-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-AutoFocus-Stream-2015-05-27.tar.gz">
	afp-AutoFocus-Stream-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-AutoFocus-Stream-2014-08-28.tar.gz">
	afp-AutoFocus-Stream-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-AutoFocus-Stream-2013-12-11.tar.gz">
	afp-AutoFocus-Stream-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-AutoFocus-Stream-2013-11-17.tar.gz">
	afp-AutoFocus-Stream-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-AutoFocus-Stream-2013-03-08.tar.gz">
	afp-AutoFocus-Stream-2013-03-08.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-AutoFocus-Stream-2013-02-16.tar.gz">
	afp-AutoFocus-Stream-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-AutoFocus-Stream-2012-05-24.tar.gz">
	afp-AutoFocus-Stream-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-AutoFocus-Stream-2011-10-11.tar.gz">
	afp-AutoFocus-Stream-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-AutoFocus-Stream-2011-02-24.tar.gz">
	afp-AutoFocus-Stream-2011-02-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Automatic_Refinement.html b/web/entries/Automatic_Refinement.html
	--- a/web/entries/Automatic_Refinement.html
	+++ b/web/entries/Automatic_Refinement.html
	@@ -1,218 +1,223 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Automatic Data Refinement - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>utomatic

	<font class="first">D</font>ata

	<font class="first">R</font>efinement

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Automatic Data Refinement</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-10-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We present the Autoref tool for Isabelle/HOL, which automatically
	refines algorithms specified over abstract concepts like maps
	and sets to algorithms over concrete implementations like red-black-trees,
	and produces a refinement theorem. It is based on ideas borrowed from
	relational parametricity due to Reynolds and Wadler.
	The tool allows for rapid prototyping of verified, executable algorithms.
	Moreover, it can be configured to fine-tune the result to the user~s needs.
	Our tool is able to automatically instantiate generic algorithms, which
	greatly simplifies the implementation of executable data structures.
	<p>
	This AFP-entry provides the basic tool, which is then used by the
	Refinement and Collection Framework to provide automatic data refinement for
	the nondeterminism monad and various collection datastructures.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Automatic_Refinement-AFP,
	author = {Peter Lammich},
	title = {Automatic Data Refinement},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Automatic_Refinement.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Containers.html">Containers</a>, <a href="Dict_Construction.html">Dict_Construction</a>, <a href="IP_Addresses.html">IP_Addresses</a>, <a href="JinjaThreads.html">JinjaThreads</a>, <a href="Network_Security_Policy_Verification.html">Network_Security_Policy_Verification</a>, <a href="Refine_Monadic.html">Refine_Monadic</a>, <a href="ROBDD.html">ROBDD</a>, <a href="Separation_Logic_Imperative_HOL.html">Separation_Logic_Imperative_HOL</a>, <a href="UpDown_Scheme.html">UpDown_Scheme</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Automatic_Refinement/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Automatic_Refinement/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Automatic_Refinement/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Automatic_Refinement-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Automatic_Refinement-2018-08-16.tar.gz">
	+ afp-Automatic_Refinement-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Automatic_Refinement-2017-10-10.tar.gz">
	afp-Automatic_Refinement-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Automatic_Refinement-2016-12-17.tar.gz">
	afp-Automatic_Refinement-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Automatic_Refinement-2016-02-22.tar.gz">
	afp-Automatic_Refinement-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Automatic_Refinement-2015-05-27.tar.gz">
	afp-Automatic_Refinement-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Automatic_Refinement-2014-08-28.tar.gz">
	afp-Automatic_Refinement-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Automatic_Refinement-2013-12-11.tar.gz">
	afp-Automatic_Refinement-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Automatic_Refinement-2013-11-17.tar.gz">
	afp-Automatic_Refinement-2013-11-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/AxiomaticCategoryTheory.html b/web/entries/AxiomaticCategoryTheory.html
	--- a/web/entries/AxiomaticCategoryTheory.html
	+++ b/web/entries/AxiomaticCategoryTheory.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Axiom Systems for Category Theory in Free Logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>xiom

	<font class="first">S</font>ystems

	for

	<font class="first">C</font>ategory

	<font class="first">T</font>heory

	in

	<font class="first">F</font>ree

	<font class="first">L</font>ogic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Axiom Systems for Category Theory in Free Logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://christoph-benzmueller.de">Christoph Benzmüller</a> and
	<a href="http://www.cs.cmu.edu/~scott/">Dana Scott</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-05-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This document provides a concise overview on the core results of our
	previous work on the exploration of axioms systems for category
	theory. Extending the previous studies
	(http://arxiv.org/abs/1609.01493) we include one further axiomatic
	theory in our experiments. This additional theory has been suggested
	by Mac Lane in 1948. We show that the axioms proposed by Mac Lane are
	equivalent to the ones we studied before, which includes an axioms set
	suggested by Scott in the 1970s and another axioms set proposed by
	Freyd and Scedrov in 1990, which we slightly modified to remedy a
	minor technical issue.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{AxiomaticCategoryTheory-AFP,
	author = {Christoph Benzmüller and Dana Scott},
	title = {Axiom Systems for Category Theory in Free Logic},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/AxiomaticCategoryTheory.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AxiomaticCategoryTheory/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/AxiomaticCategoryTheory/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/AxiomaticCategoryTheory/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-AxiomaticCategoryTheory-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-AxiomaticCategoryTheory-2018-08-16.tar.gz">
	+ afp-AxiomaticCategoryTheory-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-AxiomaticCategoryTheory-2018-05-23.tar.gz">
	afp-AxiomaticCategoryTheory-2018-05-23.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/BDD.html b/web/entries/BDD.html
	--- a/web/entries/BDD.html
	+++ b/web/entries/BDD.html
	@@ -1,250 +1,255 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>BDD Normalisation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>DD

	<font class="first">N</font>ormalisation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">BDD Normalisation</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Veronika Ortner and
	Norbert Schirmer (norbert /dot/ schirmer /at/ web /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-02-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We present the verification of the normalisation of a binary decision diagram (BDD). The normalisation follows the original algorithm presented by Bryant in 1986 and transforms an ordered BDD in a reduced, ordered and shared BDD. The verification is based on Hoare logics.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{BDD-AFP,
	author = {Veronika Ortner and Norbert Schirmer},
	title = {BDD Normalisation},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/BDD.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Simpl.html">Simpl</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BDD/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/BDD/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BDD/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-BDD-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-BDD-2018-08-16.tar.gz">
	+ afp-BDD-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-BDD-2017-10-10.tar.gz">
	afp-BDD-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-BDD-2016-12-17.tar.gz">
	afp-BDD-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-BDD-2016-02-22.tar.gz">
	afp-BDD-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-BDD-2015-05-27.tar.gz">
	afp-BDD-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-BDD-2014-08-28.tar.gz">
	afp-BDD-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-BDD-2013-12-11.tar.gz">
	afp-BDD-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-BDD-2013-11-17.tar.gz">
	afp-BDD-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-BDD-2013-02-16.tar.gz">
	afp-BDD-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-BDD-2012-05-24.tar.gz">
	afp-BDD-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-BDD-2011-10-11.tar.gz">
	afp-BDD-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-BDD-2011-02-11.tar.gz">
	afp-BDD-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-BDD-2010-06-30.tar.gz">
	afp-BDD-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-BDD-2009-12-12.tar.gz">
	afp-BDD-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-BDD-2009-04-29.tar.gz">
	afp-BDD-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-BDD-2008-06-10.tar.gz">
	afp-BDD-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-BDD-2008-03-07.tar.gz">
	afp-BDD-2008-03-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/BNF_CC.html b/web/entries/BNF_CC.html
	--- a/web/entries/BNF_CC.html
	+++ b/web/entries/BNF_CC.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Bounded Natural Functors with Covariance and Contravariance - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>ounded

	<font class="first">N</font>atural

	<font class="first">F</font>unctors

	with

	<font class="first">C</font>ovariance

	and

	<font class="first">C</font>ontravariance

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Bounded Natural Functors with Covariance and Contravariance</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a> and
	Joshua Schneider (joshua /dot/ schneider /at/ inf /dot/ ethz /dot/ ch)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-04-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Bounded natural functors (BNFs) provide a modular framework for the
	construction of (co)datatypes in higher-order logic. Their functorial
	operations, the mapper and relator, are restricted to a subset of the
	parameters, namely those where recursion can take place. For certain
	applications, such as free theorems, data refinement, quotients, and
	generalised rewriting, it is desirable that these operations do not
	ignore the other parameters. In this article, we formalise the
	generalisation BNF<sub>CC</sub> that extends the mapper
	and relator to covariant and contravariant parameters. We show that
	<ol> <li> BNF<sub>CC</sub>s are closed under
	functor composition and least and greatest fixpoints,</li>
	<li> subtypes inherit the BNF<sub>CC</sub> structure
	under conditions that generalise those for the BNF case,
	and</li> <li> BNF<sub>CC</sub>s preserve
	quotients under mild conditions.</li> </ol> These proofs
	are carried out for abstract BNF<sub>CC</sub>s similar to
	the AFP entry BNF Operations. In addition, we apply the
	BNF<sub>CC</sub> theory to several concrete functors.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{BNF_CC-AFP,
	author = {Andreas Lochbihler and Joshua Schneider},
	title = {Bounded Natural Functors with Covariance and Contravariance},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/BNF_CC.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BNF_CC/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/BNF_CC/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BNF_CC/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-BNF_CC-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-BNF_CC-2018-08-16.tar.gz">
	+ afp-BNF_CC-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-BNF_CC-2018-04-25.tar.gz">
	afp-BNF_CC-2018-04-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/BNF_Operations.html b/web/entries/BNF_Operations.html
	--- a/web/entries/BNF_Operations.html
	+++ b/web/entries/BNF_Operations.html
	@@ -1,184 +1,190 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Operations on Bounded Natural Functors - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">O</font>perations

	on

	<font class="first">B</font>ounded

	<font class="first">N</font>atural

	<font class="first">F</font>unctors

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Operations on Bounded Natural Functors</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl),
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk) and
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-12-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry formalizes the closure property of bounded natural functors
	(BNFs) under seven operations. These operations and the corresponding
	proofs constitute the core of Isabelle's (co)datatype package. To
	be close to the implemented tactics, the proofs are deliberately
	formulated as detailed apply scripts. The (co)datatypes together with
	(co)induction principles and (co)recursors are byproducts of the
	fixpoint operations LFP and GFP. Composition of BNFs is subdivided
	into four simpler operations: Compose, Kill, Lift, and Permute. The
	N2M operation provides mutual (co)induction principles and
	(co)recursors for nested (co)datatypes.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{BNF_Operations-AFP,
	author = {Jasmin Christian Blanchette and Andrei Popescu and Dmitriy Traytel},
	title = {Operations on Bounded Natural Functors},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/BNF_Operations.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BNF_Operations/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/BNF_Operations/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BNF_Operations/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-BNF_Operations-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-BNF_Operations-2018-08-16.tar.gz">
	+ afp-BNF_Operations-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Bell_Numbers_Spivey.html b/web/entries/Bell_Numbers_Spivey.html
	--- a/web/entries/Bell_Numbers_Spivey.html
	+++ b/web/entries/Bell_Numbers_Spivey.html
	@@ -1,207 +1,212 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Spivey's Generalized Recurrence for Bell Numbers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>pivey's

	<font class="first">G</font>eneralized

	<font class="first">R</font>ecurrence

	for

	<font class="first">B</font>ell

	<font class="first">N</font>umbers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Spivey's Generalized Recurrence for Bell Numbers</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-04</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry defines the Bell numbers as the cardinality of set partitions for
	a carrier set of given size, and derives Spivey's generalized recurrence
	relation for Bell numbers following his elegant and intuitive combinatorial
	proof.
	<p>
	As the set construction for the combinatorial proof requires construction of
	three intermediate structures, the main difficulty of the formalization is
	handling the overall combinatorial argument in a structured way.
	The introduced proof structure allows us to compose the combinatorial argument
	from its subparts, and supports to keep track how the detailed proof steps are
	related to the overall argument. To obtain this structure, this entry uses set
	monad notation for the set construction's definition, introduces suitable
	predicates and rules, and follows a repeating structure in its Isar proof.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Bell_Numbers_Spivey-AFP,
	author = {Lukas Bulwahn},
	title = {Spivey's Generalized Recurrence for Bell Numbers},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Bell_Numbers_Spivey.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Card_Partitions.html">Card_Partitions</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Card_Equiv_Relations.html">Card_Equiv_Relations</a>, <a href="Twelvefold_Way.html">Twelvefold_Way</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bell_Numbers_Spivey/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Bell_Numbers_Spivey/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bell_Numbers_Spivey/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Bell_Numbers_Spivey-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Bell_Numbers_Spivey-2018-08-16.tar.gz">
	+ afp-Bell_Numbers_Spivey-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Bell_Numbers_Spivey-2017-10-10.tar.gz">
	afp-Bell_Numbers_Spivey-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Bell_Numbers_Spivey-2016-12-17.tar.gz">
	afp-Bell_Numbers_Spivey-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Bell_Numbers_Spivey-2016-05-04.tar.gz">
	afp-Bell_Numbers_Spivey-2016-05-04.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Berlekamp_Zassenhaus.html b/web/entries/Berlekamp_Zassenhaus.html
	--- a/web/entries/Berlekamp_Zassenhaus.html
	+++ b/web/entries/Berlekamp_Zassenhaus.html
	@@ -1,210 +1,220 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Factorization Algorithm of Berlekamp and Zassenhaus - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">F</font>actorization

	<font class="first">A</font>lgorithm

	of

	<font class="first">B</font>erlekamp

	and

	<font class="first">Z</font>assenhaus

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Factorization Algorithm of Berlekamp and Zassenhaus</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
	<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a> and
	Akihisa Yamada (ayamada /at/ trs /dot/ cm /dot/ is /dot/ nagoya-u /dot/ ac /dot/ jp)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-10-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>We formalize the Berlekamp-Zassenhaus algorithm for factoring
	square-free integer polynomials in Isabelle/HOL. We further adapt an
	existing formalization of Yun’s square-free factorization algorithm to
	integer polynomials, and thus provide an efficient and certified
	factorization algorithm for arbitrary univariate polynomials.
	</p>
	<p>The algorithm first performs a factorization in the prime field GF(p) and
	then performs computations in the integer ring modulo p^k, where both
	p and k are determined at runtime. Since a natural modeling of these
	structures via dependent types is not possible in Isabelle/HOL, we
	formalize the whole algorithm using Isabelle’s recent addition of
	local type definitions.
	</p>
	<p>Through experiments we verify that our algorithm factors polynomials of degree
	100 within seconds.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Berlekamp_Zassenhaus-AFP,
	author = {Jose Divasón and Sebastiaan Joosten and René Thiemann and Akihisa Yamada},
	title = {The Factorization Algorithm of Berlekamp and Zassenhaus},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Berlekamp_Zassenhaus.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Efficient-Mergesort.html">Efficient-Mergesort</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a>, <a href="Polynomial_Interpolation.html">Polynomial_Interpolation</a>, <a href="Show.html">Show</a>, <a href="Subresultants.html">Subresultants</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Algebraic_Numbers.html">Algebraic_Numbers</a>, <a href="Linear_Recurrences.html">Linear_Recurrences</a>, <a href="LLL_Basis_Reduction.html">LLL_Basis_Reduction</a>, <a href="Probabilistic_While.html">Probabilistic_While</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Berlekamp_Zassenhaus/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Berlekamp_Zassenhaus/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Berlekamp_Zassenhaus/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Berlekamp_Zassenhaus-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Berlekamp_Zassenhaus-2018-09-07.tar.gz">
	+ afp-Berlekamp_Zassenhaus-2018-09-07.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Berlekamp_Zassenhaus-2018-08-16.tar.gz">
	+ afp-Berlekamp_Zassenhaus-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Berlekamp_Zassenhaus-2017-10-10.tar.gz">
	afp-Berlekamp_Zassenhaus-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Berlekamp_Zassenhaus-2016-12-17.tar.gz">
	afp-Berlekamp_Zassenhaus-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Bernoulli.html b/web/entries/Bernoulli.html
	--- a/web/entries/Bernoulli.html
	+++ b/web/entries/Bernoulli.html
	@@ -1,197 +1,202 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Bernoulli Numbers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>ernoulli

	<font class="first">N</font>umbers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Bernoulli Numbers</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com) and
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-01-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>Bernoulli numbers were first discovered in the closed-form
	expansion of the sum 1<sup>m</sup> +
	2<sup>m</sup> + … + n<sup>m</sup>
	for a fixed m and appear in many other places. This entry provides
	three different definitions for them: a recursive one, an explicit
	one, and one through their exponential generating function.</p>
	<p>In addition, we prove some basic facts, e.g. their relation
	to sums of powers of integers and that all odd Bernoulli numbers
	except the first are zero, and some advanced facts like their
	relationship to the Riemann zeta function on positive even
	integers.</p>
	<p>We also prove the correctness of the
	Akiyama–Tanigawa algorithm for computing Bernoulli numbers
	with reasonable efficiency, and we define the periodic Bernoulli
	polynomials (which appear e.g. in the Euler–MacLaurin
	summation formula and the expansion of the log-Gamma function) and
	prove their basic properties.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Bernoulli-AFP,
	author = {Lukas Bulwahn and Manuel Eberl},
	title = {Bernoulli Numbers},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Bernoulli.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Euler_MacLaurin.html">Euler_MacLaurin</a>, <a href="Stirling_Formula.html">Stirling_Formula</a>, <a href="Zeta_Function.html">Zeta_Function</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bernoulli/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Bernoulli/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bernoulli/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Bernoulli-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Bernoulli-2018-08-16.tar.gz">
	+ afp-Bernoulli-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Bernoulli-2017-10-10.tar.gz">
	afp-Bernoulli-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Bernoulli-2017-01-24.tar.gz">
	afp-Bernoulli-2017-01-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Bertrands_Postulate.html b/web/entries/Bertrands_Postulate.html
	--- a/web/entries/Bertrands_Postulate.html
	+++ b/web/entries/Bertrands_Postulate.html
	@@ -1,197 +1,202 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Bertrand's postulate - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>ertrand's

	postulate

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Bertrand's postulate</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Julian Biendarra and
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	<a href="http://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-01-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>Bertrand's postulate is an early result on the
	distribution of prime numbers: For every positive integer n, there
	exists a prime number that lies strictly between n and 2n.
	The proof is ported from John Harrison's formalisation
	in HOL Light. It proceeds by first showing that the property is true
	for all n greater than or equal to 600 and then showing that it also
	holds for all n below 600 by case distinction. </p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Bertrands_Postulate-AFP,
	author = {Julian Biendarra and Manuel Eberl},
	title = {Bertrand's postulate},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Bertrands_Postulate.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Pratt_Certificate.html">Pratt_Certificate</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Dirichlet_L.html">Dirichlet_L</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bertrands_Postulate/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Bertrands_Postulate/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bertrands_Postulate/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Bertrands_Postulate-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Bertrands_Postulate-2018-08-16.tar.gz">
	+ afp-Bertrands_Postulate-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Bertrands_Postulate-2017-10-10.tar.gz">
	afp-Bertrands_Postulate-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Bertrands_Postulate-2017-01-18.tar.gz">
	afp-Bertrands_Postulate-2017-01-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/BinarySearchTree.html b/web/entries/BinarySearchTree.html
	--- a/web/entries/BinarySearchTree.html
	+++ b/web/entries/BinarySearchTree.html
	@@ -1,269 +1,274 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Binary Search Trees - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>inary

	<font class="first">S</font>earch

	<font class="first">T</font>rees

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Binary Search Trees</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://lara.epfl.ch/~kuncak/">Viktor Kuncak</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-04-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The correctness is shown of binary search tree operations (lookup, insert and remove) implementing a set. Two versions are given, for both structured and linear (tactic-style) proofs. An implementation of integer-indexed maps is also verified.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{BinarySearchTree-AFP,
	author = {Viktor Kuncak},
	title = {Binary Search Trees},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/BinarySearchTree.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BinarySearchTree/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/BinarySearchTree/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BinarySearchTree/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-BinarySearchTree-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-BinarySearchTree-2018-08-16.tar.gz">
	+ afp-BinarySearchTree-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-BinarySearchTree-2017-10-10.tar.gz">
	afp-BinarySearchTree-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-BinarySearchTree-2016-12-17.tar.gz">
	afp-BinarySearchTree-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-BinarySearchTree-2016-02-22.tar.gz">
	afp-BinarySearchTree-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-BinarySearchTree-2015-05-27.tar.gz">
	afp-BinarySearchTree-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-BinarySearchTree-2014-08-28.tar.gz">
	afp-BinarySearchTree-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-BinarySearchTree-2013-12-11.tar.gz">
	afp-BinarySearchTree-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-BinarySearchTree-2013-11-17.tar.gz">
	afp-BinarySearchTree-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-BinarySearchTree-2013-02-16.tar.gz">
	afp-BinarySearchTree-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-BinarySearchTree-2012-05-24.tar.gz">
	afp-BinarySearchTree-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-BinarySearchTree-2011-10-11.tar.gz">
	afp-BinarySearchTree-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-BinarySearchTree-2011-02-11.tar.gz">
	afp-BinarySearchTree-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-BinarySearchTree-2010-06-30.tar.gz">
	afp-BinarySearchTree-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-BinarySearchTree-2009-12-12.tar.gz">
	afp-BinarySearchTree-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-BinarySearchTree-2009-04-29.tar.gz">
	afp-BinarySearchTree-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-BinarySearchTree-2008-06-10.tar.gz">
	afp-BinarySearchTree-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-BinarySearchTree-2007-11-27.tar.gz">
	afp-BinarySearchTree-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-BinarySearchTree-2005-10-14.tar.gz">
	afp-BinarySearchTree-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-BinarySearchTree-2004-09-21.tar.gz">
	afp-BinarySearchTree-2004-09-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-BinarySearchTree-2004-04-21.tar.gz">
	afp-BinarySearchTree-2004-04-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-BinarySearchTree-2004-04-20.tar.gz">
	afp-BinarySearchTree-2004-04-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Binding_Syntax_Theory.html b/web/entries/Binding_Syntax_Theory.html
	--- a/web/entries/Binding_Syntax_Theory.html
	+++ b/web/entries/Binding_Syntax_Theory.html
	@@ -1,187 +1,193 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A General Theory of Syntax with Bindings - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">G</font>eneral

	<font class="first">T</font>heory

	of

	<font class="first">S</font>yntax

	with

	<font class="first">B</font>indings

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A General Theory of Syntax with Bindings</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Lorenzo Gheri (lor /dot/ gheri /at/ gmail /dot/ com) and
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-04-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize a theory of syntax with bindings that has been developed
	and refined over the last decade to support several large
	formalization efforts. Terms are defined for an arbitrary number of
	constructors of varying numbers of inputs, quotiented to
	alpha-equivalence and sorted according to a binding signature. The
	theory includes many properties of the standard operators on terms:
	substitution, swapping and freshness. It also includes bindings-aware
	induction and recursion principles and support for semantic
	interpretation. This work has been presented in the ITP 2017 paper “A
	Formalized General Theory of Syntax with Bindings”.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Binding_Syntax_Theory-AFP,
	author = {Lorenzo Gheri and Andrei Popescu},
	title = {A General Theory of Syntax with Bindings},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Binding_Syntax_Theory.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Binding_Syntax_Theory/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Binding_Syntax_Theory/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Binding_Syntax_Theory/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Binding_Syntax_Theory-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Binding_Syntax_Theory-2019-04-08.tar.gz">
	+ afp-Binding_Syntax_Theory-2019-04-08.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Binomial-Heaps.html b/web/entries/Binomial-Heaps.html
	--- a/web/entries/Binomial-Heaps.html
	+++ b/web/entries/Binomial-Heaps.html
	@@ -1,254 +1,259 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Binomial Heaps and Skew Binomial Heaps - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>inomial

	<font class="first">H</font>eaps

	and

	<font class="first">S</font>kew

	<font class="first">B</font>inomial

	<font class="first">H</font>eaps

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Binomial Heaps and Skew Binomial Heaps</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Rene Meis (rene /dot/ meis /at/ uni-due /dot/ de),
	Finn Nielsen (finn /dot/ nielsen /at/ uni-muenster /dot/ de) and
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-10-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We implement and prove correct binomial heaps and skew binomial heaps.
	Both are data-structures for priority queues.
	While binomial heaps have logarithmic <em>findMin</em>, <em>deleteMin</em>,
	<em>insert</em>, and <em>meld</em> operations,
	skew binomial heaps have constant time <em>findMin</em>, <em>insert</em>,
	and <em>meld</em> operations, and only the <em>deleteMin</em>-operation is
	logarithmic. This is achieved by using <em>skew links</em> to avoid
	cascading linking on <em>insert</em>-operations, and <em>data-structural
	bootstrapping</em> to get constant-time <em>findMin</em> and <em>meld</em>
	operations. Our implementation follows the paper by Brodal and Okasaki.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Binomial-Heaps-AFP,
	author = {Rene Meis and Finn Nielsen and Peter Lammich},
	title = {Binomial Heaps and Skew Binomial Heaps},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Binomial-Heaps.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="JinjaThreads.html">JinjaThreads</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Binomial-Heaps/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Binomial-Heaps/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Binomial-Heaps/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Binomial-Heaps-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Binomial-Heaps-2018-08-16.tar.gz">
	+ afp-Binomial-Heaps-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Binomial-Heaps-2017-10-10.tar.gz">
	afp-Binomial-Heaps-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Binomial-Heaps-2016-12-17.tar.gz">
	afp-Binomial-Heaps-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Binomial-Heaps-2016-02-22.tar.gz">
	afp-Binomial-Heaps-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Binomial-Heaps-2015-05-27.tar.gz">
	afp-Binomial-Heaps-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Binomial-Heaps-2014-08-28.tar.gz">
	afp-Binomial-Heaps-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Binomial-Heaps-2013-12-11.tar.gz">
	afp-Binomial-Heaps-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Binomial-Heaps-2013-11-17.tar.gz">
	afp-Binomial-Heaps-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Binomial-Heaps-2013-03-02.tar.gz">
	afp-Binomial-Heaps-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Binomial-Heaps-2013-02-16.tar.gz">
	afp-Binomial-Heaps-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Binomial-Heaps-2012-05-24.tar.gz">
	afp-Binomial-Heaps-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Binomial-Heaps-2011-10-11.tar.gz">
	afp-Binomial-Heaps-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Binomial-Heaps-2011-02-11.tar.gz">
	afp-Binomial-Heaps-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Binomial-Heaps-2010-10-28.tar.gz">
	afp-Binomial-Heaps-2010-10-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Binomial-Queues.html b/web/entries/Binomial-Queues.html
	--- a/web/entries/Binomial-Queues.html
	+++ b/web/entries/Binomial-Queues.html
	@@ -1,224 +1,229 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Functional Binomial Queues - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>unctional

	<font class="first">B</font>inomial

	<font class="first">Q</font>ueues

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Functional Binomial Queues</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	René Neumann (rene /dot/ neumann /at/ in /dot/ tum /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-10-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Priority queues are an important data structure and efficient implementations of them are crucial. We implement a functional variant of binomial queues in Isabelle/HOL and show its functional correctness. A verification against an abstract reference specification of priority queues has also been attempted, but could not be achieved to the full extent.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Binomial-Queues-AFP,
	author = {René Neumann},
	title = {Functional Binomial Queues},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Binomial-Queues.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Binomial-Queues/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Binomial-Queues/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Binomial-Queues/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Binomial-Queues-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Binomial-Queues-2018-08-16.tar.gz">
	+ afp-Binomial-Queues-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Binomial-Queues-2017-10-10.tar.gz">
	afp-Binomial-Queues-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Binomial-Queues-2016-12-17.tar.gz">
	afp-Binomial-Queues-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Binomial-Queues-2016-02-22.tar.gz">
	afp-Binomial-Queues-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Binomial-Queues-2015-05-27.tar.gz">
	afp-Binomial-Queues-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Binomial-Queues-2014-08-28.tar.gz">
	afp-Binomial-Queues-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Binomial-Queues-2013-12-11.tar.gz">
	afp-Binomial-Queues-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Binomial-Queues-2013-11-17.tar.gz">
	afp-Binomial-Queues-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Binomial-Queues-2013-02-16.tar.gz">
	afp-Binomial-Queues-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Binomial-Queues-2012-05-24.tar.gz">
	afp-Binomial-Queues-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Binomial-Queues-2011-10-11.tar.gz">
	afp-Binomial-Queues-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Binomial-Queues-2011-02-11.tar.gz">
	afp-Binomial-Queues-2011-02-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Bondy.html b/web/entries/Bondy.html
	--- a/web/entries/Bondy.html
	+++ b/web/entries/Bondy.html
	@@ -1,213 +1,218 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Bondy's Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>ondy's

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Bondy's Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.andrew.cmu.edu/user/avigad/">Jeremy Avigad</a> and
	<a href="http://www.logic.at/people/hetzl/">Stefan Hetzl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-10-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">A proof of Bondy's theorem following B. Bollabas, Combinatorics, 1986, Cambridge University Press.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Bondy-AFP,
	author = {Jeremy Avigad and Stefan Hetzl},
	title = {Bondy's Theorem},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Bondy.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bondy/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Bondy/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bondy/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Bondy-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Bondy-2018-08-16.tar.gz">
	+ afp-Bondy-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Bondy-2017-10-10.tar.gz">
	afp-Bondy-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Bondy-2016-12-17.tar.gz">
	afp-Bondy-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Bondy-2016-02-22.tar.gz">
	afp-Bondy-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Bondy-2015-05-27.tar.gz">
	afp-Bondy-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Bondy-2014-08-28.tar.gz">
	afp-Bondy-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Bondy-2013-12-11.tar.gz">
	afp-Bondy-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Bondy-2013-11-17.tar.gz">
	afp-Bondy-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Bondy-2013-02-16.tar.gz">
	afp-Bondy-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Bondy-2012-10-27.tar.gz">
	afp-Bondy-2012-10-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Boolean_Expression_Checkers.html b/web/entries/Boolean_Expression_Checkers.html
	--- a/web/entries/Boolean_Expression_Checkers.html
	+++ b/web/entries/Boolean_Expression_Checkers.html
	@@ -1,209 +1,214 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Boolean Expression Checkers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>oolean

	<font class="first">E</font>xpression

	<font class="first">C</font>heckers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Boolean Expression Checkers</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-06-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides executable checkers for the following properties of
	boolean expressions: satisfiability, tautology and equivalence. Internally,
	the checkers operate on binary decision trees and are reasonably efficient
	(for purely functional algorithms).</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-09-23]: Salomon Sickert added an interface that does not require the usage of the Boolean formula datatype. Furthermore the general Mapping type is used instead of an association list.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Boolean_Expression_Checkers-AFP,
	author = {Tobias Nipkow},
	title = {Boolean Expression Checkers},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Boolean_Expression_Checkers.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="LTL.html">LTL</a>, <a href="LTL_to_DRA.html">LTL_to_DRA</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Boolean_Expression_Checkers/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Boolean_Expression_Checkers/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Boolean_Expression_Checkers/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Boolean_Expression_Checkers-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Boolean_Expression_Checkers-2018-08-16.tar.gz">
	+ afp-Boolean_Expression_Checkers-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Boolean_Expression_Checkers-2017-10-10.tar.gz">
	afp-Boolean_Expression_Checkers-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Boolean_Expression_Checkers-2016-12-17.tar.gz">
	afp-Boolean_Expression_Checkers-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Boolean_Expression_Checkers-2016-02-22.tar.gz">
	afp-Boolean_Expression_Checkers-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Boolean_Expression_Checkers-2015-05-27.tar.gz">
	afp-Boolean_Expression_Checkers-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Boolean_Expression_Checkers-2014-08-28.tar.gz">
	afp-Boolean_Expression_Checkers-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Boolean_Expression_Checkers-2014-06-08.tar.gz">
	afp-Boolean_Expression_Checkers-2014-06-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Bounded_Deducibility_Security.html b/web/entries/Bounded_Deducibility_Security.html
	--- a/web/entries/Bounded_Deducibility_Security.html
	+++ b/web/entries/Bounded_Deducibility_Security.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Bounded-Deducibility Security - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>ounded-Deducibility

	<font class="first">S</font>ecurity

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Bounded-Deducibility Security</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk) and
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-04-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This is a formalization of bounded-deducibility security (BD
	security), a flexible notion of information-flow security applicable
	to arbitrary input-output automata. It generalizes Sutherland's
	classic notion of nondeducibility by factoring in declassification
	bounds and trigger, whereas nondeducibility states that, in a
	system, information cannot flow between specified sources and sinks,
	BD security indicates upper bounds for the flow and triggers under
	which these upper bounds are no longer guaranteed.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Bounded_Deducibility_Security-AFP,
	author = {Andrei Popescu and Peter Lammich},
	title = {Bounded-Deducibility Security},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Bounded_Deducibility_Security.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bounded_Deducibility_Security/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Bounded_Deducibility_Security/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Bounded_Deducibility_Security/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Bounded_Deducibility_Security-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Bounded_Deducibility_Security-2018-08-16.tar.gz">
	+ afp-Bounded_Deducibility_Security-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Bounded_Deducibility_Security-2017-10-10.tar.gz">
	afp-Bounded_Deducibility_Security-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Bounded_Deducibility_Security-2016-12-17.tar.gz">
	afp-Bounded_Deducibility_Security-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Bounded_Deducibility_Security-2016-02-22.tar.gz">
	afp-Bounded_Deducibility_Security-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Bounded_Deducibility_Security-2015-05-27.tar.gz">
	afp-Bounded_Deducibility_Security-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Bounded_Deducibility_Security-2014-08-28.tar.gz">
	afp-Bounded_Deducibility_Security-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Bounded_Deducibility_Security-2014-04-24.tar.gz">
	afp-Bounded_Deducibility_Security-2014-04-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Buchi_Complementation.html b/web/entries/Buchi_Complementation.html
	--- a/web/entries/Buchi_Complementation.html
	+++ b/web/entries/Buchi_Complementation.html
	@@ -1,183 +1,188 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Büchi Complementation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>üchi

	<font class="first">C</font>omplementation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Büchi Complementation</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~brunnerj/">Julian Brunner</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-10-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides a verified implementation of rank-based Büchi
	Complementation. The verification is done in three steps: <ol>
	<li>Definition of odd rankings and proof that an automaton
	rejects a word iff there exists an odd ranking for it.</li>
	<li>Definition of the complement automaton and proof that it
	accepts exactly those words for which there is an odd
	ranking.</li> <li>Verified implementation of the
	complement automaton using the Isabelle Collections
	Framework.</li> </ol></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Buchi_Complementation-AFP,
	author = {Julian Brunner},
	title = {Büchi Complementation},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Buchi_Complementation.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Transition_Systems_and_Automata.html">Transition_Systems_and_Automata</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Buchi_Complementation/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Buchi_Complementation/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Buchi_Complementation/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Buchi_Complementation-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Buchi_Complementation-2018-08-16.tar.gz">
	+ afp-Buchi_Complementation-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Buchi_Complementation-2017-10-27.tar.gz">
	afp-Buchi_Complementation-2017-10-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Budan_Fourier.html b/web/entries/Budan_Fourier.html
	--- a/web/entries/Budan_Fourier.html
	+++ b/web/entries/Budan_Fourier.html
	@@ -1,199 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Budan-Fourier Theorem and Counting Real Roots with Multiplicity - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">B</font>udan-Fourier

	<font class="first">T</font>heorem

	and

	<font class="first">C</font>ounting

	<font class="first">R</font>eal

	<font class="first">R</font>oots

	with

	<font class="first">M</font>ultiplicity

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Budan-Fourier Theorem and Counting Real Roots with Multiplicity</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-09-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry is mainly about counting and approximating real roots (of a
	polynomial) with multiplicity. We have first formalised the
	Budan-Fourier theorem: given a polynomial with real coefficients, we
	can calculate sign variations on Fourier sequences to over-approximate
	the number of real roots (counting multiplicity) within an interval.
	When all roots are known to be real, the over-approximation becomes
	tight: we can utilise this theorem to count real roots exactly. It is
	also worth noting that Descartes' rule of sign is a direct
	consequence of the Budan-Fourier theorem, and has been included in
	this entry. In addition, we have extended previous formalised
	Sturm's theorem to count real roots with multiplicity, while the
	original Sturm's theorem only counts distinct real roots.
	Compared to the Budan-Fourier theorem, our extended Sturm's
	theorem always counts roots exactly but may suffer from greater
	computational cost.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Budan_Fourier-AFP,
	author = {Wenda Li},
	title = {The Budan-Fourier Theorem and Counting Real Roots with Multiplicity},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Budan_Fourier.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Sturm_Tarski.html">Sturm_Tarski</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Winding_Number_Eval.html">Winding_Number_Eval</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Budan_Fourier/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Budan_Fourier/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Budan_Fourier/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Budan_Fourier-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Budan_Fourier-2018-09-04.tar.gz">
	+ afp-Budan_Fourier-2018-09-04.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Buffons_Needle.html b/web/entries/Buffons_Needle.html
	--- a/web/entries/Buffons_Needle.html
	+++ b/web/entries/Buffons_Needle.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Buffon's Needle Problem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>uffon's

	<font class="first">N</font>eedle

	<font class="first">P</font>roblem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Buffon's Needle Problem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-06-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	In the 18th century, Georges-Louis Leclerc, Comte de Buffon posed and
	later solved the following problem, which is often called the first
	problem ever solved in geometric probability: Given a floor divided
	into vertical strips of the same width, what is the probability that a
	needle thrown onto the floor randomly will cross two strips? This
	entry formally defines the problem in the case where the needle's
	position is chosen uniformly at random in a single strip around the
	origin (which is equivalent to larger arrangements due to symmetry).
	It then provides proofs of the simple solution in the case where the
	needle's length is no greater than the width of the strips and
	the more complicated solution in the opposite case.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Buffons_Needle-AFP,
	author = {Manuel Eberl},
	title = {Buffon's Needle Problem},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Buffons_Needle.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Buffons_Needle/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Buffons_Needle/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Buffons_Needle/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Buffons_Needle-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Buffons_Needle-2018-08-16.tar.gz">
	+ afp-Buffons_Needle-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Buffons_Needle-2017-10-10.tar.gz">
	afp-Buffons_Needle-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Buffons_Needle-2017-06-06.tar.gz">
	afp-Buffons_Needle-2017-06-06.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Buildings.html b/web/entries/Buildings.html
	--- a/web/entries/Buildings.html
	+++ b/web/entries/Buildings.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Chamber Complexes, Coxeter Systems, and Buildings - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>hamber

	<font class="first">C</font>omplexes,

	<font class="first">C</font>oxeter

	<font class="first">S</font>ystems,

	and

	<font class="first">B</font>uildings

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Chamber Complexes, Coxeter Systems, and Buildings</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://ualberta.ca/~jsylvest/">Jeremy Sylvestre</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-07-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We provide a basic formal framework for the theory of chamber
	complexes and Coxeter systems, and for buildings as thick chamber
	complexes endowed with a system of apartments. Along the way, we
	develop some of the general theory of abstract simplicial complexes
	and of groups (relying on the <i>group_add</i> class for the basics),
	including free groups and group presentations, and their universal
	properties. The main results verified are that the deletion condition
	is both necessary and sufficient for a group with a set of generators
	of order two to be a Coxeter system, and that the apartments in a
	(thick) building are all uniformly Coxeter.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Buildings-AFP,
	author = {Jeremy Sylvestre},
	title = {Chamber Complexes, Coxeter Systems, and Buildings},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Buildings.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Buildings/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Buildings/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Buildings/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Buildings-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Buildings-2018-08-16.tar.gz">
	+ afp-Buildings-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Buildings-2017-10-10.tar.gz">
	afp-Buildings-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Buildings-2016-12-17.tar.gz">
	afp-Buildings-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Buildings-2016-07-01.tar.gz">
	afp-Buildings-2016-07-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/BytecodeLogicJmlTypes.html b/web/entries/BytecodeLogicJmlTypes.html
	--- a/web/entries/BytecodeLogicJmlTypes.html
	+++ b/web/entries/BytecodeLogicJmlTypes.html
	@@ -1,253 +1,258 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Bytecode Logic for JML and Types - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">B</font>ytecode

	<font class="first">L</font>ogic

	for

	<font class="first">J</font>ML

	and

	<font class="first">T</font>ypes

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Bytecode Logic for JML and Types</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Lennart Beringer and
	<a href="http://www.tcs.informatik.uni-muenchen.de/~mhofmann">Martin Hofmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-12-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document contains the Isabelle/HOL sources underlying the paper <i>A bytecode logic for JML and types</i> by Beringer and Hofmann, updated to Isabelle 2008. We present a program logic for a subset of sequential Java bytecode that is suitable for representing both, features found in high-level specification language JML as well as interpretations of high-level type systems. To this end, we introduce a fine-grained collection of assertions, including strong invariants, local annotations and VDM-reminiscent partial-correctness specifications. Thanks to a goal-oriented structure and interpretation of judgements, verification may proceed without recourse to an additional control flow analysis. The suitability for interpreting intensional type systems is illustrated by the proof-carrying-code style encoding of a type system for a first-order functional language which guarantees a constant upper bound on the number of objects allocated throughout an execution, be the execution terminating or non-terminating. Like the published paper, the formal development is restricted to a comparatively small subset of the JVML, lacking (among other features) exceptions, arrays, virtual methods, and static fields. This shortcoming has been overcome meanwhile, as our paper has formed the basis of the Mobius base logic, a program logic for the full sequential fragment of the JVML. Indeed, the present formalisation formed the basis of a subsequent formalisation of the Mobius base logic in the proof assistant Coq, which includes a proof of soundness with respect to the Bicolano operational semantics by Pichardie.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{BytecodeLogicJmlTypes-AFP,
	author = {Lennart Beringer and Martin Hofmann},
	title = {A Bytecode Logic for JML and Types},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/BytecodeLogicJmlTypes.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BytecodeLogicJmlTypes/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/BytecodeLogicJmlTypes/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/BytecodeLogicJmlTypes/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-BytecodeLogicJmlTypes-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-BytecodeLogicJmlTypes-2018-08-16.tar.gz">
	+ afp-BytecodeLogicJmlTypes-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-BytecodeLogicJmlTypes-2017-10-10.tar.gz">
	afp-BytecodeLogicJmlTypes-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-BytecodeLogicJmlTypes-2016-12-17.tar.gz">
	afp-BytecodeLogicJmlTypes-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-BytecodeLogicJmlTypes-2016-02-22.tar.gz">
	afp-BytecodeLogicJmlTypes-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-BytecodeLogicJmlTypes-2015-05-27.tar.gz">
	afp-BytecodeLogicJmlTypes-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-BytecodeLogicJmlTypes-2014-08-28.tar.gz">
	afp-BytecodeLogicJmlTypes-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-BytecodeLogicJmlTypes-2013-12-11.tar.gz">
	afp-BytecodeLogicJmlTypes-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-BytecodeLogicJmlTypes-2013-11-17.tar.gz">
	afp-BytecodeLogicJmlTypes-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-BytecodeLogicJmlTypes-2013-02-16.tar.gz">
	afp-BytecodeLogicJmlTypes-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-BytecodeLogicJmlTypes-2012-05-24.tar.gz">
	afp-BytecodeLogicJmlTypes-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-BytecodeLogicJmlTypes-2011-10-11.tar.gz">
	afp-BytecodeLogicJmlTypes-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-BytecodeLogicJmlTypes-2011-02-11.tar.gz">
	afp-BytecodeLogicJmlTypes-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-BytecodeLogicJmlTypes-2010-06-30.tar.gz">
	afp-BytecodeLogicJmlTypes-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-BytecodeLogicJmlTypes-2009-12-12.tar.gz">
	afp-BytecodeLogicJmlTypes-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-BytecodeLogicJmlTypes-2009-04-29.tar.gz">
	afp-BytecodeLogicJmlTypes-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-BytecodeLogicJmlTypes-2008-12-22.tar.gz">
	afp-BytecodeLogicJmlTypes-2008-12-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CAVA_Automata.html b/web/entries/CAVA_Automata.html
	--- a/web/entries/CAVA_Automata.html
	+++ b/web/entries/CAVA_Automata.html
	@@ -1,229 +1,234 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The CAVA Automata Library - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">C</font>AVA

	<font class="first">A</font>utomata

	<font class="first">L</font>ibrary

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The CAVA Automata Library</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-05-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We report on the graph and automata library that is used in the fully
	verified LTL model checker CAVA.
	As most components of CAVA use some type of graphs or automata, a common
	automata library simplifies assembly of the components and reduces
	redundancy.
	<p>
	The CAVA Automata Library provides a hierarchy of graph and automata
	classes, together with some standard algorithms.
	Its object oriented design allows for sharing of algorithms, theorems,
	and implementations between its classes, and also simplifies extensions
	of the library.
	Moreover, it is integrated into the Automatic Refinement Framework,
	supporting automatic refinement of the abstract automata types to
	efficient data structures.
	<p>
	Note that the CAVA Automata Library is work in progress. Currently, it
	is very specifically tailored towards the requirements of the CAVA model
	checker.
	Nevertheless, the formalization techniques presented here allow an
	extension of the library to a wider scope. Moreover, they are not
	limited to graph libraries, but apply to class hierarchies in general.
	<p>
	The CAVA Automata Library is described in the paper: Peter Lammich, The
	CAVA Automata Library, Isabelle Workshop 2014.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CAVA_Automata-AFP,
	author = {Peter Lammich},
	title = {The CAVA Automata Library},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/CAVA_Automata.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="Deriving.html">Deriving</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CAVA_LTL_Modelchecker.html">CAVA_LTL_Modelchecker</a>, <a href="Collections.html">Collections</a>, <a href="DFS_Framework.html">DFS_Framework</a>, <a href="Flow_Networks.html">Flow_Networks</a>, <a href="Formal_SSA.html">Formal_SSA</a>, <a href="Gabow_SCC.html">Gabow_SCC</a>, <a href="LTL_to_GBA.html">LTL_to_GBA</a>, <a href="Promela.html">Promela</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CAVA_Automata/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CAVA_Automata/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CAVA_Automata/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CAVA_Automata-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CAVA_Automata-2018-08-16.tar.gz">
	+ afp-CAVA_Automata-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CAVA_Automata-2017-10-10.tar.gz">
	afp-CAVA_Automata-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CAVA_Automata-2016-12-17.tar.gz">
	afp-CAVA_Automata-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-CAVA_Automata-2016-02-22.tar.gz">
	afp-CAVA_Automata-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-CAVA_Automata-2015-05-27.tar.gz">
	afp-CAVA_Automata-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-CAVA_Automata-2014-08-28.tar.gz">
	afp-CAVA_Automata-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-CAVA_Automata-2014-05-29.tar.gz">
	afp-CAVA_Automata-2014-05-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CAVA_LTL_Modelchecker.html b/web/entries/CAVA_LTL_Modelchecker.html
	--- a/web/entries/CAVA_LTL_Modelchecker.html
	+++ b/web/entries/CAVA_LTL_Modelchecker.html
	@@ -1,235 +1,240 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Fully Verified Executable LTL Model Checker - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">F</font>ully

	<font class="first">V</font>erified

	<font class="first">E</font>xecutable

	<font class="first">L</font>TL

	<font class="first">M</font>odel

	<font class="first">C</font>hecker

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Fully Verified Executable LTL Model Checker</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www7.in.tum.de/~esparza/">Javier Esparza</a>,
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>,
	René Neumann (rene /dot/ neumann /at/ in /dot/ tum /dot/ de),
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>,
	Alexander Schimpf (schimpfa /at/ informatik /dot/ uni-freiburg /dot/ de) and
	<a href="http://www.irit.fr/~Jan-Georg.Smaus">Jan-Georg Smaus</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-05-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	<p>
	An early version of this model checker is described in the
	<a href="http://www21.in.tum.de/~nipkow/pubs/cav13.html">CAV 2013 paper</a>
	with the same title.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/CAVA_LTL_Modelchecker.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CAVA_Automata.html">CAVA_Automata</a>, <a href="DFS_Framework.html">DFS_Framework</a>, <a href="Gabow_SCC.html">Gabow_SCC</a>, <a href="LTL_to_GBA.html">LTL_to_GBA</a>, <a href="Partial_Order_Reduction.html">Partial_Order_Reduction</a>, <a href="Promela.html">Promela</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CAVA_LTL_Modelchecker/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CAVA_LTL_Modelchecker/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CAVA_LTL_Modelchecker/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CAVA_LTL_Modelchecker-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CAVA_LTL_Modelchecker-2018-08-16.tar.gz">
	+ afp-CAVA_LTL_Modelchecker-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CAVA_LTL_Modelchecker-2017-10-10.tar.gz">
	afp-CAVA_LTL_Modelchecker-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CAVA_LTL_Modelchecker-2016-12-17.tar.gz">
	afp-CAVA_LTL_Modelchecker-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-CAVA_LTL_Modelchecker-2016-02-22.tar.gz">
	afp-CAVA_LTL_Modelchecker-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-CAVA_LTL_Modelchecker-2015-05-27.tar.gz">
	afp-CAVA_LTL_Modelchecker-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-CAVA_LTL_Modelchecker-2014-08-28.tar.gz">
	afp-CAVA_LTL_Modelchecker-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-CAVA_LTL_Modelchecker-2014-05-30.tar.gz">
	afp-CAVA_LTL_Modelchecker-2014-05-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-CAVA_LTL_Modelchecker-2014-05-29.tar.gz">
	afp-CAVA_LTL_Modelchecker-2014-05-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CCS.html b/web/entries/CCS.html
	--- a/web/entries/CCS.html
	+++ b/web/entries/CCS.html
	@@ -1,218 +1,223 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>CCS in nominal logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>CS

	in

	nominal

	logic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">CCS in nominal logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.itu.dk/people/jebe">Jesper Bengtson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-05-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalise a large portion of CCS as described in Milner's book 'Communication and Concurrency' using the nominal datatype package in Isabelle. Our results include many of the standard theorems of bisimulation equivalence and congruence, for both weak and strong versions. One main goal of this formalisation is to keep the machine-checked proofs as close to their pen-and-paper counterpart as possible.
	<p>
	This entry is described in detail in <a href="http://www.itu.dk/people/jebe/files/thesis.pdf">Bengtson's thesis</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CCS-AFP,
	author = {Jesper Bengtson},
	title = {CCS in nominal logic},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/CCS.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CCS/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CCS/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CCS/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CCS-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CCS-2018-08-16.tar.gz">
	+ afp-CCS-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CCS-2017-10-10.tar.gz">
	afp-CCS-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CCS-2016-12-17.tar.gz">
	afp-CCS-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-CCS-2016-02-22.tar.gz">
	afp-CCS-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-CCS-2015-05-27.tar.gz">
	afp-CCS-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-CCS-2014-08-28.tar.gz">
	afp-CCS-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-CCS-2013-12-11.tar.gz">
	afp-CCS-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-CCS-2013-11-17.tar.gz">
	afp-CCS-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-CCS-2013-02-16.tar.gz">
	afp-CCS-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-CCS-2012-06-14.tar.gz">
	afp-CCS-2012-06-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CISC-Kernel.html b/web/entries/CISC-Kernel.html
	--- a/web/entries/CISC-Kernel.html
	+++ b/web/entries/CISC-Kernel.html
	@@ -1,230 +1,235 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formal Specification of a Generic Separation Kernel - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormal

	<font class="first">S</font>pecification

	of

	a

	<font class="first">G</font>eneric

	<font class="first">S</font>eparation

	<font class="first">K</font>ernel

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formal Specification of a Generic Separation Kernel</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Freek Verbeek (Freek /dot/ Verbeek /at/ ou /dot/ nl),
	Sergey Tverdyshev (stv /at/ sysgo /dot/ com),
	Oto Havle (oha /at/ sysgo /dot/ com),
	Holger Blasum (holger /dot/ blasum /at/ sysgo /dot/ com),
	Bruno Langenstein (langenstein /at/ dfki /dot/ de),
	Werner Stephan (stephan /at/ dfki /dot/ de),
	Yakoub Nemouchi (yakoub /dot/ nemouchi /at/ york /dot/ ac /dot/ uk),
	Abderrahmane Feliachi (abderrahmane /dot/ feliachi /at/ lri /dot/ fr),
	Burkhart Wolff (wolff /at/ lri /dot/ fr) and
	Julien Schmaltz (Julien /dot/ Schmaltz /at/ ou /dot/ nl)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-07-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>Intransitive noninterference has been a widely studied topic in the last
	few decades. Several well-established methodologies apply interactive
	theorem proving to formulate a noninterference theorem over abstract
	academic models. In joint work with several industrial and academic partners
	throughout Europe, we are helping in the certification process of PikeOS, an
	industrial separation kernel developed at SYSGO. In this process,
	established theories could not be applied. We present a new generic model of
	separation kernels and a new theory of intransitive noninterference. The
	model is rich in detail, making it suitable for formal verification of
	realistic and industrial systems such as PikeOS. Using a refinement-based
	theorem proving approach, we ensure that proofs remain manageable.</p>
	<p>
	This document corresponds to the deliverable D31.1 of the EURO-MILS
	Project <a href="http://www.euromils.eu">http://www.euromils.eu</a>.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CISC-Kernel-AFP,
	author = {Freek Verbeek and Sergey Tverdyshev and Oto Havle and Holger Blasum and Bruno Langenstein and Werner Stephan and Yakoub Nemouchi and Abderrahmane Feliachi and Burkhart Wolff and Julien Schmaltz},
	title = {Formal Specification of a Generic Separation Kernel},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/CISC-Kernel.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CISC-Kernel/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CISC-Kernel/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CISC-Kernel/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CISC-Kernel-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CISC-Kernel-2018-08-16.tar.gz">
	+ afp-CISC-Kernel-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CISC-Kernel-2017-10-10.tar.gz">
	afp-CISC-Kernel-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CISC-Kernel-2016-12-17.tar.gz">
	afp-CISC-Kernel-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-CISC-Kernel-2016-02-22.tar.gz">
	afp-CISC-Kernel-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-CISC-Kernel-2015-05-27.tar.gz">
	afp-CISC-Kernel-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-CISC-Kernel-2014-08-28.tar.gz">
	afp-CISC-Kernel-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-CISC-Kernel-2014-07-18.tar.gz">
	afp-CISC-Kernel-2014-07-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CRDT.html b/web/entries/CRDT.html
	--- a/web/entries/CRDT.html
	+++ b/web/entries/CRDT.html
	@@ -1,214 +1,219 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A framework for establishing Strong Eventual Consistency for Conflict-free Replicated Datatypes - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	framework

	for

	establishing

	<font class="first">S</font>trong

	<font class="first">E</font>ventual

	<font class="first">C</font>onsistency

	for

	<font class="first">C</font>onflict-free

	<font class="first">R</font>eplicated

	<font class="first">D</font>atatypes

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A framework for establishing Strong Eventual Consistency for Conflict-free Replicated Datatypes</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Victor B. F. Gomes (vb358 /at/ cl /dot/ cam /dot/ ac /dot/ uk),
	Martin Kleppmann (mk428 /at/ cl /dot/ cam /dot/ ac /dot/ uk),
	Dominic P. Mulligan (Dominic /dot/ Mulligan /at/ arm /dot/ com) and
	Alastair R. Beresford (arb33 /at/ cl /dot/ cam /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-07-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	In this work, we focus on the correctness of Conflict-free Replicated
	Data Types (CRDTs), a class of algorithm that provides strong eventual
	consistency guarantees for replicated data. We develop a modular and
	reusable framework for verifying the correctness of CRDT algorithms.
	We avoid correctness issues that have dogged previous mechanised
	proofs in this area by including a network model in our formalisation,
	and proving that our theorems hold in all possible network behaviours.
	Our axiomatic network model is a standard abstraction that accurately
	reflects the behaviour of real-world computer networks. Moreover, we
	identify an abstract convergence theorem, a property of order
	relations, which provides a formal definition of strong eventual
	consistency. We then obtain the first machine-checked correctness
	theorems for three concrete CRDTs: the Replicated Growable Array, the
	Observed-Remove Set, and an Increment-Decrement Counter.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CRDT-AFP,
	author = {Victor B. F. Gomes and Martin Kleppmann and Dominic P. Mulligan and Alastair R. Beresford},
	title = {A framework for establishing Strong Eventual Consistency for Conflict-free Replicated Datatypes},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/CRDT.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="IMAP-CRDT.html">IMAP-CRDT</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CRDT/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CRDT/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CRDT/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CRDT-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CRDT-2018-08-16.tar.gz">
	+ afp-CRDT-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CRDT-2017-10-10.tar.gz">
	afp-CRDT-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CRDT-2017-07-07.tar.gz">
	afp-CRDT-2017-07-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CYK.html b/web/entries/CYK.html
	--- a/web/entries/CYK.html
	+++ b/web/entries/CYK.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A formalisation of the Cocke-Younger-Kasami algorithm - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	formalisation

	of

	the

	<font class="first">C</font>ocke-Younger-Kasami

	algorithm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A formalisation of the Cocke-Younger-Kasami algorithm</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Maksym Bortin
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-04-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The theory provides a formalisation of the Cocke-Younger-Kasami
	algorithm (CYK for short), an approach to solving the word problem
	for context-free languages. CYK decides if a word is in the
	languages generated by a context-free grammar in Chomsky normal form.
	The formalized algorithm is executable.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CYK-AFP,
	author = {Maksym Bortin},
	title = {A formalisation of the Cocke-Younger-Kasami algorithm},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/CYK.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CYK/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CYK/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CYK/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CYK-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CYK-2018-08-16.tar.gz">
	+ afp-CYK-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CYK-2017-10-10.tar.gz">
	afp-CYK-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CYK-2016-12-17.tar.gz">
	afp-CYK-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-CYK-2016-04-27.tar.gz">
	afp-CYK-2016-04-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CakeML.html b/web/entries/CakeML.html
	--- a/web/entries/CakeML.html
	+++ b/web/entries/CakeML.html
	@@ -1,181 +1,187 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>CakeML - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>akeML

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">CakeML</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a> and
	Yu Zhang
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	Johannes Åman Pohjola
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-03-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	CakeML is a functional programming language with a proven-correct
	compiler and runtime system. This entry contains an unofficial version
	of the CakeML semantics that has been exported from the Lem
	specifications to Isabelle. Additionally, there are some hand-written
	theory files that adapt the exported code to Isabelle and port proofs
	from the HOL4 formalization, e.g. termination and equivalence proofs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CakeML-AFP,
	author = {Lars Hupel and Yu Zhang},
	title = {CakeML},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/CakeML.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a>, <a href="IEEE_Floating_Point.html">IEEE_Floating_Point</a>, <a href="Show.html">Show</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CakeML/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CakeML/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CakeML/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CakeML-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CakeML-2018-08-16.tar.gz">
	+ afp-CakeML-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Call_Arity.html b/web/entries/Call_Arity.html
	--- a/web/entries/Call_Arity.html
	+++ b/web/entries/Call_Arity.html
	@@ -1,232 +1,237 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Safety of Call Arity - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">S</font>afety

	of

	<font class="first">C</font>all

	<font class="first">A</font>rity

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Safety of Call Arity</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Joachim Breitner (joachim /at/ cis /dot/ upenn /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-02-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize the Call Arity analysis, as implemented in GHC, and prove
	both functional correctness and, more interestingly, safety (i.e. the
	transformation does not increase allocation).
	<p>
	We use syntax and the denotational semantics from the entry
	"Launchbury", where we formalized Launchbury's natural semantics for
	lazy evaluation.
	<p>
	The functional correctness of Call Arity is proved with regard to that
	denotational semantics. The operational properties are shown with
	regard to a small-step semantics akin to Sestoft's mark 1 machine,
	which we prove to be equivalent to Launchbury's semantics.
	<p>
	We use Christian Urban's Nominal2 package to define our terms and make
	use of Brian Huffman's HOLCF package for the domain-theoretical
	aspects of the development.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-03-16]: This entry now builds on top of the Launchbury entry,
	and the equivalency proof of the natural and the small-step semantics
	was added.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Call_Arity-AFP,
	author = {Joachim Breitner},
	title = {The Safety of Call Arity},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Call_Arity.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Launchbury.html">Launchbury</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Call_Arity/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Call_Arity/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Call_Arity/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Call_Arity-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Call_Arity-2018-08-16.tar.gz">
	+ afp-Call_Arity-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Call_Arity-2017-10-10.tar.gz">
	afp-Call_Arity-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Call_Arity-2016-12-17.tar.gz">
	afp-Call_Arity-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Call_Arity-2016-02-22.tar.gz">
	afp-Call_Arity-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Call_Arity-2015-05-27.tar.gz">
	afp-Call_Arity-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Call_Arity-2015-05-11.tar.gz">
	afp-Call_Arity-2015-05-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Call_Arity-2015-02-21.tar.gz">
	afp-Call_Arity-2015-02-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Call_Arity-2015-02-20.tar.gz">
	afp-Call_Arity-2015-02-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Card_Equiv_Relations.html b/web/entries/Card_Equiv_Relations.html
	--- a/web/entries/Card_Equiv_Relations.html
	+++ b/web/entries/Card_Equiv_Relations.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Cardinality of Equivalence Relations - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ardinality

	of

	<font class="first">E</font>quivalence

	<font class="first">R</font>elations

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Cardinality of Equivalence Relations</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides formulae for counting the number of equivalence
	relations and partial equivalence relations over a finite carrier set
	with given cardinality. To count the number of equivalence relations,
	we provide bijections between equivalence relations and set
	partitions, and then transfer the main results of the two AFP entries,
	Cardinality of Set Partitions and Spivey's Generalized Recurrence for
	Bell Numbers, to theorems on equivalence relations. To count the
	number of partial equivalence relations, we observe that counting
	partial equivalence relations over a set A is equivalent to counting
	all equivalence relations over all subsets of the set A. From this
	observation and the results on equivalence relations, we show that the
	cardinality of partial equivalence relations over a finite set of
	cardinality n is equal to the n+1-th Bell number.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Card_Equiv_Relations-AFP,
	author = {Lukas Bulwahn},
	title = {Cardinality of Equivalence Relations},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Card_Equiv_Relations.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Bell_Numbers_Spivey.html">Bell_Numbers_Spivey</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Card_Equiv_Relations/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Card_Equiv_Relations/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Card_Equiv_Relations/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Card_Equiv_Relations-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Card_Equiv_Relations-2018-08-16.tar.gz">
	+ afp-Card_Equiv_Relations-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Card_Equiv_Relations-2017-10-10.tar.gz">
	afp-Card_Equiv_Relations-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Card_Equiv_Relations-2016-12-17.tar.gz">
	afp-Card_Equiv_Relations-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Card_Equiv_Relations-2016-05-24.tar.gz">
	afp-Card_Equiv_Relations-2016-05-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Card_Multisets.html b/web/entries/Card_Multisets.html
	--- a/web/entries/Card_Multisets.html
	+++ b/web/entries/Card_Multisets.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Cardinality of Multisets - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ardinality

	of

	<font class="first">M</font>ultisets

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Cardinality of Multisets</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This entry provides three lemmas to count the number of multisets
	of a given size and finite carrier set. The first lemma provides a
	cardinality formula assuming that the multiset's elements are chosen
	from the given carrier set. The latter two lemmas provide formulas
	assuming that the multiset's elements also cover the given carrier
	set, i.e., each element of the carrier set occurs in the multiset at
	least once.</p> <p>The proof of the first lemma uses the argument of
	the recurrence relation for counting multisets. The proof of the
	second lemma is straightforward, and the proof of the third lemma is
	easily obtained using the first cardinality lemma. A challenge for the
	formalization is the derivation of the required induction rule, which
	is a special combination of the induction rules for finite sets and
	natural numbers. The induction rule is derived by defining a suitable
	inductive predicate and transforming the predicate's induction
	rule.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Card_Multisets-AFP,
	author = {Lukas Bulwahn},
	title = {Cardinality of Multisets},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Card_Multisets.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Twelvefold_Way.html">Twelvefold_Way</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Card_Multisets/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Card_Multisets/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Card_Multisets/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Card_Multisets-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Card_Multisets-2018-08-16.tar.gz">
	+ afp-Card_Multisets-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Card_Multisets-2017-10-10.tar.gz">
	afp-Card_Multisets-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Card_Multisets-2016-12-17.tar.gz">
	afp-Card_Multisets-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Card_Multisets-2016-06-26.tar.gz">
	afp-Card_Multisets-2016-06-26.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Card_Number_Partitions.html b/web/entries/Card_Number_Partitions.html
	--- a/web/entries/Card_Number_Partitions.html
	+++ b/web/entries/Card_Number_Partitions.html
	@@ -1,202 +1,207 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Cardinality of Number Partitions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ardinality

	of

	<font class="first">N</font>umber

	<font class="first">P</font>artitions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Cardinality of Number Partitions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-01-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides a basic library for number partitions, defines the
	two-argument partition function through its recurrence relation and relates
	this partition function to the cardinality of number partitions. The main
	proof shows that the recursively-defined partition function with arguments
	n and k equals the cardinality of number partitions of n with exactly k parts.
	The combinatorial proof follows the proof sketch of Theorem 2.4.1 in
	Mazur's textbook `Combinatorics: A Guided Tour`. This entry can serve as
	starting point for various more intrinsic properties about number partitions,
	the partition function and related recurrence relations.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Card_Number_Partitions-AFP,
	author = {Lukas Bulwahn},
	title = {Cardinality of Number Partitions},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Card_Number_Partitions.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Euler_Partition.html">Euler_Partition</a>, <a href="Twelvefold_Way.html">Twelvefold_Way</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Card_Number_Partitions/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Card_Number_Partitions/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Card_Number_Partitions/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Card_Number_Partitions-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Card_Number_Partitions-2018-08-16.tar.gz">
	+ afp-Card_Number_Partitions-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Card_Number_Partitions-2017-10-10.tar.gz">
	afp-Card_Number_Partitions-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Card_Number_Partitions-2016-12-17.tar.gz">
	afp-Card_Number_Partitions-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Card_Number_Partitions-2016-02-22.tar.gz">
	afp-Card_Number_Partitions-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Card_Number_Partitions-2016-01-14.tar.gz">
	afp-Card_Number_Partitions-2016-01-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Card_Partitions.html b/web/entries/Card_Partitions.html
	--- a/web/entries/Card_Partitions.html
	+++ b/web/entries/Card_Partitions.html
	@@ -1,204 +1,209 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Cardinality of Set Partitions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ardinality

	of

	<font class="first">S</font>et

	<font class="first">P</font>artitions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Cardinality of Set Partitions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The theory's main theorem states that the cardinality of set partitions of
	size k on a carrier set of size n is expressed by Stirling numbers of the
	second kind. In Isabelle, Stirling numbers of the second kind are defined
	in the AFP entry `Discrete Summation` through their well-known recurrence
	relation. The main theorem relates them to the alternative definition as
	cardinality of set partitions. The proof follows the simple and short
	explanation in Richard P. Stanley's `Enumerative Combinatorics: Volume 1`
	and Wikipedia, and unravels the full details and implicit reasoning steps
	of these explanations.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Card_Partitions-AFP,
	author = {Lukas Bulwahn},
	title = {Cardinality of Set Partitions},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Card_Partitions.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Discrete_Summation.html">Discrete_Summation</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Bell_Numbers_Spivey.html">Bell_Numbers_Spivey</a>, <a href="Falling_Factorial_Sum.html">Falling_Factorial_Sum</a>, <a href="Twelvefold_Way.html">Twelvefold_Way</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Card_Partitions/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Card_Partitions/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Card_Partitions/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Card_Partitions-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Card_Partitions-2018-08-16.tar.gz">
	+ afp-Card_Partitions-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Card_Partitions-2017-10-10.tar.gz">
	afp-Card_Partitions-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Card_Partitions-2016-12-17.tar.gz">
	afp-Card_Partitions-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Card_Partitions-2016-02-22.tar.gz">
	afp-Card_Partitions-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Card_Partitions-2015-12-13.tar.gz">
	afp-Card_Partitions-2015-12-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Cartan_FP.html b/web/entries/Cartan_FP.html
	--- a/web/entries/Cartan_FP.html
	+++ b/web/entries/Cartan_FP.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Cartan Fixed Point Theorems - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">C</font>artan

	<font class="first">F</font>ixed

	<font class="first">P</font>oint

	<font class="first">T</font>heorems

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Cartan Fixed Point Theorems</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-03-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The Cartan fixed point theorems concern the group of holomorphic
	automorphisms on a connected open set of C<sup>n</sup>. Ciolli et al.
	have formalised the one-dimensional case of these theorems in HOL
	Light. This entry contains their proofs, ported to Isabelle/HOL. Thus
	it addresses the authors' remark that "it would be important to write
	a formal proof in a language that can be read by both humans and
	machines".</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Cartan_FP-AFP,
	author = {Lawrence C. Paulson},
	title = {The Cartan Fixed Point Theorems},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Cartan_FP.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Cartan_FP/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Cartan_FP/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Cartan_FP/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Cartan_FP-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Cartan_FP-2018-08-16.tar.gz">
	+ afp-Cartan_FP-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Cartan_FP-2017-10-10.tar.gz">
	afp-Cartan_FP-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Cartan_FP-2016-12-17.tar.gz">
	afp-Cartan_FP-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Cartan_FP-2016-03-09.tar.gz">
	afp-Cartan_FP-2016-03-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Case_Labeling.html b/web/entries/Case_Labeling.html
	--- a/web/entries/Case_Labeling.html
	+++ b/web/entries/Case_Labeling.html
	@@ -1,216 +1,221 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Generating Cases from Labeled Subgoals - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>enerating

	<font class="first">C</font>ases

	from

	<font class="first">L</font>abeled

	<font class="first">S</font>ubgoals

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Generating Cases from Labeled Subgoals</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-07-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Isabelle/Isar provides named cases to structure proofs. This article
	contains an implementation of a proof method <tt>casify</tt>, which can
	be used to easily extend proof tools with support for named cases. Such
	a proof tool must produce labeled subgoals, which are then interpreted
	by <tt>casify</tt>.
	<p>
	As examples, this work contains verification condition generators
	producing named cases for three languages: The Hoare language from
	<tt>HOL/Library</tt>, a monadic language for computations with failure
	(inspired by the AutoCorres tool), and a language of conditional
	expressions. These VCGs are demonstrated by a number of example programs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Case_Labeling-AFP,
	author = {Lars Noschinski},
	title = {Generating Cases from Labeled Subgoals},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Case_Labeling.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Planarity_Certificates.html">Planarity_Certificates</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Case_Labeling/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Case_Labeling/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Case_Labeling/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Case_Labeling-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Case_Labeling-2018-08-16.tar.gz">
	+ afp-Case_Labeling-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Case_Labeling-2017-10-10.tar.gz">
	afp-Case_Labeling-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Case_Labeling-2016-12-17.tar.gz">
	afp-Case_Labeling-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Case_Labeling-2016-02-22.tar.gz">
	afp-Case_Labeling-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Case_Labeling-2015-08-17.tar.gz">
	afp-Case_Labeling-2015-08-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Case_Labeling-2015-07-27.tar.gz">
	afp-Case_Labeling-2015-07-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Case_Labeling-2015-07-24.tar.gz">
	afp-Case_Labeling-2015-07-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Catalan_Numbers.html b/web/entries/Catalan_Numbers.html
	--- a/web/entries/Catalan_Numbers.html
	+++ b/web/entries/Catalan_Numbers.html
	@@ -1,192 +1,197 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Catalan Numbers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>atalan

	<font class="first">N</font>umbers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Catalan Numbers</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>In this work, we define the Catalan numbers <em>C<sub>n</sub></em>
	and prove several equivalent definitions (including some closed-form
	formulae). We also show one of their applications (counting the number
	of binary trees of size <em>n</em>), prove the asymptotic growth
	approximation <em>C<sub>n</sub> &sim; 4<sup>n</sup> / (√<span
	style="text-decoration: overline">π</span> ·
	n<sup>1.5</sup>)</em>, and provide reasonably efficient executable
	code to compute them.</p> <p>The derivation of the closed-form
	formulae uses algebraic manipulations of the ordinary generating
	function of the Catalan numbers, and the asymptotic approximation is
	then done using generalised binomial coefficients and the Gamma
	function. Thanks to these highly non-elementary mathematical tools,
	the proofs are very short and simple.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Catalan_Numbers-AFP,
	author = {Manuel Eberl},
	title = {Catalan Numbers},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Catalan_Numbers.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Landau_Symbols.html">Landau_Symbols</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Catalan_Numbers/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Catalan_Numbers/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Catalan_Numbers/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Catalan_Numbers-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Catalan_Numbers-2018-08-16.tar.gz">
	+ afp-Catalan_Numbers-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Catalan_Numbers-2017-10-10.tar.gz">
	afp-Catalan_Numbers-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Catalan_Numbers-2016-12-17.tar.gz">
	afp-Catalan_Numbers-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Category.html b/web/entries/Category.html
	--- a/web/entries/Category.html
	+++ b/web/entries/Category.html
	@@ -1,277 +1,282 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Category Theory to Yoneda's Lemma - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ategory

	<font class="first">T</font>heory

	to

	<font class="first">Y</font>oneda's

	<font class="first">L</font>emma

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Category Theory to Yoneda's Lemma</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://users.rsise.anu.edu.au/~okeefe/">Greg O'Keefe</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2005-04-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This development proves Yoneda's lemma and aims to be readable by humans. It only defines what is needed for the lemma: categories, functors and natural transformations. Limits, adjunctions and other important concepts are not included.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2010-04-23]: The definition of the constant <tt>equinumerous</tt> was slightly too weak in the original submission and has been fixed in revision <a href="https://bitbucket.org/isa-afp/afp-devel/commits/8c2b5b3c995f">8c2b5b3c995f</a>.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Category-AFP,
	author = {Greg O'Keefe},
	title = {Category Theory to Yoneda's Lemma},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2005,
	note = {\url{http://isa-afp.org/entries/Category.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Category/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Category/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Category/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Category-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Category-2018-08-16.tar.gz">
	+ afp-Category-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Category-2017-10-10.tar.gz">
	afp-Category-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Category-2016-12-17.tar.gz">
	afp-Category-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Category-2016-02-22.tar.gz">
	afp-Category-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Category-2015-05-27.tar.gz">
	afp-Category-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Category-2014-08-28.tar.gz">
	afp-Category-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Category-2013-12-11.tar.gz">
	afp-Category-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Category-2013-11-17.tar.gz">
	afp-Category-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Category-2013-03-02.tar.gz">
	afp-Category-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Category-2013-02-16.tar.gz">
	afp-Category-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Category-2012-05-24.tar.gz">
	afp-Category-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Category-2011-10-11.tar.gz">
	afp-Category-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Category-2011-02-11.tar.gz">
	afp-Category-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Category-2010-06-30.tar.gz">
	afp-Category-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Category-2009-12-12.tar.gz">
	afp-Category-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Category-2009-04-29.tar.gz">
	afp-Category-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Category-2008-06-10.tar.gz">
	afp-Category-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Category-2007-11-27.tar.gz">
	afp-Category-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Category-2005-10-14.tar.gz">
	afp-Category-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Category-2005-05-01.tar.gz">
	afp-Category-2005-05-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Category-2005-04-21.tar.gz">
	afp-Category-2005-04-21.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Category2.html b/web/entries/Category2.html
	--- a/web/entries/Category2.html
	+++ b/web/entries/Category2.html
	@@ -1,237 +1,242 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Category Theory - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ategory

	<font class="first">T</font>heory

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Category Theory</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Alexander Katovsky (apk32 /at/ cam /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-06-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This article presents a development of Category Theory in Isabelle/HOL. A Category is defined using records and locales. Functors and Natural Transformations are also defined. The main result that has been formalized is that the Yoneda functor is a full and faithful embedding. We also formalize the completeness of many sorted monadic equational logic. Extensive use is made of the HOLZF theory in both cases. For an informal description see <a href="http://www.srcf.ucam.org/~apk32/Isabelle/Category/Cat.pdf">here [pdf]</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Category2-AFP,
	author = {Alexander Katovsky},
	title = {Category Theory},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Category2.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Category2/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Category2/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Category2/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Category2-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Category2-2018-08-16.tar.gz">
	+ afp-Category2-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Category2-2017-10-10.tar.gz">
	afp-Category2-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Category2-2016-12-17.tar.gz">
	afp-Category2-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Category2-2016-02-22.tar.gz">
	afp-Category2-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Category2-2015-05-27.tar.gz">
	afp-Category2-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Category2-2014-08-28.tar.gz">
	afp-Category2-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Category2-2013-12-11.tar.gz">
	afp-Category2-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Category2-2013-11-17.tar.gz">
	afp-Category2-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Category2-2013-03-02.tar.gz">
	afp-Category2-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Category2-2013-02-16.tar.gz">
	afp-Category2-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Category2-2012-05-24.tar.gz">
	afp-Category2-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Category2-2011-10-11.tar.gz">
	afp-Category2-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Category2-2011-02-11.tar.gz">
	afp-Category2-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Category2-2010-06-30.tar.gz">
	afp-Category2-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Category2-2010-06-21.tar.gz">
	afp-Category2-2010-06-21.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Category3.html b/web/entries/Category3.html
	--- a/web/entries/Category3.html
	+++ b/web/entries/Category3.html
	@@ -1,231 +1,236 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Category Theory with Adjunctions and Limits - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ategory

	<font class="first">T</font>heory

	with

	<font class="first">A</font>djunctions

	and

	<font class="first">L</font>imits

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Category Theory with Adjunctions and Limits</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Eugene W. Stark (stark /at/ cs /dot/ stonybrook /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This article attempts to develop a usable framework for doing category
	theory in Isabelle/HOL. Our point of view, which to some extent
	differs from that of the previous AFP articles on the subject, is to
	try to explore how category theory can be done efficaciously within
	HOL, rather than trying to match exactly the way things are done using
	a traditional approach. To this end, we define the notion of category
	in an "object-free" style, in which a category is represented by a
	single partial composition operation on arrows. This way of defining
	categories provides some advantages in the context of HOL, including
	the ability to avoid the use of records and the possibility of
	defining functors and natural transformations simply as certain
	functions on arrows, rather than as composite objects. We define
	various constructions associated with the basic notions, including:
	dual category, product category, functor category, discrete category,
	free category, functor composition, and horizontal and vertical
	composite of natural transformations. A "set category" locale is
	defined that axiomatizes the notion "category of all sets at a type
	and all functions between them," and a fairly extensive set of
	properties of set categories is derived from the locale assumptions.
	The notion of a set category is used to prove the Yoneda Lemma in a
	general setting of a category equipped with a "hom embedding," which
	maps arrows of the category to the "universe" of the set category. We
	also give a treatment of adjunctions, defining adjunctions via left
	and right adjoint functors, natural bijections between hom-sets, and
	unit and counit natural transformations, and showing the equivalence
	of these definitions. We also develop the theory of limits, including
	representations of functors, diagrams and cones, and diagonal
	functors. We show that right adjoint functors preserve limits, and
	that limits can be constructed via products and equalizers. We
	characterize the conditions under which limits exist in a set
	category. We also examine the case of limits in a functor category,
	ultimately culminating in a proof that the Yoneda embedding preserves
	limits.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-05-29]:
	Revised axioms for the category locale. Introduced notation for composition and "in hom".
	(revision 8318366d4575)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Category3-AFP,
	author = {Eugene W. Stark},
	title = {Category Theory with Adjunctions and Limits},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Category3.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="MonoidalCategory.html">MonoidalCategory</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Category3/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Category3/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Category3/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Category3-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Category3-2018-08-16.tar.gz">
	+ afp-Category3-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Category3-2017-10-10.tar.gz">
	afp-Category3-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Category3-2016-12-17.tar.gz">
	afp-Category3-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Category3-2016-06-26.tar.gz">
	afp-Category3-2016-06-26.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Cauchy.html b/web/entries/Cauchy.html
	--- a/web/entries/Cauchy.html
	+++ b/web/entries/Cauchy.html
	@@ -1,264 +1,269 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Cauchy's Mean Theorem and the Cauchy-Schwarz Inequality - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>auchy's

	<font class="first">M</font>ean

	<font class="first">T</font>heorem

	and

	the

	<font class="first">C</font>auchy-Schwarz

	<font class="first">I</font>nequality

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Cauchy's Mean Theorem and the Cauchy-Schwarz Inequality</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Benjamin Porter
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2006-03-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document presents the mechanised proofs of two popular theorems attributed to Augustin Louis Cauchy - Cauchy's Mean Theorem and the Cauchy-Schwarz Inequality.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Cauchy-AFP,
	author = {Benjamin Porter},
	title = {Cauchy's Mean Theorem and the Cauchy-Schwarz Inequality},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2006,
	note = {\url{http://isa-afp.org/entries/Cauchy.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Sqrt_Babylonian.html">Sqrt_Babylonian</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Cauchy/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Cauchy/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Cauchy/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Cauchy-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Cauchy-2018-08-16.tar.gz">
	+ afp-Cauchy-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Cauchy-2017-10-10.tar.gz">
	afp-Cauchy-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Cauchy-2016-12-17.tar.gz">
	afp-Cauchy-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Cauchy-2016-02-22.tar.gz">
	afp-Cauchy-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Cauchy-2015-05-27.tar.gz">
	afp-Cauchy-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Cauchy-2014-08-28.tar.gz">
	afp-Cauchy-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Cauchy-2013-12-11.tar.gz">
	afp-Cauchy-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Cauchy-2013-11-17.tar.gz">
	afp-Cauchy-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Cauchy-2013-02-16.tar.gz">
	afp-Cauchy-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Cauchy-2012-05-24.tar.gz">
	afp-Cauchy-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Cauchy-2011-10-11.tar.gz">
	afp-Cauchy-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Cauchy-2011-02-11.tar.gz">
	afp-Cauchy-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Cauchy-2010-06-30.tar.gz">
	afp-Cauchy-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Cauchy-2009-12-12.tar.gz">
	afp-Cauchy-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Cauchy-2009-04-29.tar.gz">
	afp-Cauchy-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Cauchy-2008-06-10.tar.gz">
	afp-Cauchy-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Cauchy-2007-11-27.tar.gz">
	afp-Cauchy-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Cauchy-2006-03-14.tar.gz">
	afp-Cauchy-2006-03-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Cayley_Hamilton.html b/web/entries/Cayley_Hamilton.html
	--- a/web/entries/Cayley_Hamilton.html
	+++ b/web/entries/Cayley_Hamilton.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Cayley-Hamilton Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">C</font>ayley-Hamilton

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Cayley-Hamilton Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://nm.wu.ac.at/nm/sadelsbe">Stephan Adelsberger</a>,
	<a href="http://www.logic.at/people/hetzl/">Stefan Hetzl</a> and
	Florian Pollak (florian /dot/ pollak /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-09-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This document contains a proof of the Cayley-Hamilton theorem
	based on the development of matrices in HOL/Multivariate Analysis.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Cayley_Hamilton-AFP,
	author = {Stephan Adelsberger and Stefan Hetzl and Florian Pollak},
	title = {The Cayley-Hamilton Theorem},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Cayley_Hamilton.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Echelon_Form.html">Echelon_Form</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Cayley_Hamilton/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Cayley_Hamilton/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Cayley_Hamilton/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Cayley_Hamilton-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Cayley_Hamilton-2018-08-16.tar.gz">
	+ afp-Cayley_Hamilton-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Cayley_Hamilton-2017-10-10.tar.gz">
	afp-Cayley_Hamilton-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Cayley_Hamilton-2016-12-17.tar.gz">
	afp-Cayley_Hamilton-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Cayley_Hamilton-2016-02-22.tar.gz">
	afp-Cayley_Hamilton-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Cayley_Hamilton-2015-05-27.tar.gz">
	afp-Cayley_Hamilton-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Cayley_Hamilton-2014-09-16.tar.gz">
	afp-Cayley_Hamilton-2014-09-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Certification_Monads.html b/web/entries/Certification_Monads.html
	--- a/web/entries/Certification_Monads.html
	+++ b/web/entries/Certification_Monads.html
	@@ -1,197 +1,202 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Certification Monads - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ertification

	<font class="first">M</font>onads

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Certification Monads</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-10-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This entry provides several monads intended for the development of stand-alone certifiers via code generation from Isabelle/HOL. More specifically, there are three flavors of error monads (the sum type, for the case where all monadic functions are total; an instance of the former, the so called check monad, yielding either success without any further information or an error message; as well as a variant of the sum type that accommodates partial functions by providing an explicit bottom element) and a parser monad built on top. All of this monads are heavily used in the IsaFoR/CeTA project which thus provides many examples of their usage.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Certification_Monads-AFP,
	author = {Christian Sternagel and René Thiemann},
	title = {Certification Monads},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Certification_Monads.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Partial_Function_MR.html">Partial_Function_MR</a>, <a href="Show.html">Show</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="XML.html">XML</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Certification_Monads/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Certification_Monads/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Certification_Monads/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Certification_Monads-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Certification_Monads-2018-08-16.tar.gz">
	+ afp-Certification_Monads-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Certification_Monads-2017-10-10.tar.gz">
	afp-Certification_Monads-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Certification_Monads-2016-12-17.tar.gz">
	afp-Certification_Monads-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Certification_Monads-2016-02-22.tar.gz">
	afp-Certification_Monads-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Certification_Monads-2015-05-27.tar.gz">
	afp-Certification_Monads-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Certification_Monads-2014-10-08.tar.gz">
	afp-Certification_Monads-2014-10-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Chord_Segments.html b/web/entries/Chord_Segments.html
	--- a/web/entries/Chord_Segments.html
	+++ b/web/entries/Chord_Segments.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Intersecting Chords Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>ntersecting

	<font class="first">C</font>hords

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Intersecting Chords Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-10-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides a geometric proof of the intersecting chords
	theorem. The theorem states that when two chords intersect each other
	inside a circle, the products of their segments are equal. After a
	short review of existing proofs in the literature, I decided to use a
	proof approach that employs reasoning about lengths of line segments,
	the orthogonality of two lines and the Pythagoras Law. Hence, one can
	understand the formalized proof easily with the knowledge of a few
	general geometric facts that are commonly taught in high-school. This
	theorem is the 55th theorem of the Top 100 Theorems list.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Chord_Segments-AFP,
	author = {Lukas Bulwahn},
	title = {Intersecting Chords Theorem},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Chord_Segments.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Triangle.html">Triangle</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Chord_Segments/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Chord_Segments/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Chord_Segments/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Chord_Segments-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Chord_Segments-2018-08-16.tar.gz">
	+ afp-Chord_Segments-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Chord_Segments-2017-10-10.tar.gz">
	afp-Chord_Segments-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Chord_Segments-2016-12-17.tar.gz">
	afp-Chord_Segments-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Chord_Segments-2016-10-11.tar.gz">
	afp-Chord_Segments-2016-10-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Circus.html b/web/entries/Circus.html
	--- a/web/entries/Circus.html
	+++ b/web/entries/Circus.html
	@@ -1,226 +1,231 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Isabelle/Circus - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>sabelle/Circus

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Isabelle/Circus</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Abderrahmane Feliachi (abderrahmane /dot/ feliachi /at/ lri /dot/ fr),
	Burkhart Wolff (wolff /at/ lri /dot/ fr) and
	Marie-Claude Gaudel (mcg /at/ lri /dot/ fr)
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	Makarius Wenzel (Makarius /dot/ wenzel /at/ lri /dot/ fr)
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-05-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The Circus specification language combines elements for complex data and behavior specifications, using an integration of Z and CSP with a refinement calculus. Its semantics is based on Hoare and He's Unifying Theories of Programming (UTP). Isabelle/Circus is a formalization of the UTP and the Circus language in Isabelle/HOL. It contains proof rules and tactic support that allows for proofs of refinement for Circus processes (involving both data and behavioral aspects).
	<p>
	The Isabelle/Circus environment supports a syntax for the semantic definitions which is close to textbook presentations of Circus. This article contains an extended version of corresponding VSTTE Paper together with the complete formal development of its underlying commented theories.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2014-06-05]: More polishing, shorter proofs, added Circus syntax, added Makarius Wenzel as contributor.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Circus-AFP,
	author = {Abderrahmane Feliachi and Burkhart Wolff and Marie-Claude Gaudel},
	title = {Isabelle/Circus},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Circus.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Circus/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Circus/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Circus/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Circus-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Circus-2018-08-16.tar.gz">
	+ afp-Circus-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Circus-2017-10-10.tar.gz">
	afp-Circus-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Circus-2016-12-17.tar.gz">
	afp-Circus-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Circus-2016-02-22.tar.gz">
	afp-Circus-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Circus-2015-05-27.tar.gz">
	afp-Circus-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Circus-2014-08-28.tar.gz">
	afp-Circus-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Circus-2013-12-11.tar.gz">
	afp-Circus-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Circus-2013-11-17.tar.gz">
	afp-Circus-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Circus-2013-02-16.tar.gz">
	afp-Circus-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Circus-2012-05-29.tar.gz">
	afp-Circus-2012-05-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/ClockSynchInst.html b/web/entries/ClockSynchInst.html
	--- a/web/entries/ClockSynchInst.html
	+++ b/web/entries/ClockSynchInst.html
	@@ -1,269 +1,274 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Instances of Schneider's generalized protocol of clock synchronization - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>nstances

	of

	<font class="first">S</font>chneider's

	generalized

	protocol

	of

	clock

	synchronization

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Instances of Schneider's generalized protocol of clock synchronization</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.cs.famaf.unc.edu.ar/~damian/">Damián Barsotti</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2006-03-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">F. B. Schneider ("Understanding protocols for Byzantine clock synchronization") generalizes a number of protocols for Byzantine fault-tolerant clock synchronization and presents a uniform proof for their correctness. In Schneider's schema, each processor maintains a local clock by periodically adjusting each value to one computed by a convergence function applied to the readings of all the clocks. Then, correctness of an algorithm, i.e. that the readings of two clocks at any time are within a fixed bound of each other, is based upon some conditions on the convergence function. To prove that a particular clock synchronization algorithm is correct it suffices to show that the convergence function used by the algorithm meets Schneider's conditions. Using the theorem prover Isabelle, we formalize the proofs that the convergence functions of two algorithms, namely, the Interactive Convergence Algorithm (ICA) of Lamport and Melliar-Smith and the Fault-tolerant Midpoint algorithm of Lundelius-Lynch, meet Schneider's conditions. Furthermore, we experiment on handling some parts of the proofs with fully automatic tools like ICS and CVC-lite. These theories are part of a joint work with Alwen Tiu and Leonor P. Nieto <a href="http://users.rsise.anu.edu.au/~tiu/clocksync.pdf">"Verification of Clock Synchronization Algorithms: Experiments on a combination of deductive tools"</a> in proceedings of AVOCS 2005. In this work the correctness of Schneider schema was also verified using Isabelle (entry <a href="GenClock.html">GenClock</a> in AFP).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{ClockSynchInst-AFP,
	author = {Damián Barsotti},
	title = {Instances of Schneider's generalized protocol of clock synchronization},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2006,
	note = {\url{http://isa-afp.org/entries/ClockSynchInst.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ClockSynchInst/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/ClockSynchInst/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ClockSynchInst/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-ClockSynchInst-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-ClockSynchInst-2018-08-16.tar.gz">
	+ afp-ClockSynchInst-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-ClockSynchInst-2017-10-10.tar.gz">
	afp-ClockSynchInst-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-ClockSynchInst-2016-12-17.tar.gz">
	afp-ClockSynchInst-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-ClockSynchInst-2016-02-22.tar.gz">
	afp-ClockSynchInst-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-ClockSynchInst-2015-05-27.tar.gz">
	afp-ClockSynchInst-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-ClockSynchInst-2014-08-28.tar.gz">
	afp-ClockSynchInst-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-ClockSynchInst-2013-12-11.tar.gz">
	afp-ClockSynchInst-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-ClockSynchInst-2013-11-17.tar.gz">
	afp-ClockSynchInst-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-ClockSynchInst-2013-03-02.tar.gz">
	afp-ClockSynchInst-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-ClockSynchInst-2013-02-16.tar.gz">
	afp-ClockSynchInst-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-ClockSynchInst-2012-05-24.tar.gz">
	afp-ClockSynchInst-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-ClockSynchInst-2011-10-11.tar.gz">
	afp-ClockSynchInst-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-ClockSynchInst-2011-02-11.tar.gz">
	afp-ClockSynchInst-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-ClockSynchInst-2010-06-30.tar.gz">
	afp-ClockSynchInst-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-ClockSynchInst-2009-12-12.tar.gz">
	afp-ClockSynchInst-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-ClockSynchInst-2009-04-29.tar.gz">
	afp-ClockSynchInst-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-ClockSynchInst-2008-06-10.tar.gz">
	afp-ClockSynchInst-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-ClockSynchInst-2007-11-27.tar.gz">
	afp-ClockSynchInst-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-ClockSynchInst-2006-03-15.tar.gz">
	afp-ClockSynchInst-2006-03-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CofGroups.html b/web/entries/CofGroups.html
	--- a/web/entries/CofGroups.html
	+++ b/web/entries/CofGroups.html
	@@ -1,259 +1,264 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>An Example of a Cofinitary Group in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>n

	<font class="first">E</font>xample

	of

	a

	<font class="first">C</font>ofinitary

	<font class="first">G</font>roup

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">An Example of a Cofinitary Group in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://kasterma.net">Bart Kastermans</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-08-04</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalize the usual proof that the group generated by the function k -> k + 1 on the integers gives rise to a cofinitary group.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CofGroups-AFP,
	author = {Bart Kastermans},
	title = {An Example of a Cofinitary Group in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/CofGroups.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CofGroups/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CofGroups/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CofGroups/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CofGroups-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CofGroups-2018-08-16.tar.gz">
	+ afp-CofGroups-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CofGroups-2017-10-10.tar.gz">
	afp-CofGroups-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CofGroups-2016-12-17.tar.gz">
	afp-CofGroups-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-CofGroups-2016-02-22.tar.gz">
	afp-CofGroups-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-CofGroups-2015-05-27.tar.gz">
	afp-CofGroups-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-CofGroups-2014-08-28.tar.gz">
	afp-CofGroups-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-CofGroups-2013-12-11.tar.gz">
	afp-CofGroups-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-CofGroups-2013-11-17.tar.gz">
	afp-CofGroups-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-CofGroups-2013-03-02.tar.gz">
	afp-CofGroups-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-CofGroups-2013-02-16.tar.gz">
	afp-CofGroups-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-CofGroups-2012-05-24.tar.gz">
	afp-CofGroups-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-CofGroups-2011-10-11.tar.gz">
	afp-CofGroups-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-CofGroups-2011-02-11.tar.gz">
	afp-CofGroups-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-CofGroups-2010-06-30.tar.gz">
	afp-CofGroups-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-CofGroups-2009-12-12.tar.gz">
	afp-CofGroups-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-CofGroups-2009-09-05.tar.gz">
	afp-CofGroups-2009-09-05.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-CofGroups-2009-08-09.tar.gz">
	afp-CofGroups-2009-08-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Coinductive.html b/web/entries/Coinductive.html
	--- a/web/entries/Coinductive.html
	+++ b/web/entries/Coinductive.html
	@@ -1,287 +1,292 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Coinductive - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>oinductive

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Coinductive</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	Johannes Hölzl (hoelzl /at/ in /dot/ tum /dot/ de)
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-02-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This article collects formalisations of general-purpose coinductive data types and sets. Currently, it contains coinductive natural numbers, coinductive lists, i.e. lazy lists or streams, infinite streams, coinductive terminated lists, coinductive resumptions, a library of operations on coinductive lists, and a version of König's lemma as an application for coinductive lists.<br>The initial theory was contributed by Paulson and Wenzel. Extensions and other coinductive formalisations of general interest are welcome.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2010-06-10]:
	coinductive lists: setup for quotient package
	(revision 015574f3bf3c)<br>
	[2010-06-28]:
	new codatatype terminated lazy lists
	(revision e12de475c558)<br>
	[2010-08-04]:
	terminated lazy lists: setup for quotient package;
	more lemmas
	(revision 6ead626f1d01)<br>
	[2010-08-17]:
	Koenig's lemma as an example application for coinductive lists
	(revision f81ce373fa96)<br>
	[2011-02-01]:
	lazy implementation of coinductive (terminated) lists for the code generator
	(revision 6034973dce83)<br>
	[2011-07-20]:
	new codatatype resumption
	(revision 811364c776c7)<br>
	[2012-06-27]:
	new codatatype stream with operations (with contributions by Peter Gammie)
	(revision dd789a56473c)<br>
	[2013-03-13]:
	construct codatatypes with the BNF package and adjust the definitions and proofs,
	setup for lifting and transfer packages
	(revision f593eda5b2c0)<br>
	[2013-09-20]:
	stream theory uses type and operations from HOL/BNF/Examples/Stream
	(revision 692809b2b262)<br>
	[2014-04-03]:
	ccpo structure on codatatypes used to define ldrop, ldropWhile, lfilter, lconcat as least fixpoint;
	ccpo topology on coinductive lists contributed by Johannes Hölzl;
	added examples
	(revision 23cd8156bd42)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Coinductive-AFP,
	author = {Andreas Lochbihler},
	title = {Coinductive},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Coinductive.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CakeML.html">CakeML</a>, <a href="CryptHOL.html">CryptHOL</a>, <a href="DynamicArchitectures.html">DynamicArchitectures</a>, <a href="JinjaThreads.html">JinjaThreads</a>, <a href="Lazy-Lists-II.html">Lazy-Lists-II</a>, <a href="Markov_Models.html">Markov_Models</a>, <a href="Ordered_Resolution_Prover.html">Ordered_Resolution_Prover</a>, <a href="Parity_Game.html">Parity_Game</a>, <a href="Partial_Order_Reduction.html">Partial_Order_Reduction</a>, <a href="Probabilistic_Noninterference.html">Probabilistic_Noninterference</a>, <a href="Stream_Fusion_Code.html">Stream_Fusion_Code</a>, <a href="Topology.html">Topology</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Coinductive/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Coinductive/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Coinductive/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Coinductive-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Coinductive-2018-08-16.tar.gz">
	+ afp-Coinductive-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Coinductive-2017-10-10.tar.gz">
	afp-Coinductive-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Coinductive-2016-12-17.tar.gz">
	afp-Coinductive-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Coinductive-2016-02-22.tar.gz">
	afp-Coinductive-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Coinductive-2015-05-27.tar.gz">
	afp-Coinductive-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Coinductive-2014-08-28.tar.gz">
	afp-Coinductive-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Coinductive-2013-12-11.tar.gz">
	afp-Coinductive-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Coinductive-2013-11-17.tar.gz">
	afp-Coinductive-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Coinductive-2013-03-02.tar.gz">
	afp-Coinductive-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Coinductive-2013-02-16.tar.gz">
	afp-Coinductive-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Coinductive-2012-05-24.tar.gz">
	afp-Coinductive-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Coinductive-2011-10-11.tar.gz">
	afp-Coinductive-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Coinductive-2011-02-11.tar.gz">
	afp-Coinductive-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Coinductive-2010-06-30.tar.gz">
	afp-Coinductive-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Coinductive-2010-02-15.tar.gz">
	afp-Coinductive-2010-02-15.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Coinductive-2010-02-14.tar.gz">
	afp-Coinductive-2010-02-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Coinductive_Languages.html b/web/entries/Coinductive_Languages.html
	--- a/web/entries/Coinductive_Languages.html
	+++ b/web/entries/Coinductive_Languages.html
	@@ -1,228 +1,233 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Codatatype of Formal Languages - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">C</font>odatatype

	of

	<font class="first">F</font>ormal

	<font class="first">L</font>anguages

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Codatatype of Formal Languages</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-11-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract"><p>We define formal languages as a codataype of infinite trees
	branching over the alphabet. Each node in such a tree indicates whether the
	path to this node constitutes a word inside or outside of the language. This
	codatatype is isormorphic to the set of lists representation of languages,
	but caters for definitions by corecursion and proofs by coinduction.</p>
	<p>Regular operations on languages are then defined by primitive corecursion.
	A difficulty arises here, since the standard definitions of concatenation and
	iteration from the coalgebraic literature are not primitively
	corecursive-they require guardedness up-to union/concatenation.
	Without support for up-to corecursion, these operation must be defined as a
	composition of primitive ones (and proved being equal to the standard
	definitions). As an exercise in coinduction we also prove the axioms of
	Kleene algebra for the defined regular operations.</p>
	<p>Furthermore, a language for context-free grammars given by productions in
	Greibach normal form and an initial nonterminal is constructed by primitive
	corecursion, yielding an executable decision procedure for the word problem
	without further ado.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Coinductive_Languages-AFP,
	author = {Dmitriy Traytel},
	title = {A Codatatype of Formal Languages},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Coinductive_Languages.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Regular-Sets.html">Regular-Sets</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Formula_Derivatives.html">Formula_Derivatives</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Coinductive_Languages/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Coinductive_Languages/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Coinductive_Languages/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Coinductive_Languages-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Coinductive_Languages-2018-08-16.tar.gz">
	+ afp-Coinductive_Languages-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Coinductive_Languages-2017-10-10.tar.gz">
	afp-Coinductive_Languages-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Coinductive_Languages-2016-12-17.tar.gz">
	afp-Coinductive_Languages-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Coinductive_Languages-2016-02-22.tar.gz">
	afp-Coinductive_Languages-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Coinductive_Languages-2015-05-27.tar.gz">
	afp-Coinductive_Languages-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Coinductive_Languages-2014-08-28.tar.gz">
	afp-Coinductive_Languages-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Coinductive_Languages-2013-12-11.tar.gz">
	afp-Coinductive_Languages-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Coinductive_Languages-2013-11-17.tar.gz">
	afp-Coinductive_Languages-2013-11-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Collections.html b/web/entries/Collections.html
	--- a/web/entries/Collections.html
	+++ b/web/entries/Collections.html
	@@ -1,284 +1,289 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Collections Framework - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ollections

	<font class="first">F</font>ramework

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Collections Framework</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributors:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a> and
	Thomas Tuerk
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-11-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[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.<br>
	[2010-12-01]: New Interfaces: Priority Queues, Annotated Lists. Implemented by finger trees, (skew) binomial queues.<br>
	[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<br>
	[2012-04-25]: New iterator foundation by Tuerk. Various maintenance changes.<br>
	[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.<br>
	[2013-09]: Added Generic Collection Framework based on Autoref. The GenCF provides: Arbitrary nesting, full integration with Autoref.<br>
	[2014-06]: Maintenace changes to GenCF: Optimized inj_image on list_set. op_set_cart (Cartesian product). big-Union operation. atLeastLessThan - operation ({a..<b})<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Collections-AFP,
	author = {Peter Lammich},
	title = {Collections Framework},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/Collections.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Binomial-Heaps.html">Binomial-Heaps</a>, <a href="CAVA_Automata.html">CAVA_Automata</a>, <a href="Containers.html">Containers</a>, <a href="Finger-Trees.html">Finger-Trees</a>, <a href="Native_Word.html">Native_Word</a>, <a href="Refine_Monadic.html">Refine_Monadic</a>, <a href="Trie.html">Trie</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Abstract_Completeness.html">Abstract_Completeness</a>, <a href="CAVA_Automata.html">CAVA_Automata</a>, <a href="Containers.html">Containers</a>, <a href="Deriving.html">Deriving</a>, <a href="Dijkstra_Shortest_Path.html">Dijkstra_Shortest_Path</a>, <a href="Formal_SSA.html">Formal_SSA</a>, <a href="JinjaThreads.html">JinjaThreads</a>, <a href="Kruskal.html">Kruskal</a>, <a href="Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a>, <a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a>, <a href="ROBDD.html">ROBDD</a>, <a href="Separation_Logic_Imperative_HOL.html">Separation_Logic_Imperative_HOL</a>, <a href="Transition_Systems_and_Automata.html">Transition_Systems_and_Automata</a>, <a href="Transitive-Closure.html">Transitive-Closure</a>, <a href="Tree-Automata.html">Tree-Automata</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Collections/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Collections/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Collections/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Collections-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Collections-2018-08-16.tar.gz">
	+ afp-Collections-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Collections-2017-10-10.tar.gz">
	afp-Collections-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Collections-2016-12-17.tar.gz">
	afp-Collections-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Collections-2016-02-22.tar.gz">
	afp-Collections-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Collections-2015-05-27.tar.gz">
	afp-Collections-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Collections-2014-08-28.tar.gz">
	afp-Collections-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Collections-2013-12-11.tar.gz">
	afp-Collections-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Collections-2013-11-17.tar.gz">
	afp-Collections-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Collections-2013-03-02.tar.gz">
	afp-Collections-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Collections-2013-02-16.tar.gz">
	afp-Collections-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Collections-2012-05-24.tar.gz">
	afp-Collections-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Collections-2011-10-12.tar.gz">
	afp-Collections-2011-10-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Collections-2011-10-11.tar.gz">
	afp-Collections-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Collections-2011-02-11.tar.gz">
	afp-Collections-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Collections-2010-06-30.tar.gz">
	afp-Collections-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Collections-2009-12-13.tar.gz">
	afp-Collections-2009-12-13.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Collections-2009-12-12.tar.gz">
	afp-Collections-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Collections-2009-11-29.tar.gz">
	afp-Collections-2009-11-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Comparison_Sort_Lower_Bound.html b/web/entries/Comparison_Sort_Lower_Bound.html
	--- a/web/entries/Comparison_Sort_Lower_Bound.html
	+++ b/web/entries/Comparison_Sort_Lower_Bound.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Lower bound on comparison-based sorting algorithms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ower

	bound

	on

	comparison-based

	sorting

	algorithms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Lower bound on comparison-based sorting algorithms</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-03-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This article contains a formal proof of the well-known fact
	that number of comparisons that a comparison-based sorting algorithm
	needs to perform to sort a list of length <em>n</em> is at
	least <em>log<sub>2</sub> (n!)</em>
	in the worst case, i. e. <em>Ω(n log
	n)</em>.</p> <p>For this purpose, a shallow
	embedding for comparison-based sorting algorithms is defined: a
	sorting algorithm is a recursive datatype containing either a HOL
	function or a query of a comparison oracle with a continuation
	containing the remaining computation. This makes it possible to force
	the algorithm to use only comparisons and to track the number of
	comparisons made.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Comparison_Sort_Lower_Bound-AFP,
	author = {Manuel Eberl},
	title = {Lower bound on comparison-based sorting algorithms},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Comparison_Sort_Lower_Bound.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Landau_Symbols.html">Landau_Symbols</a>, <a href="List-Index.html">List-Index</a>, <a href="Stirling_Formula.html">Stirling_Formula</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Quick_Sort_Cost.html">Quick_Sort_Cost</a>, <a href="Treaps.html">Treaps</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Comparison_Sort_Lower_Bound/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Comparison_Sort_Lower_Bound/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Comparison_Sort_Lower_Bound/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Comparison_Sort_Lower_Bound-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Comparison_Sort_Lower_Bound-2018-08-16.tar.gz">
	+ afp-Comparison_Sort_Lower_Bound-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Comparison_Sort_Lower_Bound-2017-10-10.tar.gz">
	afp-Comparison_Sort_Lower_Bound-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Comparison_Sort_Lower_Bound-2017-03-16.tar.gz">
	afp-Comparison_Sort_Lower_Bound-2017-03-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Compiling-Exceptions-Correctly.html b/web/entries/Compiling-Exceptions-Correctly.html
	--- a/web/entries/Compiling-Exceptions-Correctly.html
	+++ b/web/entries/Compiling-Exceptions-Correctly.html
	@@ -1,259 +1,264 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Compiling Exceptions Correctly - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ompiling

	<font class="first">E</font>xceptions

	<font class="first">C</font>orrectly

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Compiling Exceptions Correctly</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-07-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">An exception compilation scheme that dynamically creates and removes exception handler entries on the stack. A formalization of an article of the same name by <a href="http://www.cs.nott.ac.uk/~gmh/">Hutton</a> and Wright.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Compiling-Exceptions-Correctly-AFP,
	author = {Tobias Nipkow},
	title = {Compiling Exceptions Correctly},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Compiling-Exceptions-Correctly.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Compiling-Exceptions-Correctly/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Compiling-Exceptions-Correctly/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Compiling-Exceptions-Correctly/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Compiling-Exceptions-Correctly-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Compiling-Exceptions-Correctly-2018-08-16.tar.gz">
	+ afp-Compiling-Exceptions-Correctly-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2017-10-10.tar.gz">
	afp-Compiling-Exceptions-Correctly-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2016-12-17.tar.gz">
	afp-Compiling-Exceptions-Correctly-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2016-02-22.tar.gz">
	afp-Compiling-Exceptions-Correctly-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2015-05-27.tar.gz">
	afp-Compiling-Exceptions-Correctly-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2014-08-28.tar.gz">
	afp-Compiling-Exceptions-Correctly-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2013-12-11.tar.gz">
	afp-Compiling-Exceptions-Correctly-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2013-11-17.tar.gz">
	afp-Compiling-Exceptions-Correctly-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2013-02-16.tar.gz">
	afp-Compiling-Exceptions-Correctly-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2012-05-24.tar.gz">
	afp-Compiling-Exceptions-Correctly-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2011-10-11.tar.gz">
	afp-Compiling-Exceptions-Correctly-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2011-02-11.tar.gz">
	afp-Compiling-Exceptions-Correctly-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2010-06-30.tar.gz">
	afp-Compiling-Exceptions-Correctly-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2009-12-12.tar.gz">
	afp-Compiling-Exceptions-Correctly-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2009-04-29.tar.gz">
	afp-Compiling-Exceptions-Correctly-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2008-06-10.tar.gz">
	afp-Compiling-Exceptions-Correctly-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2007-11-27.tar.gz">
	afp-Compiling-Exceptions-Correctly-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2005-10-14.tar.gz">
	afp-Compiling-Exceptions-Correctly-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Compiling-Exceptions-Correctly-2004-07-09.tar.gz">
	afp-Compiling-Exceptions-Correctly-2004-07-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Completeness.html b/web/entries/Completeness.html
	--- a/web/entries/Completeness.html
	+++ b/web/entries/Completeness.html
	@@ -1,273 +1,278 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Completeness theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ompleteness

	theorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Completeness theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	James Margetson and
	Tom Ridge
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-09-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The completeness of first-order logic is proved, following the first five pages of Wainer and Wallen's chapter of the book <i>Proof Theory</i> by Aczel et al., CUP, 1992. Their presentation of formulas allows the proofs to use symmetry arguments. Margetson formalized this theorem by early 2000. The Isar conversion is thanks to Tom Ridge. A paper describing the formalization is available <a href="Completeness-paper.pdf">[pdf]</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Completeness-AFP,
	author = {James Margetson and Tom Ridge},
	title = {Completeness theorem},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Completeness.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Completeness/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Completeness/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Completeness/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Completeness-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Completeness-2018-08-16.tar.gz">
	+ afp-Completeness-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Completeness-2017-10-10.tar.gz">
	afp-Completeness-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Completeness-2016-12-17.tar.gz">
	afp-Completeness-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Completeness-2016-02-22.tar.gz">
	afp-Completeness-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Completeness-2015-05-27.tar.gz">
	afp-Completeness-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Completeness-2014-08-28.tar.gz">
	afp-Completeness-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Completeness-2013-12-11.tar.gz">
	afp-Completeness-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Completeness-2013-11-17.tar.gz">
	afp-Completeness-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Completeness-2013-03-02.tar.gz">
	afp-Completeness-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Completeness-2013-02-16.tar.gz">
	afp-Completeness-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Completeness-2012-05-24.tar.gz">
	afp-Completeness-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Completeness-2011-10-11.tar.gz">
	afp-Completeness-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Completeness-2011-02-11.tar.gz">
	afp-Completeness-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Completeness-2010-06-30.tar.gz">
	afp-Completeness-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Completeness-2009-12-12.tar.gz">
	afp-Completeness-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Completeness-2009-04-29.tar.gz">
	afp-Completeness-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Completeness-2008-06-10.tar.gz">
	afp-Completeness-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Completeness-2007-11-27.tar.gz">
	afp-Completeness-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Completeness-2005-10-14.tar.gz">
	afp-Completeness-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Completeness-2005-07-22.tar.gz">
	afp-Completeness-2005-07-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Completeness-2004-09-21.tar.gz">
	afp-Completeness-2004-09-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Completeness-2004-09-20.tar.gz">
	afp-Completeness-2004-09-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Complx.html b/web/entries/Complx.html
	--- a/web/entries/Complx.html
	+++ b/web/entries/Complx.html
	@@ -1,222 +1,227 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>COMPLX: A Verification Framework for Concurrent Imperative Programs - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>OMPLX:

	<font class="first">A</font>

	<font class="first">V</font>erification

	<font class="first">F</font>ramework

	for

	<font class="first">C</font>oncurrent

	<font class="first">I</font>mperative

	<font class="first">P</font>rograms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">COMPLX: A Verification Framework for Concurrent Imperative Programs</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Sidney Amani,
	June Andronick,
	Maksym Bortin,
	Corey Lewis,
	Christine Rizkallah and
	Joseph Tuong
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-11-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We propose a concurrency reasoning framework for imperative programs,
	based on the Owicki-Gries (OG) foundational shared-variable
	concurrency method. Our framework combines the approaches of
	Hoare-Parallel, a formalisation of OG in Isabelle/HOL for a simple
	while-language, and Simpl, a generic imperative language embedded in
	Isabelle/HOL, allowing formal reasoning on C programs. We define the
	Complx language, extending the syntax and semantics of Simpl with
	support for parallel composition and synchronisation. We additionally
	define an OG logic, which we prove sound w.r.t. the semantics, and a
	verification condition generator, both supporting involved low-level
	imperative constructs such as function calls and abrupt termination.
	We illustrate our framework on an example that features exceptions,
	guards and function calls. We aim to then target concurrent operating
	systems, such as the interruptible eChronos embedded operating system
	for which we already have a model-level OG proof using Hoare-Parallel.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2017-01-13]:
	Improve VCG for nested parallels and sequential sections
	(revision 30739dbc3dcb)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Complx-AFP,
	author = {Sidney Amani and June Andronick and Maksym Bortin and Corey Lewis and Christine Rizkallah and Joseph Tuong},
	title = {COMPLX: A Verification Framework for Concurrent Imperative Programs},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Complx.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Word_Lib.html">Word_Lib</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Complx/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Complx/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Complx/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Complx-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Complx-2018-08-16.tar.gz">
	+ afp-Complx-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Complx-2017-10-10.tar.gz">
	afp-Complx-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Complx-2016-12-17.tar.gz">
	afp-Complx-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Complx-2016-11-29.tar.gz">
	afp-Complx-2016-11-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/ComponentDependencies.html b/web/entries/ComponentDependencies.html
	--- a/web/entries/ComponentDependencies.html
	+++ b/web/entries/ComponentDependencies.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalisation and Analysis of Component Dependencies - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalisation

	and

	<font class="first">A</font>nalysis

	of

	<font class="first">C</font>omponent

	<font class="first">D</font>ependencies

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalisation and Analysis of Component Dependencies</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Maria Spichkova (maria /dot/ spichkova /at/ rmit /dot/ edu /dot/ au)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-04-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This set of theories presents a formalisation in Isabelle/HOL of data dependencies between components. The approach allows to analyse system structure oriented towards efficient checking of system: it aims at elaborating for a concrete system, which parts of the system are necessary to check a given property.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{ComponentDependencies-AFP,
	author = {Maria Spichkova},
	title = {Formalisation and Analysis of Component Dependencies},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/ComponentDependencies.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ComponentDependencies/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/ComponentDependencies/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ComponentDependencies/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-ComponentDependencies-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-ComponentDependencies-2018-08-16.tar.gz">
	+ afp-ComponentDependencies-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-ComponentDependencies-2017-10-10.tar.gz">
	afp-ComponentDependencies-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-ComponentDependencies-2016-12-17.tar.gz">
	afp-ComponentDependencies-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-ComponentDependencies-2016-02-22.tar.gz">
	afp-ComponentDependencies-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-ComponentDependencies-2015-05-27.tar.gz">
	afp-ComponentDependencies-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-ComponentDependencies-2014-08-28.tar.gz">
	afp-ComponentDependencies-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-ComponentDependencies-2014-04-29.tar.gz">
	afp-ComponentDependencies-2014-04-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/ConcurrentGC.html b/web/entries/ConcurrentGC.html
	--- a/web/entries/ConcurrentGC.html
	+++ b/web/entries/ConcurrentGC.html
	@@ -1,215 +1,220 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Relaxing Safely: Verified On-the-Fly Garbage Collection for x86-TSO - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>elaxing

	<font class="first">S</font>afely:

	<font class="first">V</font>erified

	<font class="first">O</font>n-the-Fly

	<font class="first">G</font>arbage

	<font class="first">C</font>ollection

	for

	x86-TSO

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Relaxing Safely: Verified On-the-Fly Garbage Collection for x86-TSO</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a>,
	<a href="https://www.cs.purdue.edu/homes/hosking/">Tony Hosking</a> and
	Kai Engelhardt
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-04-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	We use ConcurrentIMP to model Schism, a state-of-the-art real-time
	garbage collection scheme for weak memory, and show that it is safe
	on x86-TSO.</p>
	<p>
	This development accompanies the PLDI 2015 paper of the same name.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{ConcurrentGC-AFP,
	author = {Peter Gammie and Tony Hosking and Kai Engelhardt},
	title = {Relaxing Safely: Verified On-the-Fly Garbage Collection for x86-TSO},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/ConcurrentGC.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="ConcurrentIMP.html">ConcurrentIMP</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ConcurrentGC/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/ConcurrentGC/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ConcurrentGC/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-ConcurrentGC-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-ConcurrentGC-2018-08-16.tar.gz">
	+ afp-ConcurrentGC-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-ConcurrentGC-2017-10-10.tar.gz">
	afp-ConcurrentGC-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-ConcurrentGC-2016-12-17.tar.gz">
	afp-ConcurrentGC-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-ConcurrentGC-2016-02-22.tar.gz">
	afp-ConcurrentGC-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-ConcurrentGC-2015-05-27.tar.gz">
	afp-ConcurrentGC-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-ConcurrentGC-2015-04-15.tar.gz">
	afp-ConcurrentGC-2015-04-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/ConcurrentIMP.html b/web/entries/ConcurrentIMP.html
	--- a/web/entries/ConcurrentIMP.html
	+++ b/web/entries/ConcurrentIMP.html
	@@ -1,196 +1,201 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Concurrent IMP - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>oncurrent

	<font class="first">I</font>MP

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Concurrent IMP</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-04-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	ConcurrentIMP extends the small imperative language IMP with control
	non-determinism and constructs for synchronous message passing.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{ConcurrentIMP-AFP,
	author = {Peter Gammie},
	title = {Concurrent IMP},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/ConcurrentIMP.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="ConcurrentGC.html">ConcurrentGC</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ConcurrentIMP/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/ConcurrentIMP/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ConcurrentIMP/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-ConcurrentIMP-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-ConcurrentIMP-2018-08-16.tar.gz">
	+ afp-ConcurrentIMP-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-ConcurrentIMP-2017-10-10.tar.gz">
	afp-ConcurrentIMP-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-ConcurrentIMP-2016-12-17.tar.gz">
	afp-ConcurrentIMP-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-ConcurrentIMP-2016-02-22.tar.gz">
	afp-ConcurrentIMP-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-ConcurrentIMP-2015-05-27.tar.gz">
	afp-ConcurrentIMP-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-ConcurrentIMP-2015-04-15.tar.gz">
	afp-ConcurrentIMP-2015-04-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Concurrent_Ref_Alg.html b/web/entries/Concurrent_Ref_Alg.html
	--- a/web/entries/Concurrent_Ref_Alg.html
	+++ b/web/entries/Concurrent_Ref_Alg.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Concurrent Refinement Algebra and Rely Quotients - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>oncurrent

	<font class="first">R</font>efinement

	<font class="first">A</font>lgebra

	and

	<font class="first">R</font>ely

	<font class="first">Q</font>uotients

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Concurrent Refinement Algebra and Rely Quotients</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Julian Fell (julian /dot/ fell /at/ uq /dot/ net /dot/ au),
	Ian J. Hayes (ian /dot/ hayes /at/ itee /dot/ uq /dot/ edu /dot/ au) and
	<a href="http://andrius.velykis.lt">Andrius Velykis</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-12-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The concurrent refinement algebra developed here is designed to
	provide a foundation for rely/guarantee reasoning about concurrent
	programs. The algebra builds on a complete lattice of commands by
	providing sequential composition, parallel composition and a novel
	weak conjunction operator. The weak conjunction operator coincides
	with the lattice supremum providing its arguments are non-aborting,
	but aborts if either of its arguments do. Weak conjunction provides an
	abstract version of a guarantee condition as a guarantee process. We
	distinguish between models that distribute sequential composition over
	non-deterministic choice from the left (referred to as being
	conjunctive in the refinement calculus literature) and those that
	don't. Least and greatest fixed points of monotone functions are
	provided to allow recursion and iteration operators to be added to the
	language. Additional iteration laws are available for conjunctive
	models. The rely quotient of processes <i>c</i> and
	<i>i</i> is the process that, if executed in parallel with
	<i>i</i> implements <i>c</i>. It represents an
	abstract version of a rely condition generalised to a process.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Concurrent_Ref_Alg-AFP,
	author = {Julian Fell and Ian J. Hayes and Andrius Velykis},
	title = {Concurrent Refinement Algebra and Rely Quotients},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Concurrent_Ref_Alg.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Concurrent_Ref_Alg/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Concurrent_Ref_Alg/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Concurrent_Ref_Alg/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Concurrent_Ref_Alg-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Concurrent_Ref_Alg-2018-08-16.tar.gz">
	+ afp-Concurrent_Ref_Alg-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Concurrent_Ref_Alg-2017-10-10.tar.gz">
	afp-Concurrent_Ref_Alg-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Concurrent_Ref_Alg-2017-01-04.tar.gz">
	afp-Concurrent_Ref_Alg-2017-01-04.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Concurrent_Revisions.html b/web/entries/Concurrent_Revisions.html
	--- a/web/entries/Concurrent_Revisions.html
	+++ b/web/entries/Concurrent_Revisions.html
	@@ -1,179 +1,185 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of Concurrent Revisions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	<font class="first">C</font>oncurrent

	<font class="first">R</font>evisions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of Concurrent Revisions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Roy Overbeek (Roy /dot/ Overbeek /at/ cwi /dot/ nl)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-12-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Concurrent revisions is a concurrency control model developed by
	Microsoft Research. It has many interesting properties that
	distinguish it from other well-known models such as transactional
	memory. One of these properties is <em>determinacy</em>:
	programs written within the model always produce the same outcome,
	independent of scheduling activity. The concurrent revisions model has
	an operational semantics, with an informal proof of determinacy. This
	document contains an Isabelle/HOL formalization of this semantics and
	the proof of determinacy.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Concurrent_Revisions-AFP,
	author = {Roy Overbeek},
	title = {Formalization of Concurrent Revisions},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Concurrent_Revisions.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Concurrent_Revisions/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Concurrent_Revisions/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Concurrent_Revisions/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Concurrent_Revisions-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Concurrent_Revisions-2019-01-03.tar.gz">
	+ afp-Concurrent_Revisions-2019-01-03.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Consensus_Refined.html b/web/entries/Consensus_Refined.html
	--- a/web/entries/Consensus_Refined.html
	+++ b/web/entries/Consensus_Refined.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Consensus Refined - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>onsensus

	<font class="first">R</font>efined

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Consensus Refined</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Ognjen Maric and
	Christoph Sprenger (sprenger /at/ inf /dot/ ethz /dot/ ch)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-03-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Algorithms for solving the consensus problem are fundamental to
	distributed computing. Despite their brevity, their
	ability to operate in concurrent, asynchronous and failure-prone
	environments comes at the cost of complex and subtle
	behaviors. Accordingly, understanding how they work and proving
	their correctness is a non-trivial endeavor where abstraction
	is immensely helpful.
	Moreover, research on consensus has yielded a large number of
	algorithms, many of which appear to share common algorithmic
	ideas. A natural question is whether and how these similarities can
	be distilled and described in a precise, unified way.
	In this work, we combine stepwise refinement and
	lockstep models to provide an abstract and unified
	view of a sizeable family of consensus algorithms. Our models
	provide insights into the design choices underlying the different
	algorithms, and classify them based on those choices.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Consensus_Refined-AFP,
	author = {Ognjen Maric and Christoph Sprenger},
	title = {Consensus Refined},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Consensus_Refined.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Heard_Of.html">Heard_Of</a>, <a href="Stuttering_Equivalence.html">Stuttering_Equivalence</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Consensus_Refined/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Consensus_Refined/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Consensus_Refined/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Consensus_Refined-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Consensus_Refined-2018-08-16.tar.gz">
	+ afp-Consensus_Refined-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Consensus_Refined-2017-10-10.tar.gz">
	afp-Consensus_Refined-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Consensus_Refined-2016-12-17.tar.gz">
	afp-Consensus_Refined-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Consensus_Refined-2016-02-22.tar.gz">
	afp-Consensus_Refined-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Consensus_Refined-2015-05-27.tar.gz">
	afp-Consensus_Refined-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Consensus_Refined-2015-03-19.tar.gz">
	afp-Consensus_Refined-2015-03-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Constructive_Cryptography.html b/web/entries/Constructive_Cryptography.html
	--- a/web/entries/Constructive_Cryptography.html
	+++ b/web/entries/Constructive_Cryptography.html
	@@ -1,183 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Constructive Cryptography in HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>onstructive

	<font class="first">C</font>ryptography

	in

	<font class="first">H</font>OL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Constructive Cryptography in HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a> and
	S. Reza Sefidgar
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-12-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Inspired by Abstract Cryptography, we extend CryptHOL, a framework for
	formalizing game-based proofs, with an abstract model of Random
	Systems and provide proof rules about their composition and equality.
	This foundation facilitates the formalization of Constructive
	Cryptography proofs, where the security of a cryptographic scheme is
	realized as a special form of construction in which a complex random
	system is built from simpler ones. This is a first step towards a
	fully-featured compositional framework, similar to Universal
	Composability framework, that supports formalization of
	simulation-based proofs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Constructive_Cryptography-AFP,
	author = {Andreas Lochbihler and S. Reza Sefidgar},
	title = {Constructive Cryptography in HOL},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Constructive_Cryptography.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CryptHOL.html">CryptHOL</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Constructive_Cryptography/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Constructive_Cryptography/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Constructive_Cryptography/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Constructive_Cryptography-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Constructive_Cryptography-2018-12-20.tar.gz">
	+ afp-Constructive_Cryptography-2018-12-20.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Constructive_Cryptography-2018-12-19.tar.gz">
	+ afp-Constructive_Cryptography-2018-12-19.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Constructor_Funs.html b/web/entries/Constructor_Funs.html
	--- a/web/entries/Constructor_Funs.html
	+++ b/web/entries/Constructor_Funs.html
	@@ -1,183 +1,188 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Constructor Functions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>onstructor

	<font class="first">F</font>unctions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Constructor Functions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-04-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Isabelle's code generator performs various adaptations for target
	languages. Among others, constructor applications have to be fully
	saturated. That means that for constructor calls occuring as arguments
	to higher-order functions, synthetic lambdas have to be inserted. This
	entry provides tooling to avoid this construction altogether by
	introducing constructor functions.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Constructor_Funs-AFP,
	author = {Lars Hupel},
	title = {Constructor Functions},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Constructor_Funs.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Constructor_Funs/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Constructor_Funs/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Constructor_Funs/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Constructor_Funs-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Constructor_Funs-2018-08-16.tar.gz">
	+ afp-Constructor_Funs-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Constructor_Funs-2017-10-10.tar.gz">
	afp-Constructor_Funs-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Constructor_Funs-2017-04-20.tar.gz">
	afp-Constructor_Funs-2017-04-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Containers.html b/web/entries/Containers.html
	--- a/web/entries/Containers.html
	+++ b/web/entries/Containers.html
	@@ -1,235 +1,240 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Light-weight Containers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ight-weight

	<font class="first">C</font>ontainers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Light-weight Containers</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	René Thiemann (rene /dot/ thiemann /at/ uibk /dot/ ac /dot/ at)
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-04-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	<p>
	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.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2013-07-11]: add pretty printing for sets (revision 7f3f52c5f5fa)<br>
	[2013-09-20]:
	provide generators for canonical type class instantiations
	(revision 159f4401f4a8 by René Thiemann)<br>
	[2014-07-08]: add support for going from partial functions to mappings (revision 7a6fc957e8ed)<br>
	[2018-03-05]: add two application examples: depth-first search and 2SAT (revision e5e1a1da2411)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Containers-AFP,
	author = {Andreas Lochbihler},
	title = {Light-weight Containers},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Containers.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Automatic_Refinement.html">Automatic_Refinement</a>, <a href="Collections.html">Collections</a>, <a href="Deriving.html">Deriving</a>, <a href="Finger-Trees.html">Finger-Trees</a>, <a href="Regular-Sets.html">Regular-Sets</a>, <a href="Trie.html">Trie</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Containers/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Containers/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Containers/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Containers-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Containers-2018-08-16.tar.gz">
	+ afp-Containers-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Containers-2017-10-10.tar.gz">
	afp-Containers-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Containers-2016-12-17.tar.gz">
	afp-Containers-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Containers-2016-02-22.tar.gz">
	afp-Containers-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Containers-2015-05-27.tar.gz">
	afp-Containers-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Containers-2014-08-28.tar.gz">
	afp-Containers-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Containers-2013-12-11.tar.gz">
	afp-Containers-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Containers-2013-11-17.tar.gz">
	afp-Containers-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Containers-2013-04-23.tar.gz">
	afp-Containers-2013-04-23.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CoreC++.html b/web/entries/CoreC++.html
	--- a/web/entries/CoreC++.html
	+++ b/web/entries/CoreC++.html
	@@ -1,255 +1,260 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>CoreC++ - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>oreC++

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">CoreC++</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2006-05-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We present an operational semantics and type safety proof for multiple inheritance in C++. The semantics models the behavior of method calls, field accesses, and two forms of casts in C++ class hierarchies. For explanations see the OOPSLA 2006 paper by Wasserrab, Nipkow, Snelting and Tip.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CoreC++-AFP,
	author = {Daniel Wasserrab},
	title = {CoreC++},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2006,
	note = {\url{http://isa-afp.org/entries/CoreC++.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CoreC++/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CoreC++/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CoreC++/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CoreC++-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CoreC++-2018-08-16.tar.gz">
	+ afp-CoreC++-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CoreC++-2017-10-10.tar.gz">
	afp-CoreC++-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CoreC++-2016-12-17.tar.gz">
	afp-CoreC++-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-CoreC++-2016-02-22.tar.gz">
	afp-CoreC++-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-CoreC++-2015-05-27.tar.gz">
	afp-CoreC++-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-CoreC++-2014-08-28.tar.gz">
	afp-CoreC++-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-CoreC++-2013-12-11.tar.gz">
	afp-CoreC++-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-CoreC++-2013-11-17.tar.gz">
	afp-CoreC++-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-CoreC++-2013-03-02.tar.gz">
	afp-CoreC++-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-CoreC++-2013-02-16.tar.gz">
	afp-CoreC++-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-CoreC++-2012-05-24.tar.gz">
	afp-CoreC++-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-CoreC++-2011-10-11.tar.gz">
	afp-CoreC++-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-CoreC++-2011-02-11.tar.gz">
	afp-CoreC++-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-CoreC++-2010-06-30.tar.gz">
	afp-CoreC++-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-CoreC++-2009-12-12.tar.gz">
	afp-CoreC++-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-CoreC++-2009-04-29.tar.gz">
	afp-CoreC++-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-CoreC++-2008-06-10.tar.gz">
	afp-CoreC++-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-CoreC++-2007-11-27.tar.gz">
	afp-CoreC++-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-CoreC++-2006-05-16.tar.gz">
	afp-CoreC++-2006-05-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Core_DOM.html b/web/entries/Core_DOM.html
	--- a/web/entries/Core_DOM.html
	+++ b/web/entries/Core_DOM.html
	@@ -1,193 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Formal Model of the Document Object Model - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">F</font>ormal

	<font class="first">M</font>odel

	of

	the

	<font class="first">D</font>ocument

	<font class="first">O</font>bject

	<font class="first">M</font>odel

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Formal Model of the Document Object Model</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.brucker.ch/">Achim D. Brucker</a> and
	<a href="http://www.dcs.shef.ac.uk/cgi-bin/makeperson?M.Herzberg">Michael Herzberg</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-12-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	In this AFP entry, we formalize the core of the Document Object Model
	(DOM). At its core, the DOM defines a tree-like data structure for
	representing documents in general and HTML documents in particular. It
	is the heart of any modern web browser. Formalizing the key concepts
	of the DOM is a prerequisite for the formal reasoning over client-side
	JavaScript programs and for the analysis of security concepts in
	modern web browsers. We present a formalization of the core DOM, with
	focus on the node-tree and the operations defined on node-trees, in
	Isabelle/HOL. We use the formalization to verify the functional
	correctness of the most important functions defined in the DOM
	standard. Moreover, our formalization is 1) extensible, i.e., can be
	extended without the need of re-proving already proven properties and
	2) executable, i.e., we can generate executable code from our
	specification.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Core_DOM-AFP,
	author = {Achim D. Brucker and Michael Herzberg},
	title = {A Formal Model of the Document Object Model},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Core_DOM.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Core_DOM/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Core_DOM/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Core_DOM/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Core_DOM-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Core_DOM-2019-01-07.tar.gz">
	+ afp-Core_DOM-2019-01-07.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Count_Complex_Roots.html b/web/entries/Count_Complex_Roots.html
	--- a/web/entries/Count_Complex_Roots.html
	+++ b/web/entries/Count_Complex_Roots.html
	@@ -1,191 +1,196 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Count the Number of Complex Roots - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ount

	the

	<font class="first">N</font>umber

	of

	<font class="first">C</font>omplex

	<font class="first">R</font>oots

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Count the Number of Complex Roots</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-10-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Based on evaluating Cauchy indices through remainder sequences, this
	entry provides an effective procedure to count the number of complex
	roots (with multiplicity) of a polynomial within a rectangle box or a
	half-plane. Potential applications of this entry include certified
	complex root isolation (of a polynomial) and testing the Routh-Hurwitz
	stability criterion (i.e., to check whether all the roots of some
	characteristic polynomial have negative real parts).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Count_Complex_Roots-AFP,
	author = {Wenda Li},
	title = {Count the Number of Complex Roots},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Count_Complex_Roots.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Sturm_Tarski.html">Sturm_Tarski</a>, <a href="Winding_Number_Eval.html">Winding_Number_Eval</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Linear_Recurrences.html">Linear_Recurrences</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Count_Complex_Roots/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Count_Complex_Roots/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Count_Complex_Roots/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Count_Complex_Roots-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Count_Complex_Roots-2018-08-16.tar.gz">
	+ afp-Count_Complex_Roots-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Count_Complex_Roots-2017-10-18.tar.gz">
	afp-Count_Complex_Roots-2017-10-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CryptHOL.html b/web/entries/CryptHOL.html
	--- a/web/entries/CryptHOL.html
	+++ b/web/entries/CryptHOL.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>CryptHOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ryptHOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">CryptHOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>CryptHOL provides a framework for formalising cryptographic arguments
	in Isabelle/HOL. It shallowly embeds a probabilistic functional
	programming language in higher order logic. The language features
	monadic sequencing, recursion, random sampling, failures and failure
	handling, and black-box access to oracles. Oracles are probabilistic
	functions which maintain hidden state between different invocations.
	All operators are defined in the new semantic domain of
	generative probabilistic values, a codatatype. We derive proof rules for
	the operators and establish a connection with the theory of relational
	parametricity. Thus, the resuting proofs are trustworthy and
	comprehensible, and the framework is extensible and widely applicable.
	</p><p>
	The framework is used in the accompanying AFP entry "Game-based
	Cryptography in HOL". There, we show-case our framework by formalizing
	different game-based proofs from the literature. This formalisation
	continues the work described in the author's ESOP 2016 paper.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CryptHOL-AFP,
	author = {Andreas Lochbihler},
	title = {CryptHOL},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/CryptHOL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Applicative_Lifting.html">Applicative_Lifting</a>, <a href="Coinductive.html">Coinductive</a>, <a href="Landau_Symbols.html">Landau_Symbols</a>, <a href="Monad_Normalisation.html">Monad_Normalisation</a>, <a href="Monomorphic_Monad.html">Monomorphic_Monad</a>, <a href="Probabilistic_While.html">Probabilistic_While</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Constructive_Cryptography.html">Constructive_Cryptography</a>, <a href="Game_Based_Crypto.html">Game_Based_Crypto</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CryptHOL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CryptHOL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CryptHOL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CryptHOL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CryptHOL-2018-08-16.tar.gz">
	+ afp-CryptHOL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CryptHOL-2017-10-10.tar.gz">
	afp-CryptHOL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CryptHOL-2017-05-11.tar.gz">
	afp-CryptHOL-2017-05-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/CryptoBasedCompositionalProperties.html b/web/entries/CryptoBasedCompositionalProperties.html
	--- a/web/entries/CryptoBasedCompositionalProperties.html
	+++ b/web/entries/CryptoBasedCompositionalProperties.html
	@@ -1,208 +1,213 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Compositional Properties of Crypto-Based Components - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ompositional

	<font class="first">P</font>roperties

	of

	<font class="first">C</font>rypto-Based

	<font class="first">C</font>omponents

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Compositional Properties of Crypto-Based Components</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Maria Spichkova (maria /dot/ spichkova /at/ rmit /dot/ edu /dot/ au)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-01-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This paper presents an Isabelle/HOL set of theories which allows the specification of crypto-based components and the verification of their composition properties wrt. cryptographic aspects. We introduce a formalisation of the security property of data secrecy, the corresponding definitions and proofs. Please note that here we import the Isabelle/HOL theory ListExtras.thy, presented in the AFP entry FocusStreamsCaseStudies-AFP.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{CryptoBasedCompositionalProperties-AFP,
	author = {Maria Spichkova},
	title = {Compositional Properties of Crypto-Based Components},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/CryptoBasedCompositionalProperties.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CryptoBasedCompositionalProperties/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/CryptoBasedCompositionalProperties/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/CryptoBasedCompositionalProperties/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-CryptoBasedCompositionalProperties-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-CryptoBasedCompositionalProperties-2018-08-16.tar.gz">
	+ afp-CryptoBasedCompositionalProperties-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-CryptoBasedCompositionalProperties-2017-10-10.tar.gz">
	afp-CryptoBasedCompositionalProperties-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-CryptoBasedCompositionalProperties-2016-12-17.tar.gz">
	afp-CryptoBasedCompositionalProperties-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-CryptoBasedCompositionalProperties-2016-02-22.tar.gz">
	afp-CryptoBasedCompositionalProperties-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-CryptoBasedCompositionalProperties-2015-05-27.tar.gz">
	afp-CryptoBasedCompositionalProperties-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-CryptoBasedCompositionalProperties-2014-08-28.tar.gz">
	afp-CryptoBasedCompositionalProperties-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-CryptoBasedCompositionalProperties-2014-01-14.tar.gz">
	afp-CryptoBasedCompositionalProperties-2014-01-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-CryptoBasedCompositionalProperties-2014-01-11.tar.gz">
	afp-CryptoBasedCompositionalProperties-2014-01-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/DFS_Framework.html b/web/entries/DFS_Framework.html
	--- a/web/entries/DFS_Framework.html
	+++ b/web/entries/DFS_Framework.html
	@@ -1,213 +1,218 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Framework for Verifying Depth-First Search Algorithms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">F</font>ramework

	for

	<font class="first">V</font>erifying

	<font class="first">D</font>epth-First

	<font class="first">S</font>earch

	<font class="first">A</font>lgorithms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Framework for Verifying Depth-First Search Algorithms</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	René Neumann (rene /dot/ neumann /at/ in /dot/ tum /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-07-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	This entry presents a framework for the modular verification of
	DFS-based algorithms, which is described in our [CPP-2015] paper. It
	provides a generic DFS algorithm framework, that can be parameterized
	with user-defined actions on certain events (e.g. discovery of new
	node). It comes with an extensible library of invariants, which can
	be used to derive invariants of a specific parameterization. Using
	refinement techniques, efficient implementations of the algorithms can
	easily be derived. Here, the framework comes with templates for a
	recursive and a tail-recursive implementation, and also with several
	templates for implementing the data structures required by the DFS
	algorithm. Finally, this entry contains a set of re-usable DFS-based
	algorithms, which illustrate the application of the framework.
	</p><p>
	[CPP-2015] Peter Lammich, René Neumann: A Framework for Verifying
	Depth-First Search Algorithms. CPP 2015: 137-146</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{DFS_Framework-AFP,
	author = {Peter Lammich and René Neumann},
	title = {A Framework for Verifying Depth-First Search Algorithms},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/DFS_Framework.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CAVA_Automata.html">CAVA_Automata</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CAVA_LTL_Modelchecker.html">CAVA_LTL_Modelchecker</a>, <a href="Flow_Networks.html">Flow_Networks</a>, <a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a>, <a href="Transition_Systems_and_Automata.html">Transition_Systems_and_Automata</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DFS_Framework/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/DFS_Framework/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DFS_Framework/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-DFS_Framework-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-DFS_Framework-2018-08-16.tar.gz">
	+ afp-DFS_Framework-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-DFS_Framework-2017-10-10.tar.gz">
	afp-DFS_Framework-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-DFS_Framework-2016-12-17.tar.gz">
	afp-DFS_Framework-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-DFS_Framework-2016-07-05.tar.gz">
	afp-DFS_Framework-2016-07-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/DPT-SAT-Solver.html b/web/entries/DPT-SAT-Solver.html
	--- a/web/entries/DPT-SAT-Solver.html
	+++ b/web/entries/DPT-SAT-Solver.html
	@@ -1,251 +1,256 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Fast SAT Solver for Isabelle in Standard ML - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">F</font>ast

	<font class="first">S</font>AT

	<font class="first">S</font>olver

	for

	<font class="first">I</font>sabelle

	in

	<font class="first">S</font>tandard

	<font class="first">M</font>L

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Fast SAT Solver for Isabelle in Standard ML</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Armin Heller
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-12-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This contribution contains a fast SAT solver for Isabelle written in Standard ML. By loading the theory <tt>DPT_SAT_Solver</tt>, the SAT solver installs itself (under the name ``dptsat'') and certain Isabelle tools like Refute will start using it automatically. This is a port of the DPT (Decision Procedure Toolkit) SAT Solver written in OCaml.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{DPT-SAT-Solver-AFP,
	author = {Armin Heller},
	title = {A Fast SAT Solver for Isabelle in Standard ML},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/DPT-SAT-Solver.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DPT-SAT-Solver/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/DPT-SAT-Solver/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DPT-SAT-Solver/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-DPT-SAT-Solver-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-DPT-SAT-Solver-2018-08-16.tar.gz">
	+ afp-DPT-SAT-Solver-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-DPT-SAT-Solver-2017-10-10.tar.gz">
	afp-DPT-SAT-Solver-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-DPT-SAT-Solver-2016-12-17.tar.gz">
	afp-DPT-SAT-Solver-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-DPT-SAT-Solver-2016-02-22.tar.gz">
	afp-DPT-SAT-Solver-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-DPT-SAT-Solver-2015-07-27.tar.gz">
	afp-DPT-SAT-Solver-2015-07-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-DPT-SAT-Solver-2015-05-27.tar.gz">
	afp-DPT-SAT-Solver-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-DPT-SAT-Solver-2014-08-28.tar.gz">
	afp-DPT-SAT-Solver-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-DPT-SAT-Solver-2013-12-11.tar.gz">
	afp-DPT-SAT-Solver-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-DPT-SAT-Solver-2013-11-17.tar.gz">
	afp-DPT-SAT-Solver-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-DPT-SAT-Solver-2013-02-16.tar.gz">
	afp-DPT-SAT-Solver-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-DPT-SAT-Solver-2012-05-24.tar.gz">
	afp-DPT-SAT-Solver-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-DPT-SAT-Solver-2011-10-11.tar.gz">
	afp-DPT-SAT-Solver-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-DPT-SAT-Solver-2011-02-11.tar.gz">
	afp-DPT-SAT-Solver-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-DPT-SAT-Solver-2010-06-30.tar.gz">
	afp-DPT-SAT-Solver-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-DPT-SAT-Solver-2009-12-12.tar.gz">
	afp-DPT-SAT-Solver-2009-12-12.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/DataRefinementIBP.html b/web/entries/DataRefinementIBP.html
	--- a/web/entries/DataRefinementIBP.html
	+++ b/web/entries/DataRefinementIBP.html
	@@ -1,255 +1,260 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Semantics and Data Refinement of Invariant Based Programs - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>emantics

	and

	<font class="first">D</font>ata

	<font class="first">R</font>efinement

	of

	<font class="first">I</font>nvariant

	<font class="first">B</font>ased

	<font class="first">P</font>rograms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Semantics and Data Refinement of Invariant Based Programs</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Viorel Preoteasa (viorel /dot/ preoteasa /at/ aalto /dot/ fi) and
	<a href="http://users.abo.fi/Ralph-Johan.Back/">Ralph-Johan Back</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-05-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The invariant based programming is a technique of constructing correct programs by first identifying the basic situations (pre- and post-conditions and invariants) that can occur during the execution of the program, and then defining the transitions and proving that they preserve the invariants. Data refinement is a technique of building correct programs working on concrete datatypes as refinements of more abstract programs. In the theories presented here we formalize the predicate transformer semantics for invariant based programs and their data refinement.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2012-01-05]: Moved some general complete lattice properties to the AFP entry Lattice Properties.
	Changed the definition of the data refinement relation to be more general and updated all corresponding theorems.
	Added new syntax for demonic and angelic update statements.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{DataRefinementIBP-AFP,
	author = {Viorel Preoteasa and Ralph-Johan Back},
	title = {Semantics and Data Refinement of Invariant Based Programs},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/DataRefinementIBP.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="LatticeProperties.html">LatticeProperties</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="GraphMarkingIBP.html">GraphMarkingIBP</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DataRefinementIBP/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/DataRefinementIBP/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DataRefinementIBP/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-DataRefinementIBP-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-DataRefinementIBP-2018-08-16.tar.gz">
	+ afp-DataRefinementIBP-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-DataRefinementIBP-2017-10-10.tar.gz">
	afp-DataRefinementIBP-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-DataRefinementIBP-2016-12-17.tar.gz">
	afp-DataRefinementIBP-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-DataRefinementIBP-2016-02-22.tar.gz">
	afp-DataRefinementIBP-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-DataRefinementIBP-2015-05-27.tar.gz">
	afp-DataRefinementIBP-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-DataRefinementIBP-2014-08-28.tar.gz">
	afp-DataRefinementIBP-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-DataRefinementIBP-2013-12-11.tar.gz">
	afp-DataRefinementIBP-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-DataRefinementIBP-2013-11-17.tar.gz">
	afp-DataRefinementIBP-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-DataRefinementIBP-2013-02-16.tar.gz">
	afp-DataRefinementIBP-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-DataRefinementIBP-2012-05-24.tar.gz">
	afp-DataRefinementIBP-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-DataRefinementIBP-2011-10-11.tar.gz">
	afp-DataRefinementIBP-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-DataRefinementIBP-2011-02-11.tar.gz">
	afp-DataRefinementIBP-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-DataRefinementIBP-2010-06-30.tar.gz">
	afp-DataRefinementIBP-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-DataRefinementIBP-2010-05-28.tar.gz">
	afp-DataRefinementIBP-2010-05-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Datatype_Order_Generator.html b/web/entries/Datatype_Order_Generator.html
	--- a/web/entries/Datatype_Order_Generator.html
	+++ b/web/entries/Datatype_Order_Generator.html
	@@ -1,240 +1,245 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Generating linear orders for datatypes - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>enerating

	linear

	orders

	for

	datatypes

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Generating linear orders for datatypes</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-08-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	<p>
	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.
	<p>
	Our formalization was performed as part of the <a href="http://cl-informatik.uibk.ac.at/software/ceta">IsaFoR/CeTA</a> project.
	With our new tactic we could completely remove
	tedious proofs for linear orders of two datatypes.
	<p>
	This development is aimed at datatypes generated by the "old_datatype"
	command.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Datatype_Order_Generator.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Deriving.html">Deriving</a>, <a href="Native_Word.html">Native_Word</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Higher_Order_Terms.html">Higher_Order_Terms</a>, <a href="Show.html">Show</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Datatype_Order_Generator/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Datatype_Order_Generator/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Datatype_Order_Generator/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Datatype_Order_Generator-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Datatype_Order_Generator-2018-08-16.tar.gz">
	+ afp-Datatype_Order_Generator-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Datatype_Order_Generator-2017-10-10.tar.gz">
	afp-Datatype_Order_Generator-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Datatype_Order_Generator-2016-12-17.tar.gz">
	afp-Datatype_Order_Generator-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Datatype_Order_Generator-2016-02-22.tar.gz">
	afp-Datatype_Order_Generator-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Datatype_Order_Generator-2015-05-27.tar.gz">
	afp-Datatype_Order_Generator-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Datatype_Order_Generator-2014-08-28.tar.gz">
	afp-Datatype_Order_Generator-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Datatype_Order_Generator-2013-12-11.tar.gz">
	afp-Datatype_Order_Generator-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Datatype_Order_Generator-2013-11-17.tar.gz">
	afp-Datatype_Order_Generator-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Datatype_Order_Generator-2013-03-02.tar.gz">
	afp-Datatype_Order_Generator-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Datatype_Order_Generator-2013-02-16.tar.gz">
	afp-Datatype_Order_Generator-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Datatype_Order_Generator-2012-08-07.tar.gz">
	afp-Datatype_Order_Generator-2012-08-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Decl_Sem_Fun_PL.html b/web/entries/Decl_Sem_Fun_PL.html
	--- a/web/entries/Decl_Sem_Fun_PL.html
	+++ b/web/entries/Decl_Sem_Fun_PL.html
	@@ -1,202 +1,207 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Declarative Semantics for Functional Languages - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>eclarative

	<font class="first">S</font>emantics

	for

	<font class="first">F</font>unctional

	<font class="first">L</font>anguages

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Declarative Semantics for Functional Languages</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://homes.soic.indiana.edu/jsiek/">Jeremy Siek</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-07-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a semantics for an applied call-by-value lambda-calculus
	that is compositional, extensional, and elementary. We present four
	different views of the semantics: 1) as a relational (big-step)
	semantics that is not operational but instead declarative, 2) as a
	denotational semantics that does not use domain theory, 3) as a
	non-deterministic interpreter, and 4) as a variant of the intersection
	type systems of the Torino group. We prove that the semantics is
	correct by showing that it is sound and complete with respect to
	operational semantics on programs and that is sound with respect to
	contextual equivalence. We have not yet investigated whether it is
	fully abstract. We demonstrate that this approach to semantics is
	useful with three case studies. First, we use the semantics to prove
	correctness of a compiler optimization that inlines function
	application. Second, we adapt the semantics to the polymorphic
	lambda-calculus extended with general recursion and prove semantic
	type soundness. Third, we adapt the semantics to the call-by-value
	lambda-calculus with mutable references.
	<br>
	The paper that accompanies these Isabelle theories is <a href="https://arxiv.org/abs/1707.03762">available on arXiv</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Decl_Sem_Fun_PL-AFP,
	author = {Jeremy Siek},
	title = {Declarative Semantics for Functional Languages},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Decl_Sem_Fun_PL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Decl_Sem_Fun_PL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Decl_Sem_Fun_PL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Decl_Sem_Fun_PL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Decl_Sem_Fun_PL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Decl_Sem_Fun_PL-2018-08-16.tar.gz">
	+ afp-Decl_Sem_Fun_PL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Decl_Sem_Fun_PL-2017-10-10.tar.gz">
	afp-Decl_Sem_Fun_PL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Decl_Sem_Fun_PL-2017-07-24.tar.gz">
	afp-Decl_Sem_Fun_PL-2017-07-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Decreasing-Diagrams-II.html b/web/entries/Decreasing-Diagrams-II.html
	--- a/web/entries/Decreasing-Diagrams-II.html
	+++ b/web/entries/Decreasing-Diagrams-II.html
	@@ -1,191 +1,196 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Decreasing Diagrams II - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>ecreasing

	<font class="first">D</font>iagrams

	<font class="first">I</font>I

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Decreasing Diagrams II</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Bertram Felgenhauer
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-08-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Decreasing-Diagrams-II-AFP,
	author = {Bertram Felgenhauer},
	title = {Decreasing Diagrams II},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Decreasing-Diagrams-II.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a>, <a href="Open_Induction.html">Open_Induction</a>, <a href="Well_Quasi_Orders.html">Well_Quasi_Orders</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Decreasing-Diagrams-II/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Decreasing-Diagrams-II/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Decreasing-Diagrams-II/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Decreasing-Diagrams-II-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Decreasing-Diagrams-II-2018-08-16.tar.gz">
	+ afp-Decreasing-Diagrams-II-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Decreasing-Diagrams-II-2017-10-10.tar.gz">
	afp-Decreasing-Diagrams-II-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Decreasing-Diagrams-II-2016-12-17.tar.gz">
	afp-Decreasing-Diagrams-II-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Decreasing-Diagrams-II-2016-02-22.tar.gz">
	afp-Decreasing-Diagrams-II-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Decreasing-Diagrams-II-2015-08-21.tar.gz">
	afp-Decreasing-Diagrams-II-2015-08-21.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Decreasing-Diagrams.html b/web/entries/Decreasing-Diagrams.html
	--- a/web/entries/Decreasing-Diagrams.html
	+++ b/web/entries/Decreasing-Diagrams.html
	@@ -1,209 +1,214 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Decreasing Diagrams - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>ecreasing

	<font class="first">D</font>iagrams

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Decreasing Diagrams</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/users/hzankl">Harald Zankl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-11-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This theory contains a formalization of decreasing diagrams showing that any locally decreasing abstract rewrite system is confluent. We consider the valley (van Oostrom, TCS 1994) and the conversion version (van Oostrom, RTA 2008) and closely follow the original proofs. As an application we prove Newman's lemma.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Decreasing-Diagrams-AFP,
	author = {Harald Zankl},
	title = {Decreasing Diagrams},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Decreasing-Diagrams.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Decreasing-Diagrams/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Decreasing-Diagrams/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Decreasing-Diagrams/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Decreasing-Diagrams-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Decreasing-Diagrams-2018-08-16.tar.gz">
	+ afp-Decreasing-Diagrams-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Decreasing-Diagrams-2017-10-10.tar.gz">
	afp-Decreasing-Diagrams-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Decreasing-Diagrams-2016-12-17.tar.gz">
	afp-Decreasing-Diagrams-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Decreasing-Diagrams-2016-02-22.tar.gz">
	afp-Decreasing-Diagrams-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Decreasing-Diagrams-2015-05-27.tar.gz">
	afp-Decreasing-Diagrams-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Decreasing-Diagrams-2014-08-28.tar.gz">
	afp-Decreasing-Diagrams-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Decreasing-Diagrams-2013-12-11.tar.gz">
	afp-Decreasing-Diagrams-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Decreasing-Diagrams-2013-12-02.tar.gz">
	afp-Decreasing-Diagrams-2013-12-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Decreasing-Diagrams-2013-11-18.tar.gz">
	afp-Decreasing-Diagrams-2013-11-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Deep_Learning.html b/web/entries/Deep_Learning.html
	--- a/web/entries/Deep_Learning.html
	+++ b/web/entries/Deep_Learning.html
	@@ -1,191 +1,196 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Expressiveness of Deep Learning - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>xpressiveness

	of

	<font class="first">D</font>eep

	<font class="first">L</font>earning

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Expressiveness of Deep Learning</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Alexander Bentkamp (bentkamp /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-11-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Deep learning has had a profound impact on computer science in recent years, with applications to search engines, image recognition and language processing, bioinformatics, and more. Recently, Cohen et al. provided theoretical evidence for the superiority of deep learning over shallow learning. This formalization of their work simplifies and generalizes the original proof, while working around the limitations of the Isabelle type system. To support the formalization, I developed reusable libraries of formalized mathematics, including results about the matrix rank, the Lebesgue measure, and multivariate polynomials, as well as a library for tensor analysis.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Deep_Learning-AFP,
	author = {Alexander Bentkamp},
	title = {Expressiveness of Deep Learning},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Deep_Learning.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a>, <a href="Polynomial_Interpolation.html">Polynomial_Interpolation</a>, <a href="Polynomials.html">Polynomials</a>, <a href="VectorSpace.html">VectorSpace</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="QHLProver.html">QHLProver</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Deep_Learning/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Deep_Learning/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Deep_Learning/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Deep_Learning-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Deep_Learning-2018-08-16.tar.gz">
	+ afp-Deep_Learning-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Deep_Learning-2017-10-10.tar.gz">
	afp-Deep_Learning-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Deep_Learning-2016-12-17.tar.gz">
	afp-Deep_Learning-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Deep_Learning-2016-11-10.tar.gz">
	afp-Deep_Learning-2016-11-10.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Density_Compiler.html b/web/entries/Density_Compiler.html
	--- a/web/entries/Density_Compiler.html
	+++ b/web/entries/Density_Compiler.html
	@@ -1,225 +1,230 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Verified Compiler for Probability Density Functions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">V</font>erified

	<font class="first">C</font>ompiler

	for

	<font class="first">P</font>robability

	<font class="first">D</font>ensity

	<font class="first">F</font>unctions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Verified Compiler for Probability Density Functions</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>,
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-10-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<a href="https://doi.org/10.1007/978-3-642-36742-7_35">Bhat et al. [TACAS 2013]</a> developed an inductive compiler that computes
	density functions for probability spaces described by programs in a
	probabilistic functional language. In this work, we implement such a
	compiler for a modified version of this language within the theorem prover
	Isabelle and give a formal proof of its soundness w.r.t. the semantics of
	the source and target language. Together with Isabelle's code generation
	for inductive predicates, this yields a fully verified, executable density
	compiler. The proof is done in two steps: First, an abstract compiler
	working with abstract functions modelled directly in the theorem prover's
	logic is defined and proved sound. Then, this compiler is refined to a
	concrete version that returns a target-language expression.
	<p>
	An article with the same title and authors is published in the proceedings
	of ESOP 2015.
	A detailed presentation of this work can be found in the first author's
	master's thesis.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Density_Compiler-AFP,
	author = {Manuel Eberl and Johannes Hölzl and Tobias Nipkow},
	title = {A Verified Compiler for Probability Density Functions},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Density_Compiler.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Density_Compiler/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Density_Compiler/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Density_Compiler/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Density_Compiler-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Density_Compiler-2018-08-16.tar.gz">
	+ afp-Density_Compiler-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Density_Compiler-2017-10-10.tar.gz">
	afp-Density_Compiler-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Density_Compiler-2016-12-17.tar.gz">
	afp-Density_Compiler-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Density_Compiler-2016-02-22.tar.gz">
	afp-Density_Compiler-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Density_Compiler-2015-05-27.tar.gz">
	afp-Density_Compiler-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Density_Compiler-2014-12-22.tar.gz">
	afp-Density_Compiler-2014-12-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Density_Compiler-2014-10-09.tar.gz">
	afp-Density_Compiler-2014-10-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Dependent_SIFUM_Refinement.html b/web/entries/Dependent_SIFUM_Refinement.html
	--- a/web/entries/Dependent_SIFUM_Refinement.html
	+++ b/web/entries/Dependent_SIFUM_Refinement.html
	@@ -1,212 +1,217 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Compositional Security-Preserving Refinement for Concurrent Imperative Programs - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ompositional

	<font class="first">S</font>ecurity-Preserving

	<font class="first">R</font>efinement

	for

	<font class="first">C</font>oncurrent

	<font class="first">I</font>mperative

	<font class="first">P</font>rograms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Compositional Security-Preserving Refinement for Concurrent Imperative Programs</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://people.eng.unimelb.edu.au/tobym/">Toby Murray</a>,
	Robert Sison,
	Edward Pierzchalski and
	Christine Rizkallah
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The paper "Compositional Verification and Refinement of Concurrent
	Value-Dependent Noninterference" by Murray et. al. (CSF 2016) presents
	a compositional theory of refinement for a value-dependent
	noninterference property, defined in (Murray, PLAS 2015), for
	concurrent programs. This development formalises that refinement
	theory, and demonstrates its application on some small examples.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2016-08-19]:
	Removed unused "stop" parameters from the sifum_refinement locale.
	(revision dbc482d36372)
	[2016-09-02]:
	TobyM extended "simple" refinement theory to be usable for all bisimulations.
	(revision 547f31c25f60)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Dependent_SIFUM_Refinement-AFP,
	author = {Toby Murray and Robert Sison and Edward Pierzchalski and Christine Rizkallah},
	title = {Compositional Security-Preserving Refinement for Concurrent Imperative Programs},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Dependent_SIFUM_Refinement.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Dependent_SIFUM_Type_Systems.html">Dependent_SIFUM_Type_Systems</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dependent_SIFUM_Refinement/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Dependent_SIFUM_Refinement/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dependent_SIFUM_Refinement/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Dependent_SIFUM_Refinement-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Dependent_SIFUM_Refinement-2018-08-16.tar.gz">
	+ afp-Dependent_SIFUM_Refinement-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Dependent_SIFUM_Refinement-2017-10-10.tar.gz">
	afp-Dependent_SIFUM_Refinement-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Dependent_SIFUM_Refinement-2016-12-17.tar.gz">
	afp-Dependent_SIFUM_Refinement-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Dependent_SIFUM_Refinement-2016-06-28.tar.gz">
	afp-Dependent_SIFUM_Refinement-2016-06-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Dependent_SIFUM_Type_Systems.html b/web/entries/Dependent_SIFUM_Type_Systems.html
	--- a/web/entries/Dependent_SIFUM_Type_Systems.html
	+++ b/web/entries/Dependent_SIFUM_Type_Systems.html
	@@ -1,219 +1,224 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Dependent Security Type System for Concurrent Imperative Programs - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">D</font>ependent

	<font class="first">S</font>ecurity

	<font class="first">T</font>ype

	<font class="first">S</font>ystem

	for

	<font class="first">C</font>oncurrent

	<font class="first">I</font>mperative

	<font class="first">P</font>rograms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Dependent Security Type System for Concurrent Imperative Programs</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://people.eng.unimelb.edu.au/tobym/">Toby Murray</a>,
	Robert Sison,
	Edward Pierzchalski and
	Christine Rizkallah
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The paper "Compositional Verification and Refinement of Concurrent
	Value-Dependent Noninterference" by Murray et. al. (CSF 2016) presents
	a dependent security type system for compositionally verifying a
	value-dependent noninterference property, defined in (Murray, PLAS
	2015), for concurrent programs. This development formalises that
	security definition, the type system and its soundness proof, and
	demonstrates its application on some small examples. It was derived
	from the SIFUM_Type_Systems AFP entry, by Sylvia Grewe, Heiko Mantel
	and Daniel Schoepe, and whose structure it inherits.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2016-08-19]:
	Removed unused "stop" parameter and "stop_no_eval" assumption from the sifum_security locale.
	(revision dbc482d36372)
	[2016-09-27]:
	Added security locale support for the imposition of requirements on the initial memory.
	(revision cce4ceb74ddb)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Dependent_SIFUM_Type_Systems-AFP,
	author = {Toby Murray and Robert Sison and Edward Pierzchalski and Christine Rizkallah},
	title = {A Dependent Security Type System for Concurrent Imperative Programs},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Dependent_SIFUM_Type_Systems.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Dependent_SIFUM_Refinement.html">Dependent_SIFUM_Refinement</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dependent_SIFUM_Type_Systems/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Dependent_SIFUM_Type_Systems/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dependent_SIFUM_Type_Systems/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Dependent_SIFUM_Type_Systems-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Dependent_SIFUM_Type_Systems-2018-08-16.tar.gz">
	+ afp-Dependent_SIFUM_Type_Systems-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Dependent_SIFUM_Type_Systems-2017-10-10.tar.gz">
	afp-Dependent_SIFUM_Type_Systems-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Dependent_SIFUM_Type_Systems-2016-12-17.tar.gz">
	afp-Dependent_SIFUM_Type_Systems-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Dependent_SIFUM_Type_Systems-2016-06-25.tar.gz">
	afp-Dependent_SIFUM_Type_Systems-2016-06-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Depth-First-Search.html b/web/entries/Depth-First-Search.html
	--- a/web/entries/Depth-First-Search.html
	+++ b/web/entries/Depth-First-Search.html
	@@ -1,260 +1,265 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Depth First Search - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>epth

	<font class="first">F</font>irst

	<font class="first">S</font>earch

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Depth First Search</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Toshiaki Nishihara and
	Yasuhiko Minamide
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-06-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Depth-first search of a graph is formalized with recdef. It is shown that it visits all of the reachable nodes from a given list of nodes. Executable ML code of depth-first search is obtained using the code generation feature of Isabelle/HOL.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Depth-First-Search-AFP,
	author = {Toshiaki Nishihara and Yasuhiko Minamide},
	title = {Depth First Search},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Depth-First-Search.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Depth-First-Search/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Depth-First-Search/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Depth-First-Search/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Depth-First-Search-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Depth-First-Search-2018-08-16.tar.gz">
	+ afp-Depth-First-Search-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Depth-First-Search-2017-10-10.tar.gz">
	afp-Depth-First-Search-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Depth-First-Search-2016-12-17.tar.gz">
	afp-Depth-First-Search-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Depth-First-Search-2016-02-22.tar.gz">
	afp-Depth-First-Search-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Depth-First-Search-2015-05-27.tar.gz">
	afp-Depth-First-Search-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Depth-First-Search-2014-08-28.tar.gz">
	afp-Depth-First-Search-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Depth-First-Search-2013-12-11.tar.gz">
	afp-Depth-First-Search-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Depth-First-Search-2013-11-17.tar.gz">
	afp-Depth-First-Search-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Depth-First-Search-2013-02-16.tar.gz">
	afp-Depth-First-Search-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Depth-First-Search-2012-05-24.tar.gz">
	afp-Depth-First-Search-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Depth-First-Search-2011-10-11.tar.gz">
	afp-Depth-First-Search-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Depth-First-Search-2011-02-11.tar.gz">
	afp-Depth-First-Search-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Depth-First-Search-2010-06-30.tar.gz">
	afp-Depth-First-Search-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Depth-First-Search-2009-12-12.tar.gz">
	afp-Depth-First-Search-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Depth-First-Search-2009-04-29.tar.gz">
	afp-Depth-First-Search-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Depth-First-Search-2008-06-10.tar.gz">
	afp-Depth-First-Search-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Depth-First-Search-2007-11-27.tar.gz">
	afp-Depth-First-Search-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Depth-First-Search-2005-10-14.tar.gz">
	afp-Depth-First-Search-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Depth-First-Search-2004-06-24.tar.gz">
	afp-Depth-First-Search-2004-06-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Derangements.html b/web/entries/Derangements.html
	--- a/web/entries/Derangements.html
	+++ b/web/entries/Derangements.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Derangements Formula - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>erangements

	<font class="first">F</font>ormula

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Derangements Formula</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-06-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The Derangements Formula describes the number of fixpoint-free permutations
	as a closed formula. This theorem is the 88th theorem in a list of the
	``<a href="http://www.cs.ru.nl/~freek/100/">Top 100 Mathematical Theorems</a>''.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Derangements-AFP,
	author = {Lukas Bulwahn},
	title = {Derangements Formula},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Derangements.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Derangements/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Derangements/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Derangements/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Derangements-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Derangements-2018-08-16.tar.gz">
	+ afp-Derangements-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Derangements-2017-10-10.tar.gz">
	afp-Derangements-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Derangements-2016-12-17.tar.gz">
	afp-Derangements-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Derangements-2016-02-22.tar.gz">
	afp-Derangements-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Derangements-2015-11-20.tar.gz">
	afp-Derangements-2015-11-20.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Derangements-2015-06-28.tar.gz">
	afp-Derangements-2015-06-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Deriving.html b/web/entries/Deriving.html
	--- a/web/entries/Deriving.html
	+++ b/web/entries/Deriving.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Deriving class instances for datatypes - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>eriving

	class

	instances

	for

	datatypes

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Deriving class instances for datatypes</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-03-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>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.</p>
	<p>We further implemented such automatic methods to derive comparators, linear orders, parametrizable equality functions,
	and hash-functions which are required in the
	Isabelle Collection Framework and the Container Framework.
	Moreover, for the tactic of Blanchette to show that a datatype is countable, we implemented a
	wrapper so that this tactic becomes accessible in our framework. All of the generators are based on
	the infrastructure that is provided by the BNF-based datatype package.</p>
	<p>Our formalization was performed as part of the <a href="http://cl-informatik.uibk.ac.at/software/ceta">IsaFoR/CeTA</a> project.
	With our new tactics we could remove
	several tedious proofs for (conditional) linear orders, and conditional equality operators
	within IsaFoR and the Container Framework.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Deriving-AFP,
	author = {Christian Sternagel and René Thiemann},
	title = {Deriving class instances for datatypes},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Deriving.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	- <td class="data"><a href="Collections.html">Collections</a>, <a href="Native_Word.html">Native_Word</a> </td></tr>
	+ <td class="data"><a href="Collections.html">Collections</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Affine_Arithmetic.html">Affine_Arithmetic</a>, <a href="CAVA_Automata.html">CAVA_Automata</a>, <a href="Containers.html">Containers</a>, <a href="Datatype_Order_Generator.html">Datatype_Order_Generator</a>, <a href="Formula_Derivatives.html">Formula_Derivatives</a>, <a href="Groebner_Bases.html">Groebner_Bases</a>, <a href="MSO_Regex_Equivalence.html">MSO_Regex_Equivalence</a>, <a href="Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a>, <a href="Real_Impl.html">Real_Impl</a>, <a href="Show.html">Show</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Deriving/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Deriving/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Deriving/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Deriving-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Deriving-2018-08-16.tar.gz">
	+ afp-Deriving-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Deriving-2017-10-10.tar.gz">
	afp-Deriving-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Deriving-2016-12-17.tar.gz">
	afp-Deriving-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Deriving-2016-02-22.tar.gz">
	afp-Deriving-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Deriving-2015-05-27.tar.gz">
	afp-Deriving-2015-05-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Descartes_Sign_Rule.html b/web/entries/Descartes_Sign_Rule.html
	--- a/web/entries/Descartes_Sign_Rule.html
	+++ b/web/entries/Descartes_Sign_Rule.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Descartes' Rule of Signs - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>escartes'

	<font class="first">R</font>ule

	of

	<font class="first">S</font>igns

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Descartes' Rule of Signs</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	Descartes' Rule of Signs relates the number of positive real roots of a
	polynomial with the number of sign changes in its coefficient sequence.
	</p><p>
	Our proof follows the simple inductive proof given by Rob Arthan, which was also
	used by John Harrison in his HOL Light formalisation. We proved most of the
	lemmas for arbitrary linearly-ordered integrity domains (e.g. integers,
	rationals, reals); the main result, however, requires the intermediate value
	theorem and was therefore only proven for real polynomials.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Descartes_Sign_Rule-AFP,
	author = {Manuel Eberl},
	title = {Descartes' Rule of Signs},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Descartes_Sign_Rule.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Descartes_Sign_Rule/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Descartes_Sign_Rule/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Descartes_Sign_Rule/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Descartes_Sign_Rule-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Descartes_Sign_Rule-2018-08-16.tar.gz">
	+ afp-Descartes_Sign_Rule-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Descartes_Sign_Rule-2017-10-10.tar.gz">
	afp-Descartes_Sign_Rule-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Descartes_Sign_Rule-2016-12-17.tar.gz">
	afp-Descartes_Sign_Rule-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Descartes_Sign_Rule-2016-02-22.tar.gz">
	afp-Descartes_Sign_Rule-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Descartes_Sign_Rule-2016-01-05.tar.gz">
	afp-Descartes_Sign_Rule-2016-01-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Dict_Construction.html b/web/entries/Dict_Construction.html
	--- a/web/entries/Dict_Construction.html
	+++ b/web/entries/Dict_Construction.html
	@@ -1,181 +1,186 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Dictionary Construction - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>ictionary

	<font class="first">C</font>onstruction

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Dictionary Construction</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Isabelle's code generator natively supports type classes. For
	targets that do not have language support for classes and instances,
	it performs the well-known dictionary translation, as described by
	Haftmann and Nipkow. This translation happens outside the logic, i.e.,
	there is no guarantee that it is correct, besides the pen-and-paper
	proof. This work implements a certified dictionary translation that
	produces new class-free constants and derives equality theorems.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Dict_Construction-AFP,
	author = {Lars Hupel},
	title = {Dictionary Construction},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Dict_Construction.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Automatic_Refinement.html">Automatic_Refinement</a>, <a href="Lazy_Case.html">Lazy_Case</a>, <a href="Show.html">Show</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dict_Construction/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Dict_Construction/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dict_Construction/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Dict_Construction-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Dict_Construction-2018-08-16.tar.gz">
	+ afp-Dict_Construction-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Dict_Construction-2017-10-10.tar.gz">
	afp-Dict_Construction-2017-10-10.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Differential_Dynamic_Logic.html b/web/entries/Differential_Dynamic_Logic.html
	--- a/web/entries/Differential_Dynamic_Logic.html
	+++ b/web/entries/Differential_Dynamic_Logic.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Differential Dynamic Logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>ifferential

	<font class="first">D</font>ynamic

	<font class="first">L</font>ogic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Differential Dynamic Logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Brandon Bohrer (bbohrer /at/ cs /dot/ cmu /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-02-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize differential dynamic logic, a logic for proving
	properties of hybrid systems. The proof calculus in this formalization
	is based on the uniform substitution principle. We show it is sound
	with respect to our denotational semantics, which provides increased
	confidence in the correctness of the KeYmaera X theorem prover based
	on this calculus. As an application, we include a proof term checker
	embedded in Isabelle/HOL with several example proofs. Published in:
	Brandon Bohrer, Vincent Rahli, Ivana Vukotic, Marcus Völp, André
	Platzer: Formally verified differential dynamic logic. CPP 2017.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Differential_Dynamic_Logic-AFP,
	author = {Brandon Bohrer},
	title = {Differential Dynamic Logic},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Differential_Dynamic_Logic.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Differential_Dynamic_Logic/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Differential_Dynamic_Logic/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Differential_Dynamic_Logic/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Differential_Dynamic_Logic-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Differential_Dynamic_Logic-2018-08-16.tar.gz">
	+ afp-Differential_Dynamic_Logic-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Differential_Dynamic_Logic-2017-10-10.tar.gz">
	afp-Differential_Dynamic_Logic-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Differential_Dynamic_Logic-2017-02-14.tar.gz">
	afp-Differential_Dynamic_Logic-2017-02-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Dijkstra_Shortest_Path.html b/web/entries/Dijkstra_Shortest_Path.html
	--- a/web/entries/Dijkstra_Shortest_Path.html
	+++ b/web/entries/Dijkstra_Shortest_Path.html
	@@ -1,240 +1,245 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Dijkstra's Shortest Path Algorithm - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>ijkstra's

	<font class="first">S</font>hortest

	<font class="first">P</font>ath

	<font class="first">A</font>lgorithm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Dijkstra's Shortest Path Algorithm</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Benedikt Nordhoff (b_nord01 /at/ uni-muenster /dot/ de) and
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-01-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We implement and prove correct Dijkstra's algorithm for the
	single source shortest path problem, conceived in 1956 by E. Dijkstra.
	The algorithm is implemented using the data refinement framework for monadic,
	nondeterministic programs. An efficient implementation is derived using data
	structures from the Isabelle Collection Framework.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Dijkstra_Shortest_Path-AFP,
	author = {Benedikt Nordhoff and Peter Lammich},
	title = {Dijkstra's Shortest Path Algorithm},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Dijkstra_Shortest_Path.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Collections.html">Collections</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Formal_SSA.html">Formal_SSA</a>, <a href="Koenigsberg_Friendship.html">Koenigsberg_Friendship</a>, <a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dijkstra_Shortest_Path/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Dijkstra_Shortest_Path/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dijkstra_Shortest_Path/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Dijkstra_Shortest_Path-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Dijkstra_Shortest_Path-2018-08-16.tar.gz">
	+ afp-Dijkstra_Shortest_Path-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Dijkstra_Shortest_Path-2017-10-10.tar.gz">
	afp-Dijkstra_Shortest_Path-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Dijkstra_Shortest_Path-2016-12-17.tar.gz">
	afp-Dijkstra_Shortest_Path-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Dijkstra_Shortest_Path-2016-02-22.tar.gz">
	afp-Dijkstra_Shortest_Path-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Dijkstra_Shortest_Path-2015-05-27.tar.gz">
	afp-Dijkstra_Shortest_Path-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Dijkstra_Shortest_Path-2014-08-28.tar.gz">
	afp-Dijkstra_Shortest_Path-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Dijkstra_Shortest_Path-2013-12-11.tar.gz">
	afp-Dijkstra_Shortest_Path-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Dijkstra_Shortest_Path-2013-11-17.tar.gz">
	afp-Dijkstra_Shortest_Path-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Dijkstra_Shortest_Path-2013-03-08.tar.gz">
	afp-Dijkstra_Shortest_Path-2013-03-08.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Dijkstra_Shortest_Path-2013-02-16.tar.gz">
	afp-Dijkstra_Shortest_Path-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Dijkstra_Shortest_Path-2012-05-24.tar.gz">
	afp-Dijkstra_Shortest_Path-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Dijkstra_Shortest_Path-2012-03-15.tar.gz">
	afp-Dijkstra_Shortest_Path-2012-03-15.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Dijkstra_Shortest_Path-2012-02-10.tar.gz">
	afp-Dijkstra_Shortest_Path-2012-02-10.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Diophantine_Eqns_Lin_Hom.html b/web/entries/Diophantine_Eqns_Lin_Hom.html
	--- a/web/entries/Diophantine_Eqns_Lin_Hom.html
	+++ b/web/entries/Diophantine_Eqns_Lin_Hom.html
	@@ -1,189 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Homogeneous Linear Diophantine Equations - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>omogeneous

	<font class="first">L</font>inear

	<font class="first">D</font>iophantine

	<font class="first">E</font>quations

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Homogeneous Linear Diophantine Equations</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Florian Messner (florian /dot/ g /dot/ messner /at/ uibk /dot/ ac /dot/ at),
	Julian Parsert (julian /dot/ parsert /at/ gmail /dot/ com),
	Jonas Schöpf (jonas /dot/ schoepf /at/ uibk /dot/ ac /dot/ at) and
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-10-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize the theory of homogeneous linear diophantine equations,
	focusing on two main results: (1) an abstract characterization of
	minimal complete sets of solutions, and (2) an algorithm computing
	them. Both, the characterization and the algorithm are based on
	previous work by Huet. Our starting point is a simple but inefficient
	variant of Huet's lexicographic algorithm incorporating improved
	bounds due to Clausen and Fortenbacher. We proceed by proving its
	soundness and completeness. Finally, we employ code equations to
	obtain a reasonably efficient implementation. Thus, we provide a
	formally verified solver for homogeneous linear diophantine equations.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Diophantine_Eqns_Lin_Hom-AFP,
	author = {Florian Messner and Julian Parsert and Jonas Schöpf and Christian Sternagel},
	title = {Homogeneous Linear Diophantine Equations},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Diophantine_Eqns_Lin_Hom.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Diophantine_Eqns_Lin_Hom/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Diophantine_Eqns_Lin_Hom/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Diophantine_Eqns_Lin_Hom/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Diophantine_Eqns_Lin_Hom-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Diophantine_Eqns_Lin_Hom-2018-08-16.tar.gz">
	+ afp-Diophantine_Eqns_Lin_Hom-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Diophantine_Eqns_Lin_Hom-2017-10-15.tar.gz">
	afp-Diophantine_Eqns_Lin_Hom-2017-10-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Dirichlet_L.html b/web/entries/Dirichlet_L.html
	--- a/web/entries/Dirichlet_L.html
	+++ b/web/entries/Dirichlet_L.html
	@@ -1,187 +1,193 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Dirichlet L-Functions and Dirichlet's Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>irichlet

	<font class="first">L</font>-Functions

	and

	<font class="first">D</font>irichlet's

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Dirichlet L-Functions and Dirichlet's Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-12-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This article provides a formalisation of Dirichlet characters
	and Dirichlet <em>L</em>-functions including proofs of
	their basic properties – most notably their analyticity,
	their areas of convergence, and their non-vanishing for &Re;(s)
	≥ 1. All of this is built in a very high-level style using
	Dirichlet series. The proof of the non-vanishing follows a very short
	and elegant proof by Newman, which we attempt to reproduce faithfully
	in a similar level of abstraction in Isabelle.</p> <p>This
	also leads to a relatively short proof of Dirichlet’s Theorem, which
	states that, if <em>h</em> and <em>n</em> are
	coprime, there are infinitely many primes <em>p</em> with
	<em>p</em> &equiv; <em>h</em> (mod
	<em>n</em>).</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Dirichlet_L-AFP,
	author = {Manuel Eberl},
	title = {Dirichlet L-Functions and Dirichlet's Theorem},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Dirichlet_L.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Bertrands_Postulate.html">Bertrands_Postulate</a>, <a href="Dirichlet_Series.html">Dirichlet_Series</a>, <a href="Landau_Symbols.html">Landau_Symbols</a>, <a href="Zeta_Function.html">Zeta_Function</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dirichlet_L/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Dirichlet_L/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dirichlet_L/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Dirichlet_L-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Dirichlet_L-2018-08-16.tar.gz">
	+ afp-Dirichlet_L-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Dirichlet_Series.html b/web/entries/Dirichlet_Series.html
	--- a/web/entries/Dirichlet_Series.html
	+++ b/web/entries/Dirichlet_Series.html
	@@ -1,194 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Dirichlet Series - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>irichlet

	<font class="first">S</font>eries

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Dirichlet Series</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-10-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry is a formalisation of much of Chapters 2, 3, and 11 of
	Apostol's “Introduction to Analytic Number
	Theory”. This includes: <ul> <li>Definitions and
	basic properties for several number-theoretic functions (Euler's
	φ, Möbius μ, Liouville's λ,
	the divisor function σ, von Mangoldt's
	Λ)</li> <li>Executable code for most of these
	functions, the most efficient implementations using the factoring
	algorithm by Thiemann <i>et al.</i></li>
	<li>Dirichlet products and formal Dirichlet series</li>
	<li>Analytic results connecting convergent formal Dirichlet
	series to complex functions</li> <li>Euler product
	expansions</li> <li>Asymptotic estimates of
	number-theoretic functions including the density of squarefree
	integers and the average number of divisors of a natural
	number</li> </ul> These results are useful as a basis for
	developing more number-theoretic results, such as the Prime Number
	Theorem.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Dirichlet_Series-AFP,
	author = {Manuel Eberl},
	title = {Dirichlet Series},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Dirichlet_Series.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Euler_MacLaurin.html">Euler_MacLaurin</a>, <a href="Landau_Symbols.html">Landau_Symbols</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Dirichlet_L.html">Dirichlet_L</a>, <a href="Zeta_Function.html">Zeta_Function</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dirichlet_Series/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Dirichlet_Series/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dirichlet_Series/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Dirichlet_Series-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Dirichlet_Series-2018-08-16.tar.gz">
	+ afp-Dirichlet_Series-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Dirichlet_Series-2017-10-16.tar.gz">
	afp-Dirichlet_Series-2017-10-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/DiscretePricing.html b/web/entries/DiscretePricing.html
	--- a/web/entries/DiscretePricing.html
	+++ b/web/entries/DiscretePricing.html
	@@ -1,194 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Pricing in discrete financial models - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>ricing

	in

	discrete

	financial

	models

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Pricing in discrete financial models</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://lig-membres.imag.fr/mechenim/">Mnacho Echenim</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-07-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We have formalized the computation of fair prices for derivative
	products in discrete financial models. As an application, we derive a
	way to compute fair prices of derivative products in the
	Cox-Ross-Rubinstein model of a financial market, thus completing the
	work that was presented in this <a
	href="https://hal.archives-ouvertes.fr/hal-01562944">paper</a>.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2019-05-12]:
	Renamed discr_mkt predicate to stk_strict_subs and got rid of predicate A for a more natural definition of the type discrete_market;
	renamed basic quantity processes for coherent notation;
	renamed value_process into val_process and closing_value_process to cls_val_process;
	relaxed hypothesis of lemma CRR_market_fair_price.
	Added functions to price some basic options.
	(revision 0b813a1a833f)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{DiscretePricing-AFP,
	author = {Mnacho Echenim},
	title = {Pricing in discrete financial models},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/DiscretePricing.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DiscretePricing/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/DiscretePricing/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DiscretePricing/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-DiscretePricing-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-DiscretePricing-2018-08-16.tar.gz">
	+ afp-DiscretePricing-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-DiscretePricing-2018-07-18.tar.gz">
	afp-DiscretePricing-2018-07-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Discrete_Summation.html b/web/entries/Discrete_Summation.html
	--- a/web/entries/Discrete_Summation.html
	+++ b/web/entries/Discrete_Summation.html
	@@ -1,207 +1,212 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Discrete Summation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>iscrete

	<font class="first">S</font>ummation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Discrete Summation</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://isabelle.in.tum.de/~haftmann">Florian Haftmann</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	Amine Chaieb
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-04-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">These theories introduce basic concepts and proofs about discrete summation: shifts, formal summation, falling factorials and stirling numbers. As proof of concept, a simple summation conversion is provided.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Discrete_Summation-AFP,
	author = {Florian Haftmann},
	title = {Discrete Summation},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Discrete_Summation.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Card_Partitions.html">Card_Partitions</a>, <a href="Falling_Factorial_Sum.html">Falling_Factorial_Sum</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Discrete_Summation/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Discrete_Summation/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Discrete_Summation/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Discrete_Summation-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Discrete_Summation-2018-08-16.tar.gz">
	+ afp-Discrete_Summation-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Discrete_Summation-2017-10-10.tar.gz">
	afp-Discrete_Summation-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Discrete_Summation-2016-12-17.tar.gz">
	afp-Discrete_Summation-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Discrete_Summation-2016-02-22.tar.gz">
	afp-Discrete_Summation-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Discrete_Summation-2015-05-27.tar.gz">
	afp-Discrete_Summation-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Discrete_Summation-2014-08-28.tar.gz">
	afp-Discrete_Summation-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Discrete_Summation-2014-04-13.tar.gz">
	afp-Discrete_Summation-2014-04-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/DiskPaxos.html b/web/entries/DiskPaxos.html
	--- a/web/entries/DiskPaxos.html
	+++ b/web/entries/DiskPaxos.html
	@@ -1,266 +1,271 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Proving the Correctness of Disk Paxos - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>roving

	the

	<font class="first">C</font>orrectness

	of

	<font class="first">D</font>isk

	<font class="first">P</font>axos

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Proving the Correctness of Disk Paxos</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.fceia.unr.edu.ar/~mauro/">Mauro Jaskelioff</a> and
	<a href="http://www.loria.fr/~merz">Stephan Merz</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2005-06-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Disk Paxos is an algorithm for building arbitrary fault-tolerant distributed systems. The specification of Disk Paxos has been proved correct informally and tested using the TLC model checker, but up to now, it has never been fully formally verified. In this work we have formally verified its correctness using the Isabelle theorem prover and the HOL logic system, showing that Isabelle is a practical tool for verifying properties of TLA+ specifications.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{DiskPaxos-AFP,
	author = {Mauro Jaskelioff and Stephan Merz},
	title = {Proving the Correctness of Disk Paxos},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2005,
	note = {\url{http://isa-afp.org/entries/DiskPaxos.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DiskPaxos/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/DiskPaxos/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DiskPaxos/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-DiskPaxos-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-DiskPaxos-2018-08-16.tar.gz">
	+ afp-DiskPaxos-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-DiskPaxos-2017-10-10.tar.gz">
	afp-DiskPaxos-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-DiskPaxos-2016-12-17.tar.gz">
	afp-DiskPaxos-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-DiskPaxos-2016-02-22.tar.gz">
	afp-DiskPaxos-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-DiskPaxos-2015-05-27.tar.gz">
	afp-DiskPaxos-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-DiskPaxos-2014-08-28.tar.gz">
	afp-DiskPaxos-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-DiskPaxos-2013-12-11.tar.gz">
	afp-DiskPaxos-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-DiskPaxos-2013-11-17.tar.gz">
	afp-DiskPaxos-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-DiskPaxos-2013-02-16.tar.gz">
	afp-DiskPaxos-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-DiskPaxos-2012-05-24.tar.gz">
	afp-DiskPaxos-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-DiskPaxos-2011-10-11.tar.gz">
	afp-DiskPaxos-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-DiskPaxos-2011-02-11.tar.gz">
	afp-DiskPaxos-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-DiskPaxos-2010-06-30.tar.gz">
	afp-DiskPaxos-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-DiskPaxos-2009-12-12.tar.gz">
	afp-DiskPaxos-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-DiskPaxos-2009-04-29.tar.gz">
	afp-DiskPaxos-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-DiskPaxos-2008-06-10.tar.gz">
	afp-DiskPaxos-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-DiskPaxos-2007-11-27.tar.gz">
	afp-DiskPaxos-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-DiskPaxos-2005-10-14.tar.gz">
	afp-DiskPaxos-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-DiskPaxos-2005-06-22.tar.gz">
	afp-DiskPaxos-2005-06-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/DynamicArchitectures.html b/web/entries/DynamicArchitectures.html
	--- a/web/entries/DynamicArchitectures.html
	+++ b/web/entries/DynamicArchitectures.html
	@@ -1,207 +1,212 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Dynamic Architectures - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>ynamic

	<font class="first">A</font>rchitectures

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Dynamic Architectures</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://marmsoler.com">Diego Marmsoler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-07-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The architecture of a system describes the system's overall
	organization into components and connections between those components.
	With the emergence of mobile computing, dynamic architectures have
	become increasingly important. In such architectures, components may
	appear or disappear, and connections may change over time. In the
	following we mechanize a theory of dynamic architectures and verify
	the soundness of a corresponding calculus. Therefore, we first
	formalize the notion of configuration traces as a model for dynamic
	architectures. Then, the behavior of single components is formalized
	in terms of behavior traces and an operator is introduced and studied
	to extract the behavior of a single component out of a given
	configuration trace. Then, behavior trace assertions are introduced as
	a temporal specification technique to specify behavior of components.
	Reasoning about component behavior in a dynamic context is formalized
	in terms of a calculus for dynamic architectures. Finally, the
	soundness of the calculus is verified by introducing an alternative
	interpretation for behavior trace assertions over configuration traces
	and proving the rules of the calculus. Since projection may lead to
	finite as well as infinite behavior traces, they are formalized in
	terms of coinductive lists. Thus, our theory is based on
	Lochbihler's formalization of coinductive lists. The theory may
	be applied to verify properties for dynamic architectures.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-06-07]: adding logical operators to specify configuration traces (revision 09178f08f050)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{DynamicArchitectures-AFP,
	author = {Diego Marmsoler},
	title = {Dynamic Architectures},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/DynamicArchitectures.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Architectural_Design_Patterns.html">Architectural_Design_Patterns</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DynamicArchitectures/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/DynamicArchitectures/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/DynamicArchitectures/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-DynamicArchitectures-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-DynamicArchitectures-2018-08-16.tar.gz">
	+ afp-DynamicArchitectures-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-DynamicArchitectures-2017-10-10.tar.gz">
	afp-DynamicArchitectures-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-DynamicArchitectures-2017-07-31.tar.gz">
	afp-DynamicArchitectures-2017-07-31.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Dynamic_Tables.html b/web/entries/Dynamic_Tables.html
	--- a/web/entries/Dynamic_Tables.html
	+++ b/web/entries/Dynamic_Tables.html
	@@ -1,202 +1,207 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Parameterized Dynamic Tables - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>arameterized

	<font class="first">D</font>ynamic

	<font class="first">T</font>ables

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Parameterized Dynamic Tables</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-06-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This article formalizes the amortized analysis of dynamic tables
	parameterized with their minimal and maximal load factors and the
	expansion and contraction factors.
	<P>
	A full description is found in a
	<a href="http://www21.in.tum.de/~nipkow/pubs">companion paper</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Dynamic_Tables-AFP,
	author = {Tobias Nipkow},
	title = {Parameterized Dynamic Tables},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Dynamic_Tables.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Amortized_Complexity.html">Amortized_Complexity</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dynamic_Tables/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Dynamic_Tables/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Dynamic_Tables/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Dynamic_Tables-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Dynamic_Tables-2018-08-16.tar.gz">
	+ afp-Dynamic_Tables-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Dynamic_Tables-2017-10-10.tar.gz">
	afp-Dynamic_Tables-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Dynamic_Tables-2016-12-17.tar.gz">
	afp-Dynamic_Tables-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Dynamic_Tables-2016-02-22.tar.gz">
	afp-Dynamic_Tables-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Dynamic_Tables-2015-06-08.tar.gz">
	afp-Dynamic_Tables-2015-06-08.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Dynamic_Tables-2015-06-07.tar.gz">
	afp-Dynamic_Tables-2015-06-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/E_Transcendental.html b/web/entries/E_Transcendental.html
	--- a/web/entries/E_Transcendental.html
	+++ b/web/entries/E_Transcendental.html
	@@ -1,188 +1,193 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Transcendence of e - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">T</font>ranscendence

	of

	e

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Transcendence of e</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-01-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This work contains a proof that Euler's number e is transcendental. The
	proof follows the standard approach of assuming that e is algebraic and
	then using a specific integer polynomial to derive two inconsistent bounds,
	leading to a contradiction.</p> <p>This kind of approach can be found in
	many different sources; this formalisation mostly follows a <a href="http://planetmath.org/proofoflindemannweierstrasstheoremandthateandpiaretranscendental">PlanetMath article</a> by Roger Lipsett.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{E_Transcendental-AFP,
	author = {Manuel Eberl},
	title = {The Transcendence of e},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/E_Transcendental.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Pi_Transcendental.html">Pi_Transcendental</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/E_Transcendental/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/E_Transcendental/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/E_Transcendental/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-E_Transcendental-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-E_Transcendental-2018-08-16.tar.gz">
	+ afp-E_Transcendental-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-E_Transcendental-2017-10-10.tar.gz">
	afp-E_Transcendental-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-E_Transcendental-2017-01-13.tar.gz">
	afp-E_Transcendental-2017-01-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Echelon_Form.html b/web/entries/Echelon_Form.html
	--- a/web/entries/Echelon_Form.html
	+++ b/web/entries/Echelon_Form.html
	@@ -1,197 +1,202 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Echelon Form - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>chelon

	<font class="first">F</font>orm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Echelon Form</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a> and
	<a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-02-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Echelon_Form.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Cayley_Hamilton.html">Cayley_Hamilton</a>, <a href="Gauss_Jordan.html">Gauss_Jordan</a>, <a href="Rank_Nullity_Theorem.html">Rank_Nullity_Theorem</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Hermite.html">Hermite</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Echelon_Form/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Echelon_Form/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Echelon_Form/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Echelon_Form-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Echelon_Form-2018-08-16.tar.gz">
	+ afp-Echelon_Form-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Echelon_Form-2017-10-10.tar.gz">
	afp-Echelon_Form-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Echelon_Form-2016-12-17.tar.gz">
	afp-Echelon_Form-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Echelon_Form-2016-02-22.tar.gz">
	afp-Echelon_Form-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Echelon_Form-2015-05-27.tar.gz">
	afp-Echelon_Form-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Echelon_Form-2015-02-12.tar.gz">
	afp-Echelon_Form-2015-02-12.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/EdmondsKarp_Maxflow.html b/web/entries/EdmondsKarp_Maxflow.html
	--- a/web/entries/EdmondsKarp_Maxflow.html
	+++ b/web/entries/EdmondsKarp_Maxflow.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalizing the Edmonds-Karp Algorithm - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalizing

	the

	<font class="first">E</font>dmonds-Karp

	<font class="first">A</font>lgorithm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalizing the Edmonds-Karp Algorithm</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	S. Reza Sefidgar
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-08-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formalization of the Ford-Fulkerson method for computing
	the maximum flow in a network. Our formal proof closely follows a
	standard textbook proof, and is accessible even without being an
	expert in Isabelle/HOL--- the interactive theorem prover used for the
	formalization. We then use stepwise refinement to obtain the
	Edmonds-Karp algorithm, and formally prove a bound on its complexity.
	Further refinement yields a verified implementation, whose execution
	time compares well to an unverified reference implementation in Java.
	This entry is based on our ITP-2016 paper with the same title.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{EdmondsKarp_Maxflow-AFP,
	author = {Peter Lammich and S. Reza Sefidgar},
	title = {Formalizing the Edmonds-Karp Algorithm},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/EdmondsKarp_Maxflow.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Flow_Networks.html">Flow_Networks</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="MFMC_Countable.html">MFMC_Countable</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/EdmondsKarp_Maxflow/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/EdmondsKarp_Maxflow/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/EdmondsKarp_Maxflow/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-EdmondsKarp_Maxflow-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-EdmondsKarp_Maxflow-2018-08-16.tar.gz">
	+ afp-EdmondsKarp_Maxflow-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-EdmondsKarp_Maxflow-2017-10-10.tar.gz">
	afp-EdmondsKarp_Maxflow-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-EdmondsKarp_Maxflow-2016-12-17.tar.gz">
	afp-EdmondsKarp_Maxflow-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-EdmondsKarp_Maxflow-2016-08-12.tar.gz">
	afp-EdmondsKarp_Maxflow-2016-08-12.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Efficient-Mergesort.html b/web/entries/Efficient-Mergesort.html
	--- a/web/entries/Efficient-Mergesort.html
	+++ b/web/entries/Efficient-Mergesort.html
	@@ -1,238 +1,243 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Efficient Mergesort - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>fficient

	<font class="first">M</font>ergesort

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Efficient Mergesort</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-11-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We provide a formalization of the mergesort algorithm as used in GHC's Data.List module, proving correctness and stability. Furthermore, experimental data suggests that generated (Haskell-)code for this algorithm is much faster than for previous algorithms available in the Isabelle distribution.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2012-10-24]:
	Added reference to journal article.<br>
	[2018-09-17]:
	Added theory Efficient_Mergesort that works exclusively with the mutual
	induction schemas generated by the function package.<br>
	[2018-09-19]:
	Added theory Mergesort_Complexity that proves an upper bound on the number of
	comparisons that are required by mergesort.<br>
	[2018-09-19]:
	Theory Efficient_Mergesort replaces theory Efficient_Sort but keeping the old
	name Efficient_Sort.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Efficient-Mergesort-AFP,
	author = {Christian Sternagel},
	title = {Efficient Mergesort},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/Efficient-Mergesort.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a>, <a href="Regex_Equivalence.html">Regex_Equivalence</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Efficient-Mergesort/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Efficient-Mergesort/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Efficient-Mergesort/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Efficient-Mergesort-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Efficient-Mergesort-2018-08-16.tar.gz">
	+ afp-Efficient-Mergesort-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Efficient-Mergesort-2017-10-10.tar.gz">
	afp-Efficient-Mergesort-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Efficient-Mergesort-2016-12-17.tar.gz">
	afp-Efficient-Mergesort-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Efficient-Mergesort-2016-02-22.tar.gz">
	afp-Efficient-Mergesort-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Efficient-Mergesort-2015-05-27.tar.gz">
	afp-Efficient-Mergesort-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Efficient-Mergesort-2014-08-28.tar.gz">
	afp-Efficient-Mergesort-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Efficient-Mergesort-2013-12-11.tar.gz">
	afp-Efficient-Mergesort-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Efficient-Mergesort-2013-11-17.tar.gz">
	afp-Efficient-Mergesort-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Efficient-Mergesort-2013-03-02.tar.gz">
	afp-Efficient-Mergesort-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Efficient-Mergesort-2013-02-16.tar.gz">
	afp-Efficient-Mergesort-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Efficient-Mergesort-2012-05-24.tar.gz">
	afp-Efficient-Mergesort-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Efficient-Mergesort-2011-11-10.tar.gz">
	afp-Efficient-Mergesort-2011-11-10.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Elliptic_Curves_Group_Law.html b/web/entries/Elliptic_Curves_Group_Law.html
	--- a/web/entries/Elliptic_Curves_Group_Law.html
	+++ b/web/entries/Elliptic_Curves_Group_Law.html
	@@ -1,191 +1,196 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Group Law for Elliptic Curves - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">G</font>roup

	<font class="first">L</font>aw

	for

	<font class="first">E</font>lliptic

	<font class="first">C</font>urves

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Group Law for Elliptic Curves</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-02-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We prove the group law for elliptic curves in Weierstrass form over
	fields of characteristic greater than 2. In addition to affine
	coordinates, we also formalize projective coordinates, which allow for
	more efficient computations. By specializing the abstract
	formalization to prime fields, we can apply the curve operations to
	parameters used in standard security protocols.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Elliptic_Curves_Group_Law-AFP,
	author = {Stefan Berghofer},
	title = {The Group Law for Elliptic Curves},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Elliptic_Curves_Group_Law.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Elliptic_Curves_Group_Law/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Elliptic_Curves_Group_Law/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Elliptic_Curves_Group_Law/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Elliptic_Curves_Group_Law-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Elliptic_Curves_Group_Law-2018-08-16.tar.gz">
	+ afp-Elliptic_Curves_Group_Law-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Elliptic_Curves_Group_Law-2017-10-10.tar.gz">
	afp-Elliptic_Curves_Group_Law-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Elliptic_Curves_Group_Law-2017-03-01.tar.gz">
	afp-Elliptic_Curves_Group_Law-2017-03-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Encodability_Process_Calculi.html b/web/entries/Encodability_Process_Calculi.html
	--- a/web/entries/Encodability_Process_Calculi.html
	+++ b/web/entries/Encodability_Process_Calculi.html
	@@ -1,216 +1,221 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Analysing and Comparing Encodability Criteria for Process Calculi - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>nalysing

	and

	<font class="first">C</font>omparing

	<font class="first">E</font>ncodability

	<font class="first">C</font>riteria

	for

	<font class="first">P</font>rocess

	<font class="first">C</font>alculi

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Analysing and Comparing Encodability Criteria for Process Calculi</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Kirstin Peters (kirstin /dot/ peters /at/ tu-berlin /dot/ de) and
	<a href="http://theory.stanford.edu/~rvg/">Rob van Glabbeek</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-08-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Encodings or the proof of their absence are the main way to
	compare process calculi. To analyse the quality of encodings and to rule out
	trivial or meaningless encodings, they are augmented with quality
	criteria. There exists a bunch of different criteria and different variants
	of criteria in order to reason in different settings. This leads to
	incomparable results. Moreover it is not always clear whether the criteria
	used to obtain a result in a particular setting do indeed fit to this
	setting. We show how to formally reason about and compare encodability
	criteria by mapping them on requirements on a relation between source and
	target terms that is induced by the encoding function. In particular we
	analyse the common criteria full abstraction, operational correspondence,
	divergence reflection, success sensitiveness, and respect of barbs; e.g. we
	analyse the exact nature of the simulation relation (coupled simulation
	versus bisimulation) that is induced by different variants of operational
	correspondence. This way we reduce the problem of analysing or comparing
	encodability criteria to the better understood problem of comparing
	relations on processes.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Encodability_Process_Calculi-AFP,
	author = {Kirstin Peters and Rob van Glabbeek},
	title = {Analysing and Comparing Encodability Criteria for Process Calculi},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Encodability_Process_Calculi.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Encodability_Process_Calculi/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Encodability_Process_Calculi/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Encodability_Process_Calculi/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Encodability_Process_Calculi-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Encodability_Process_Calculi-2018-08-16.tar.gz">
	+ afp-Encodability_Process_Calculi-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Encodability_Process_Calculi-2017-10-10.tar.gz">
	afp-Encodability_Process_Calculi-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Encodability_Process_Calculi-2016-12-17.tar.gz">
	afp-Encodability_Process_Calculi-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Encodability_Process_Calculi-2016-02-22.tar.gz">
	afp-Encodability_Process_Calculi-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Encodability_Process_Calculi-2015-08-11.tar.gz">
	afp-Encodability_Process_Calculi-2015-08-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Epistemic_Logic.html b/web/entries/Epistemic_Logic.html
	--- a/web/entries/Epistemic_Logic.html
	+++ b/web/entries/Epistemic_Logic.html
	@@ -1,171 +1,177 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Epistemic Logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>pistemic

	<font class="first">L</font>ogic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Epistemic Logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.student.dtu.dk/~s144442/">Andreas Halkjær From</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-10-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This work is a formalization of epistemic logic with countably many
	agents. It includes proofs of soundness and completeness for the axiom
	system K. The completeness proof is based on the textbook
	"Reasoning About Knowledge" by Fagin, Halpern, Moses and
	Vardi (MIT Press 1995).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Epistemic_Logic-AFP,
	author = {Andreas Halkjær From},
	title = {Epistemic Logic},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Epistemic_Logic.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Epistemic_Logic/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Epistemic_Logic/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Epistemic_Logic/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Epistemic_Logic-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Epistemic_Logic-2018-10-29.tar.gz">
	+ afp-Epistemic_Logic-2018-10-29.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Ergodic_Theory.html b/web/entries/Ergodic_Theory.html
	--- a/web/entries/Ergodic_Theory.html
	+++ b/web/entries/Ergodic_Theory.html
	@@ -1,184 +1,189 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Ergodic Theory - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>rgodic

	<font class="first">T</font>heory

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Ergodic Theory</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Sebastien Gouezel
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Ergodic theory is the branch of mathematics that studies the behaviour of measure preserving transformations, in finite or infinite measure. It interacts both with probability theory (mainly through measure theory) and with geometry as a lot of interesting examples are from geometric origin. We implement the first definitions and theorems of ergodic theory, including notably Poicaré recurrence theorem for finite measure preserving systems (together with the notion of conservativity in general), induced maps, Kac's theorem, Birkhoff theorem (arguably the most important theorem in ergodic theory), and variations around it such as conservativity of the corresponding skew product, or Atkinson lemma.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Ergodic_Theory-AFP,
	author = {Sebastien Gouezel},
	title = {Ergodic Theory},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Ergodic_Theory.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Gromov_Hyperbolicity.html">Gromov_Hyperbolicity</a>, <a href="Lp.html">Lp</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ergodic_Theory/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Ergodic_Theory/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ergodic_Theory/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Ergodic_Theory-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Ergodic_Theory-2018-08-16.tar.gz">
	+ afp-Ergodic_Theory-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Ergodic_Theory-2017-10-10.tar.gz">
	afp-Ergodic_Theory-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Ergodic_Theory-2016-12-17.tar.gz">
	afp-Ergodic_Theory-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Ergodic_Theory-2016-02-22.tar.gz">
	afp-Ergodic_Theory-2016-02-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Error_Function.html b/web/entries/Error_Function.html
	--- a/web/entries/Error_Function.html
	+++ b/web/entries/Error_Function.html
	@@ -1,180 +1,185 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Error Function - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">E</font>rror

	<font class="first">F</font>unction

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Error Function</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-02-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p> This entry provides the definitions and basic properties of
	the complex and real error function erf and the complementary error
	function erfc. Additionally, it gives their full asymptotic
	expansions. </p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Error_Function-AFP,
	author = {Manuel Eberl},
	title = {The Error Function},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Error_Function.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Landau_Symbols.html">Landau_Symbols</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Error_Function/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Error_Function/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Error_Function/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Error_Function-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Error_Function-2018-08-16.tar.gz">
	+ afp-Error_Function-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Error_Function-2018-02-07.tar.gz">
	afp-Error_Function-2018-02-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Euler_MacLaurin.html b/web/entries/Euler_MacLaurin.html
	--- a/web/entries/Euler_MacLaurin.html
	+++ b/web/entries/Euler_MacLaurin.html
	@@ -1,196 +1,201 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Euler–MacLaurin Formula - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">E</font>uler–MacLaurin

	<font class="first">F</font>ormula

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Euler–MacLaurin Formula</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-03-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>The Euler-MacLaurin formula relates the value of a
	discrete sum to that of the corresponding integral in terms of the
	derivatives at the borders of the summation and a remainder term.
	Since the remainder term is often very small as the summation bounds
	grow, this can be used to compute asymptotic expansions for
	sums.</p> <p>This entry contains a proof of this formula
	for functions from the reals to an arbitrary Banach space. Two
	variants of the formula are given: the standard textbook version and a
	variant outlined in <em>Concrete Mathematics</em> that is
	more useful for deriving asymptotic estimates.</p> <p>As
	example applications, we use that formula to derive the full
	asymptotic expansion of the harmonic numbers and the sum of inverse
	squares.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Euler_MacLaurin-AFP,
	author = {Manuel Eberl},
	title = {The Euler–MacLaurin Formula},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Euler_MacLaurin.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Bernoulli.html">Bernoulli</a>, <a href="Landau_Symbols.html">Landau_Symbols</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Dirichlet_Series.html">Dirichlet_Series</a>, <a href="Zeta_Function.html">Zeta_Function</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Euler_MacLaurin/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Euler_MacLaurin/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Euler_MacLaurin/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Euler_MacLaurin-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Euler_MacLaurin-2018-08-16.tar.gz">
	+ afp-Euler_MacLaurin-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Euler_MacLaurin-2017-10-10.tar.gz">
	afp-Euler_MacLaurin-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Euler_MacLaurin-2017-03-14.tar.gz">
	afp-Euler_MacLaurin-2017-03-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Euler_Partition.html b/web/entries/Euler_Partition.html
	--- a/web/entries/Euler_Partition.html
	+++ b/web/entries/Euler_Partition.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Euler's Partition Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>uler's

	<font class="first">P</font>artition

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Euler's Partition Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-11-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Euler's Partition Theorem states that the number of partitions with only
	distinct parts is equal to the number of partitions with only odd parts.
	The combinatorial proof follows John Harrison's HOL Light formalization.
	This theorem is the 45th theorem of the Top 100 Theorems list.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Euler_Partition-AFP,
	author = {Lukas Bulwahn},
	title = {Euler's Partition Theorem},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Euler_Partition.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Card_Number_Partitions.html">Card_Number_Partitions</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Euler_Partition/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Euler_Partition/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Euler_Partition/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Euler_Partition-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Euler_Partition-2018-08-16.tar.gz">
	+ afp-Euler_Partition-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Euler_Partition-2017-10-10.tar.gz">
	afp-Euler_Partition-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Euler_Partition-2016-12-17.tar.gz">
	afp-Euler_Partition-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Euler_Partition-2016-02-22.tar.gz">
	afp-Euler_Partition-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Euler_Partition-2015-11-20.tar.gz">
	afp-Euler_Partition-2015-11-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FFT.html b/web/entries/FFT.html
	--- a/web/entries/FFT.html
	+++ b/web/entries/FFT.html
	@@ -1,254 +1,259 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Fast Fourier Transform - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ast

	<font class="first">F</font>ourier

	<font class="first">T</font>ransform

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Fast Fourier Transform</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~ballarin/">Clemens Ballarin</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2005-10-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalise a functional implementation of the FFT algorithm over the complex numbers, and its inverse. Both are shown equivalent to the usual definitions of these operations through Vandermonde matrices. They are also shown to be inverse to each other, more precisely, that composition of the inverse and the transformation yield the identity up to a scalar.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FFT-AFP,
	author = {Clemens Ballarin},
	title = {Fast Fourier Transform},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2005,
	note = {\url{http://isa-afp.org/entries/FFT.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FFT/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FFT/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FFT/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FFT-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FFT-2018-08-16.tar.gz">
	+ afp-FFT-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FFT-2017-10-10.tar.gz">
	afp-FFT-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FFT-2016-12-17.tar.gz">
	afp-FFT-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-FFT-2016-02-22.tar.gz">
	afp-FFT-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-FFT-2015-05-27.tar.gz">
	afp-FFT-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-FFT-2014-08-28.tar.gz">
	afp-FFT-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-FFT-2013-12-11.tar.gz">
	afp-FFT-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-FFT-2013-11-17.tar.gz">
	afp-FFT-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-FFT-2013-02-16.tar.gz">
	afp-FFT-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-FFT-2012-05-24.tar.gz">
	afp-FFT-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-FFT-2011-10-11.tar.gz">
	afp-FFT-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-FFT-2011-02-11.tar.gz">
	afp-FFT-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-FFT-2010-06-30.tar.gz">
	afp-FFT-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-FFT-2009-12-12.tar.gz">
	afp-FFT-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-FFT-2009-04-29.tar.gz">
	afp-FFT-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-FFT-2008-06-10.tar.gz">
	afp-FFT-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-FFT-2007-11-27.tar.gz">
	afp-FFT-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-FFT-2005-10-14.tar.gz">
	afp-FFT-2005-10-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FLP.html b/web/entries/FLP.html
	--- a/web/entries/FLP.html
	+++ b/web/entries/FLP.html
	@@ -1,210 +1,215 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Constructive Proof for FLP - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">C</font>onstructive

	<font class="first">P</font>roof

	for

	<font class="first">F</font>LP

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Constructive Proof for FLP</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Benjamin Bisping (benjamin /dot/ bisping /at/ campus /dot/ tu-berlin /dot/ de),
	Paul-David Brodmann (p /dot/ brodmann /at/ tu-berlin /dot/ de),
	Tim Jungnickel (tim /dot/ jungnickel /at/ tu-berlin /dot/ de),
	Christina Rickmann (c /dot/ rickmann /at/ tu-berlin /dot/ de),
	Henning Seidler (henning /dot/ seidler /at/ mailbox /dot/ tu-berlin /dot/ de),
	Anke Stüber (anke /dot/ stueber /at/ campus /dot/ tu-berlin /dot/ de),
	Arno Wilhelm-Weidner (arno /dot/ wilhelm-weidner /at/ tu-berlin /dot/ de),
	Kirstin Peters (kirstin /dot/ peters /at/ tu-berlin /dot/ de) and
	<a href="https://www.mtv.tu-berlin.de/nestmann/">Uwe Nestmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The impossibility of distributed consensus with one faulty process is
	a result with important consequences for real world distributed
	systems e.g., commits in replicated databases. Since proofs are not
	immune to faults and even plausible proofs with a profound formalism
	can conclude wrong results, we validate the fundamental result named
	FLP after Fischer, Lynch and Paterson.
	We present a formalization of distributed systems
	and the aforementioned consensus problem. Our proof is based on Hagen
	Völzer's paper "A constructive proof for FLP". In addition to the
	enhanced confidence in the validity of Völzer's proof, we contribute
	the missing gaps to show the correctness in Isabelle/HOL. We clarify
	the proof details and even prove fairness of the infinite execution
	that contradicts consensus. Our Isabelle formalization can also be
	reused for further proofs of properties of distributed systems.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FLP-AFP,
	author = {Benjamin Bisping and Paul-David Brodmann and Tim Jungnickel and Christina Rickmann and Henning Seidler and Anke Stüber and Arno Wilhelm-Weidner and Kirstin Peters and Uwe Nestmann},
	title = {A Constructive Proof for FLP},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/FLP.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FLP/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FLP/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FLP/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FLP-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FLP-2018-08-16.tar.gz">
	+ afp-FLP-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FLP-2017-10-10.tar.gz">
	afp-FLP-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FLP-2016-12-17.tar.gz">
	afp-FLP-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-FLP-2016-05-18.tar.gz">
	afp-FLP-2016-05-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FOL-Fitting.html b/web/entries/FOL-Fitting.html
	--- a/web/entries/FOL-Fitting.html
	+++ b/web/entries/FOL-Fitting.html
	@@ -1,270 +1,275 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>First-Order Logic According to Fitting - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>irst-Order

	<font class="first">L</font>ogic

	<font class="first">A</font>ccording

	to

	<font class="first">F</font>itting

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">First-Order Logic According to Fitting</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	<a href="http://www.student.dtu.dk/~s144442/">Andreas Halkjær From</a>
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2007-08-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We present a formalization of parts of Melvin Fitting's book "First-Order Logic and Automated Theorem Proving". The formalization covers the syntax of first-order logic, its semantics, the model existence theorem, a natural deduction proof calculus together with a proof of correctness and completeness, as well as the Löwenheim-Skolem theorem.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-07-21]: Proved completeness theorem for open formulas. Proofs are now written in the declarative style. Enumeration of pairs and datatypes is automated using the Countable theory.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FOL-Fitting-AFP,
	author = {Stefan Berghofer},
	title = {First-Order Logic According to Fitting},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2007,
	note = {\url{http://isa-afp.org/entries/FOL-Fitting.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FOL-Fitting/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FOL-Fitting/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FOL-Fitting/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FOL-Fitting-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FOL-Fitting-2018-08-16.tar.gz">
	+ afp-FOL-Fitting-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FOL-Fitting-2017-10-10.tar.gz">
	afp-FOL-Fitting-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FOL-Fitting-2016-12-17.tar.gz">
	afp-FOL-Fitting-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-FOL-Fitting-2016-02-22.tar.gz">
	afp-FOL-Fitting-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-FOL-Fitting-2015-05-27.tar.gz">
	afp-FOL-Fitting-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-FOL-Fitting-2014-08-28.tar.gz">
	afp-FOL-Fitting-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-FOL-Fitting-2013-12-11.tar.gz">
	afp-FOL-Fitting-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-FOL-Fitting-2013-11-17.tar.gz">
	afp-FOL-Fitting-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-FOL-Fitting-2013-03-02.tar.gz">
	afp-FOL-Fitting-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-FOL-Fitting-2013-02-16.tar.gz">
	afp-FOL-Fitting-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-FOL-Fitting-2012-05-24.tar.gz">
	afp-FOL-Fitting-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-FOL-Fitting-2011-10-11.tar.gz">
	afp-FOL-Fitting-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-FOL-Fitting-2011-02-11.tar.gz">
	afp-FOL-Fitting-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-FOL-Fitting-2010-06-30.tar.gz">
	afp-FOL-Fitting-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-FOL-Fitting-2009-12-12.tar.gz">
	afp-FOL-Fitting-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-FOL-Fitting-2009-04-29.tar.gz">
	afp-FOL-Fitting-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-FOL-Fitting-2008-06-10.tar.gz">
	afp-FOL-Fitting-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-FOL-Fitting-2007-11-27.tar.gz">
	afp-FOL-Fitting-2007-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FOL_Harrison.html b/web/entries/FOL_Harrison.html
	--- a/web/entries/FOL_Harrison.html
	+++ b/web/entries/FOL_Harrison.html
	@@ -1,203 +1,208 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>First-Order Logic According to Harrison - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>irst-Order

	<font class="first">L</font>ogic

	<font class="first">A</font>ccording

	to

	<font class="first">H</font>arrison

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">First-Order Logic According to Harrison</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://people.compute.dtu.dk/aleje/">Alexander Birch Jensen</a>,
	Anders Schlichtkrull (andschl /at/ dtu /dot/ dk) and
	<a href="https://people.compute.dtu.dk/jovi/">Jørgen Villadsen</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-01-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>We present a certified declarative first-order prover with equality
	based on John Harrison's Handbook of Practical Logic and
	Automated Reasoning, Cambridge University Press, 2009. ML code
	reflection is used such that the entire prover can be executed within
	Isabelle as a very simple interactive proof assistant. As examples we
	consider Pelletier's problems 1-46.</p>
	<p>Reference: Programming and Verifying a Declarative First-Order
	Prover in Isabelle/HOL. Alexander Birch Jensen, John Bruntse Larsen,
	Anders Schlichtkrull & Jørgen Villadsen. AI Communications 31:281-299
	2018. <a href="https://content.iospress.com/articles/ai-communications/aic764">
	https://content.iospress.com/articles/ai-communications/aic764</a></p>
	<p>See also: Students' Proof Assistant (SPA).
	<a href=https://github.com/logic-tools/spa>
	https://github.com/logic-tools/spa</a></p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-07-21]: Proof of Pelletier's problem 34 (Andrews's Challenge) thanks to Andreas Halkjær From.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FOL_Harrison-AFP,
	author = {Alexander Birch Jensen and Anders Schlichtkrull and Jørgen Villadsen},
	title = {First-Order Logic According to Harrison},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/FOL_Harrison.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FOL_Harrison/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FOL_Harrison/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FOL_Harrison/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FOL_Harrison-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FOL_Harrison-2018-08-16.tar.gz">
	+ afp-FOL_Harrison-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FOL_Harrison-2017-10-10.tar.gz">
	afp-FOL_Harrison-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FOL_Harrison-2017-01-04.tar.gz">
	afp-FOL_Harrison-2017-01-04.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Factored_Transition_System_Bounding.html b/web/entries/Factored_Transition_System_Bounding.html
	--- a/web/entries/Factored_Transition_System_Bounding.html
	+++ b/web/entries/Factored_Transition_System_Bounding.html
	@@ -1,200 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Upper Bounding Diameters of State Spaces of Factored Transition Systems - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">U</font>pper

	<font class="first">B</font>ounding

	<font class="first">D</font>iameters

	of

	<font class="first">S</font>tate

	<font class="first">S</font>paces

	of

	<font class="first">F</font>actored

	<font class="first">T</font>ransition

	<font class="first">S</font>ystems

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Upper Bounding Diameters of State Spaces of Factored Transition Systems</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Friedrich Kurz and
	<a href="http://home.in.tum.de/~mansour/">Mohammad Abdulaziz</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-10-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	A completeness threshold is required to guarantee the completeness of
	planning as satisfiability, and bounded model checking of safety
	properties. One valid completeness threshold is the diameter of the
	underlying transition system. The diameter is the maximum element in
	the set of lengths of all shortest paths between pairs of states. The
	diameter is not calculated exactly in our setting, where the
	transition system is succinctly described using a (propositionally)
	factored representation. Rather, an upper bound on the diameter is
	calculated compositionally, by bounding the diameters of small
	abstract subsystems, and then composing those. We port a HOL4
	formalisation of a compositional algorithm for computing a relatively
	tight upper bound on the system diameter. This compositional algorithm
	exploits acyclicity in the state space to achieve compositionality,
	and it was introduced by Abdulaziz et. al. The formalisation that we
	port is described as a part of another paper by Abdulaziz et. al. As a
	part of this porting we developed a libray about transition systems,
	which shall be of use in future related mechanisation efforts.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Factored_Transition_System_Bounding-AFP,
	author = {Friedrich Kurz and Mohammad Abdulaziz},
	title = {Upper Bounding Diameters of State Spaces of Factored Transition Systems},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Factored_Transition_System_Bounding.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Factored_Transition_System_Bounding/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Factored_Transition_System_Bounding/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Factored_Transition_System_Bounding/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Factored_Transition_System_Bounding-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Factored_Transition_System_Bounding-2018-10-16.tar.gz">
	+ afp-Factored_Transition_System_Bounding-2018-10-16.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Falling_Factorial_Sum.html b/web/entries/Falling_Factorial_Sum.html
	--- a/web/entries/Falling_Factorial_Sum.html
	+++ b/web/entries/Falling_Factorial_Sum.html
	@@ -1,193 +1,198 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Falling Factorial of a Sum - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">F</font>alling

	<font class="first">F</font>actorial

	of

	a

	<font class="first">S</font>um

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Falling Factorial of a Sum</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-12-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry shows that the falling factorial of a sum can be computed
	with an expression using binomial coefficients and the falling
	factorial of its summands. The entry provides three different proofs:
	a combinatorial proof, an induction proof and an algebraic proof using
	the Vandermonde identity. The three formalizations try to follow
	their informal presentations from a Mathematics Stack Exchange page as
	close as possible. The induction and algebraic formalization end up to
	be very close to their informal presentation, whereas the
	combinatorial proof first requires the introduction of list
	interleavings, and significant more detail than its informal
	presentation.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Falling_Factorial_Sum-AFP,
	author = {Lukas Bulwahn},
	title = {The Falling Factorial of a Sum},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Falling_Factorial_Sum.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Card_Partitions.html">Card_Partitions</a>, <a href="Discrete_Summation.html">Discrete_Summation</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Falling_Factorial_Sum/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Falling_Factorial_Sum/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Falling_Factorial_Sum/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Falling_Factorial_Sum-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Falling_Factorial_Sum-2018-08-16.tar.gz">
	+ afp-Falling_Factorial_Sum-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Falling_Factorial_Sum-2017-12-30.tar.gz">
	afp-Falling_Factorial_Sum-2017-12-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Farkas.html b/web/entries/Farkas.html
	--- a/web/entries/Farkas.html
	+++ b/web/entries/Farkas.html
	@@ -1,186 +1,192 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Farkas' Lemma and Motzkin's Transposition Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>arkas'

	<font class="first">L</font>emma

	and

	<font class="first">M</font>otzkin's

	<font class="first">T</font>ransposition

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Farkas' Lemma and Motzkin's Transposition Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/users/bottesch/">Ralph Bottesch</a>,
	<a href="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Max W. Haslbeck</a> and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-01-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize a proof of Motzkin's transposition theorem and
	Farkas' lemma in Isabelle/HOL. Our proof is based on the
	formalization of the simplex algorithm which, given a set of linear
	constraints, either returns a satisfying assignment to the problem or
	detects unsatisfiability. By reusing facts about the simplex algorithm
	we show that a set of linear constraints is unsatisfiable if and only
	if there is a linear combination of the constraints which evaluates to
	a trivially unsatisfiable inequality.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Farkas-AFP,
	author = {Ralph Bottesch and Max W. Haslbeck and René Thiemann},
	title = {Farkas' Lemma and Motzkin's Transposition Theorem},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Farkas.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a>, <a href="Simplex.html">Simplex</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Farkas/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Farkas/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Farkas/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Farkas-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Farkas-2019-01-21.tar.gz">
	+ afp-Farkas-2019-01-21.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FeatherweightJava.html b/web/entries/FeatherweightJava.html
	--- a/web/entries/FeatherweightJava.html
	+++ b/web/entries/FeatherweightJava.html
	@@ -1,268 +1,273 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Theory of Featherweight Java in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">T</font>heory

	of

	<font class="first">F</font>eatherweight

	<font class="first">J</font>ava

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Theory of Featherweight Java in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.cs.cornell.edu/~jnfoster/">J. Nathan Foster</a> and
	<a href="http://research.microsoft.com/en-us/people/dimitris/">Dimitrios Vytiniotis</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2006-03-31</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalize the type system, small-step operational semantics, and type soundness proof for Featherweight Java, a simple object calculus, in Isabelle/HOL.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FeatherweightJava-AFP,
	author = {J. Nathan Foster and Dimitrios Vytiniotis},
	title = {A Theory of Featherweight Java in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2006,
	note = {\url{http://isa-afp.org/entries/FeatherweightJava.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FeatherweightJava/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FeatherweightJava/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FeatherweightJava/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FeatherweightJava-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FeatherweightJava-2018-08-16.tar.gz">
	+ afp-FeatherweightJava-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FeatherweightJava-2017-10-10.tar.gz">
	afp-FeatherweightJava-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FeatherweightJava-2016-12-17.tar.gz">
	afp-FeatherweightJava-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-FeatherweightJava-2016-02-22.tar.gz">
	afp-FeatherweightJava-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-FeatherweightJava-2015-05-27.tar.gz">
	afp-FeatherweightJava-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-FeatherweightJava-2014-08-28.tar.gz">
	afp-FeatherweightJava-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-FeatherweightJava-2013-12-11.tar.gz">
	afp-FeatherweightJava-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-FeatherweightJava-2013-11-17.tar.gz">
	afp-FeatherweightJava-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-FeatherweightJava-2013-02-16.tar.gz">
	afp-FeatherweightJava-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-FeatherweightJava-2012-05-24.tar.gz">
	afp-FeatherweightJava-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-FeatherweightJava-2011-10-11.tar.gz">
	afp-FeatherweightJava-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-FeatherweightJava-2011-02-11.tar.gz">
	afp-FeatherweightJava-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-FeatherweightJava-2010-06-30.tar.gz">
	afp-FeatherweightJava-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-FeatherweightJava-2009-12-12.tar.gz">
	afp-FeatherweightJava-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-FeatherweightJava-2009-04-29.tar.gz">
	afp-FeatherweightJava-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-FeatherweightJava-2008-06-10.tar.gz">
	afp-FeatherweightJava-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-FeatherweightJava-2007-11-27.tar.gz">
	afp-FeatherweightJava-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-FeatherweightJava-2006-04-06.tar.gz">
	afp-FeatherweightJava-2006-04-06.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-FeatherweightJava-2006-04-05.tar.gz">
	afp-FeatherweightJava-2006-04-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Featherweight_OCL.html b/web/entries/Featherweight_OCL.html
	--- a/web/entries/Featherweight_OCL.html
	+++ b/web/entries/Featherweight_OCL.html
	@@ -1,250 +1,255 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Featherweight OCL: A Proposal for a Machine-Checked Formal Semantics for OCL 2.5 - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>eatherweight

	<font class="first">O</font>CL:

	<font class="first">A</font>

	<font class="first">P</font>roposal

	for

	a

	<font class="first">M</font>achine-Checked

	<font class="first">F</font>ormal

	<font class="first">S</font>emantics

	for

	<font class="first">O</font>CL

	<font class="first">2</font>.5

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Featherweight OCL: A Proposal for a Machine-Checked Formal Semantics for OCL 2.5</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.brucker.ch/">Achim D. Brucker</a>,
	Frédéric Tuong (tuong /at/ users /dot/ gforge /dot/ inria /dot/ fr) and
	Burkhart Wolff (wolff /at/ lri /dot/ fr)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-01-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The Unified Modeling Language (UML) is one of the few
	modeling languages that is widely used in industry. While
	UML is mostly known as diagrammatic modeling language
	(e.g., visualizing class models), it is complemented by a
	textual language, called Object Constraint Language
	(OCL). The current version of OCL is based on a four-valued
	logic that turns UML into a formal language. Any type
	comprises the elements "invalid" and "null" which are
	propagated as strict and non-strict, respectively.
	Unfortunately, the former semi-formal semantics of this
	specification language, captured in the "Annex A" of the
	OCL standard, leads to different interpretations of corner
	cases. We formalize the core of OCL: denotational
	definitions, a logical calculus and operational rules that
	allow for the execution of OCL expressions by a mixture of
	term rewriting and code compilation. Our formalization
	reveals several inconsistencies and contradictions in the
	current version of the OCL standard. Overall, this document
	is intended to provide the basis for a machine-checked text
	"Annex A" of the OCL standard targeting at tool
	implementors.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-10-13]:
	<a href="https://bitbucket.org/isa-afp/afp-devel/commits/ea3b38fc54d68535bcfafd40357b6ff8f1092057">afp-devel@ea3b38fc54d6</a> and
	<a href="https://projects.brucker.ch/hol-testgen/log/trunk?rev=12148">hol-testgen@12148</a><br>
	Update of Featherweight OCL including a change in the abstract.<br>
	[2014-01-16]:
	<a href="https://bitbucket.org/isa-afp/afp-devel/commits/9091ce05cb20d4ad3dc1961c18f1846d85e87f8e">afp-devel@9091ce05cb20</a> and
	<a href="https://projects.brucker.ch/hol-testgen/log/trunk?rev=10241">hol-testgen@10241</a><br>
	New Entry: Featherweight OCL</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Featherweight_OCL-AFP,
	author = {Achim D. Brucker and Frédéric Tuong and Burkhart Wolff},
	title = {Featherweight OCL: A Proposal for a Machine-Checked Formal Semantics for OCL 2.5},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Featherweight_OCL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Featherweight_OCL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Featherweight_OCL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Featherweight_OCL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Featherweight_OCL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Featherweight_OCL-2018-08-16.tar.gz">
	+ afp-Featherweight_OCL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Featherweight_OCL-2017-10-10.tar.gz">
	afp-Featherweight_OCL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Featherweight_OCL-2016-12-17.tar.gz">
	afp-Featherweight_OCL-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Featherweight_OCL-2016-02-22.tar.gz">
	afp-Featherweight_OCL-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Featherweight_OCL-2015-05-27.tar.gz">
	afp-Featherweight_OCL-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Featherweight_OCL-2014-08-28.tar.gz">
	afp-Featherweight_OCL-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Featherweight_OCL-2014-01-16.tar.gz">
	afp-Featherweight_OCL-2014-01-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Fermat3_4.html b/web/entries/Fermat3_4.html
	--- a/web/entries/Fermat3_4.html
	+++ b/web/entries/Fermat3_4.html
	@@ -1,271 +1,276 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Fermat's Last Theorem for Exponents 3 and 4 and the Parametrisation of Pythagorean Triples - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ermat's

	<font class="first">L</font>ast

	<font class="first">T</font>heorem

	for

	<font class="first">E</font>xponents

	<font class="first">3</font>

	and

	<font class="first">4</font>

	and

	the

	<font class="first">P</font>arametrisation

	of

	<font class="first">P</font>ythagorean

	<font class="first">T</font>riples

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Fermat's Last Theorem for Exponents 3 and 4 and the Parametrisation of Pythagorean Triples</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Roelof Oosterhuis
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2007-08-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document presents the mechanised proofs of<ul><li>Fermat's Last Theorem for exponents 3 and 4 and</li><li>the parametrisation of Pythagorean Triples.</li></ul></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Fermat3_4-AFP,
	author = {Roelof Oosterhuis},
	title = {Fermat's Last Theorem for Exponents 3 and 4 and the Parametrisation of Pythagorean Triples},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2007,
	note = {\url{http://isa-afp.org/entries/Fermat3_4.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Fermat3_4/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Fermat3_4/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Fermat3_4/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Fermat3_4-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Fermat3_4-2018-08-16.tar.gz">
	+ afp-Fermat3_4-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Fermat3_4-2017-10-10.tar.gz">
	afp-Fermat3_4-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Fermat3_4-2016-12-17.tar.gz">
	afp-Fermat3_4-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Fermat3_4-2016-02-22.tar.gz">
	afp-Fermat3_4-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Fermat3_4-2015-05-27.tar.gz">
	afp-Fermat3_4-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Fermat3_4-2014-08-28.tar.gz">
	afp-Fermat3_4-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Fermat3_4-2013-12-11.tar.gz">
	afp-Fermat3_4-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Fermat3_4-2013-11-17.tar.gz">
	afp-Fermat3_4-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Fermat3_4-2013-02-16.tar.gz">
	afp-Fermat3_4-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Fermat3_4-2012-05-24.tar.gz">
	afp-Fermat3_4-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Fermat3_4-2011-10-11.tar.gz">
	afp-Fermat3_4-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Fermat3_4-2011-02-11.tar.gz">
	afp-Fermat3_4-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Fermat3_4-2010-06-30.tar.gz">
	afp-Fermat3_4-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Fermat3_4-2009-12-12.tar.gz">
	afp-Fermat3_4-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Fermat3_4-2009-04-29.tar.gz">
	afp-Fermat3_4-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Fermat3_4-2008-06-10.tar.gz">
	afp-Fermat3_4-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Fermat3_4-2007-11-27.tar.gz">
	afp-Fermat3_4-2007-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FileRefinement.html b/web/entries/FileRefinement.html
	--- a/web/entries/FileRefinement.html
	+++ b/web/entries/FileRefinement.html
	@@ -1,258 +1,263 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>File Refinement - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ile

	<font class="first">R</font>efinement

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">File Refinement</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.mit.edu/~kkz/">Karen Zee</a> and
	<a href="http://lara.epfl.ch/~kuncak/">Viktor Kuncak</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-12-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">These theories illustrates the verification of basic file operations (file creation, file read and file write) in the Isabelle theorem prover. We describe a file at two levels of abstraction: an abstract file represented as a resizable array, and a concrete file represented using data blocks.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FileRefinement-AFP,
	author = {Karen Zee and Viktor Kuncak},
	title = {File Refinement},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/FileRefinement.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FileRefinement/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FileRefinement/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FileRefinement/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FileRefinement-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FileRefinement-2018-08-16.tar.gz">
	+ afp-FileRefinement-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FileRefinement-2017-10-10.tar.gz">
	afp-FileRefinement-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FileRefinement-2016-12-17.tar.gz">
	afp-FileRefinement-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-FileRefinement-2016-02-22.tar.gz">
	afp-FileRefinement-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-FileRefinement-2015-05-27.tar.gz">
	afp-FileRefinement-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-FileRefinement-2014-08-28.tar.gz">
	afp-FileRefinement-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-FileRefinement-2013-12-11.tar.gz">
	afp-FileRefinement-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-FileRefinement-2013-11-17.tar.gz">
	afp-FileRefinement-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-FileRefinement-2013-02-16.tar.gz">
	afp-FileRefinement-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-FileRefinement-2012-05-24.tar.gz">
	afp-FileRefinement-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-FileRefinement-2011-10-11.tar.gz">
	afp-FileRefinement-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-FileRefinement-2011-02-11.tar.gz">
	afp-FileRefinement-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-FileRefinement-2010-06-30.tar.gz">
	afp-FileRefinement-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-FileRefinement-2009-12-12.tar.gz">
	afp-FileRefinement-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-FileRefinement-2009-04-29.tar.gz">
	afp-FileRefinement-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-FileRefinement-2008-06-10.tar.gz">
	afp-FileRefinement-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-FileRefinement-2007-11-27.tar.gz">
	afp-FileRefinement-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-FileRefinement-2005-10-14.tar.gz">
	afp-FileRefinement-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-FileRefinement-2004-12-15.tar.gz">
	afp-FileRefinement-2004-12-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FinFun.html b/web/entries/FinFun.html
	--- a/web/entries/FinFun.html
	+++ b/web/entries/FinFun.html
	@@ -1,264 +1,269 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Code Generation for Functions as Data - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ode

	<font class="first">G</font>eneration

	for

	<font class="first">F</font>unctions

	as

	<font class="first">D</font>ata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Code Generation for Functions as Data</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-05-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">FinFuns are total functions that are constant except for a finite set of points, i.e. a generalisation of finite maps. They are formalised as a new type in Isabelle/HOL such that the code generator can handle equality tests and quantification on FinFuns. On the code output level, FinFuns are explicitly represented by constant functions and pointwise updates, similarly to associative lists. Inside the logic, they behave like ordinary functions with extensionality. Via the update/constant pattern, a recursion combinator and an induction rule for FinFuns allow for defining and reasoning about operators on FinFun that are also executable.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2010-08-13]:
	new concept domain of a FinFun as a FinFun
	(revision 34b3517cbc09)<br>
	[2010-11-04]:
	new conversion function from FinFun to list of elements in the domain
	(revision 0c167102e6ed)<br>
	[2012-03-07]:
	replace sets as FinFuns by predicates as FinFuns because the set type constructor has been reintroduced
	(revision b7aa87989f3a)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FinFun-AFP,
	author = {Andreas Lochbihler},
	title = {Code Generation for Functions as Data},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/FinFun.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="JinjaThreads.html">JinjaThreads</a>, <a href="Launchbury.html">Launchbury</a>, <a href="Nominal2.html">Nominal2</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FinFun/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FinFun/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FinFun/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FinFun-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FinFun-2018-08-16.tar.gz">
	+ afp-FinFun-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FinFun-2017-10-10.tar.gz">
	afp-FinFun-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FinFun-2016-12-17.tar.gz">
	afp-FinFun-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-FinFun-2016-02-22.tar.gz">
	afp-FinFun-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-FinFun-2015-05-27.tar.gz">
	afp-FinFun-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-FinFun-2014-08-28.tar.gz">
	afp-FinFun-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-FinFun-2013-12-11.tar.gz">
	afp-FinFun-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-FinFun-2013-11-17.tar.gz">
	afp-FinFun-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-FinFun-2013-03-02.tar.gz">
	afp-FinFun-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-FinFun-2013-02-16.tar.gz">
	afp-FinFun-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-FinFun-2012-05-24.tar.gz">
	afp-FinFun-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-FinFun-2011-10-11.tar.gz">
	afp-FinFun-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-FinFun-2011-02-11.tar.gz">
	afp-FinFun-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-FinFun-2010-06-30.tar.gz">
	afp-FinFun-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-FinFun-2009-12-12.tar.gz">
	afp-FinFun-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-FinFun-2009-05-25.tar.gz">
	afp-FinFun-2009-05-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Finger-Trees.html b/web/entries/Finger-Trees.html
	--- a/web/entries/Finger-Trees.html
	+++ b/web/entries/Finger-Trees.html
	@@ -1,246 +1,251 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Finger Trees - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>inger

	<font class="first">T</font>rees

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Finger Trees</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Benedikt Nordhoff (b_nord01 /at/ uni-muenster /dot/ de),
	Stefan Körner (s_koer03 /at/ uni-muenster /dot/ de) and
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-10-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We implement and prove correct 2-3 finger trees.
	Finger trees are a general purpose data structure, that can be used to
	efficiently implement other data structures, such as priority queues.
	Intuitively, a finger tree is an annotated sequence, where the annotations are
	elements of a monoid. Apart from operations to access the ends of the sequence,
	the main operation is to split the sequence at the point where a
	<em>monotone predicate</em> over the sum of the left part of the sequence
	becomes true for the first time.
	The implementation follows the paper of Hinze and Paterson.
	The code generator can be used to get efficient, verified code.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Finger-Trees-AFP,
	author = {Benedikt Nordhoff and Stefan Körner and Peter Lammich},
	title = {Finger Trees},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Finger-Trees.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="Containers.html">Containers</a>, <a href="JinjaThreads.html">JinjaThreads</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Finger-Trees/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Finger-Trees/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Finger-Trees/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Finger-Trees-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Finger-Trees-2018-08-16.tar.gz">
	+ afp-Finger-Trees-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Finger-Trees-2017-10-10.tar.gz">
	afp-Finger-Trees-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Finger-Trees-2016-12-17.tar.gz">
	afp-Finger-Trees-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Finger-Trees-2016-02-22.tar.gz">
	afp-Finger-Trees-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Finger-Trees-2015-05-27.tar.gz">
	afp-Finger-Trees-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Finger-Trees-2014-08-28.tar.gz">
	afp-Finger-Trees-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Finger-Trees-2013-12-11.tar.gz">
	afp-Finger-Trees-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Finger-Trees-2013-11-17.tar.gz">
	afp-Finger-Trees-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Finger-Trees-2013-03-02.tar.gz">
	afp-Finger-Trees-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Finger-Trees-2013-02-16.tar.gz">
	afp-Finger-Trees-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Finger-Trees-2012-05-24.tar.gz">
	afp-Finger-Trees-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Finger-Trees-2011-10-11.tar.gz">
	afp-Finger-Trees-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Finger-Trees-2011-02-11.tar.gz">
	afp-Finger-Trees-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Finger-Trees-2010-10-28.tar.gz">
	afp-Finger-Trees-2010-10-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Finite_Automata_HF.html b/web/entries/Finite_Automata_HF.html
	--- a/web/entries/Finite_Automata_HF.html
	+++ b/web/entries/Finite_Automata_HF.html
	@@ -1,208 +1,213 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Finite Automata in Hereditarily Finite Set Theory - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>inite

	<font class="first">A</font>utomata

	in

	<font class="first">H</font>ereditarily

	<font class="first">F</font>inite

	<font class="first">S</font>et

	<font class="first">T</font>heory

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Finite Automata in Hereditarily Finite Set Theory</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-02-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Finite_Automata_HF.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="HereditarilyFinite.html">HereditarilyFinite</a>, <a href="Regular-Sets.html">Regular-Sets</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Finite_Automata_HF/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Finite_Automata_HF/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Finite_Automata_HF/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Finite_Automata_HF-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Finite_Automata_HF-2018-08-16.tar.gz">
	+ afp-Finite_Automata_HF-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Finite_Automata_HF-2017-10-10.tar.gz">
	afp-Finite_Automata_HF-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Finite_Automata_HF-2016-12-17.tar.gz">
	afp-Finite_Automata_HF-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Finite_Automata_HF-2016-02-22.tar.gz">
	afp-Finite_Automata_HF-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Finite_Automata_HF-2015-05-27.tar.gz">
	afp-Finite_Automata_HF-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Finite_Automata_HF-2015-02-05.tar.gz">
	afp-Finite_Automata_HF-2015-02-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/First_Order_Terms.html b/web/entries/First_Order_Terms.html
	--- a/web/entries/First_Order_Terms.html
	+++ b/web/entries/First_Order_Terms.html
	@@ -1,191 +1,196 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>First-Order Terms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>irst-Order

	<font class="first">T</font>erms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">First-Order Terms</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-02-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize basic results on first-order terms, including matching and a
	first-order unification algorithm, as well as well-foundedness of the
	subsumption order. This entry is part of the <i>Isabelle
	Formalization of Rewriting</i> <a
	href="http://cl-informatik.uibk.ac.at/isafor">IsaFoR</a>,
	where first-order terms are omni-present: the unification algorithm is
	used to certify several confluence and termination techniques, like
	critical-pair computation and dependency graph approximations; and the
	subsumption order is a crucial ingredient for completion.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{First_Order_Terms-AFP,
	author = {Christian Sternagel and René Thiemann},
	title = {First-Order Terms},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/First_Order_Terms.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Functional_Ordered_Resolution_Prover.html">Functional_Ordered_Resolution_Prover</a>, <a href="Resolution_FOL.html">Resolution_FOL</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/First_Order_Terms/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/First_Order_Terms/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/First_Order_Terms/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-First_Order_Terms-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-First_Order_Terms-2018-08-16.tar.gz">
	+ afp-First_Order_Terms-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-First_Order_Terms-2018-02-07.tar.gz">
	afp-First_Order_Terms-2018-02-07.tar.gz
	</a>
	</li>
	<li>Isabelle 2017:
	<a href="../release/afp-First_Order_Terms-2018-02-06.tar.gz">
	afp-First_Order_Terms-2018-02-06.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/First_Welfare_Theorem.html b/web/entries/First_Welfare_Theorem.html
	--- a/web/entries/First_Welfare_Theorem.html
	+++ b/web/entries/First_Welfare_Theorem.html
	@@ -1,210 +1,215 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Microeconomics and the First Welfare Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>icroeconomics

	and

	the

	<font class="first">F</font>irst

	<font class="first">W</font>elfare

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Microeconomics and the First Welfare Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Julian Parsert (julian /dot/ parsert /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/users/cek/">Cezary Kaliszyk</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-09-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Economic activity has always been a fundamental part of society. Due
	to modern day politics, economic theory has gained even more influence
	on our lives. Thus we want models and theories to be as precise as
	possible. This can be achieved using certification with the help of
	formal proof technology. Hence we will use Isabelle/HOL to construct
	two economic models, that of the the pure exchange economy and a
	version of the Arrow-Debreu Model. We will prove that the
	<i>First Theorem of Welfare Economics</i> holds within
	both. The theorem is the mathematical formulation of Adam Smith's
	famous <i>invisible hand</i> and states that a group of
	self-interested and rational actors will eventually achieve an
	efficient allocation of goods and services.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-06-17]: Added some lemmas and a theory file, also introduced Microeconomics folder.
	<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{First_Welfare_Theorem-AFP,
	author = {Julian Parsert and Cezary Kaliszyk},
	title = {Microeconomics and the First Welfare Theorem},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/First_Welfare_Theorem.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Neumann_Morgenstern_Utility.html">Neumann_Morgenstern_Utility</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/First_Welfare_Theorem/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/First_Welfare_Theorem/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/First_Welfare_Theorem/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-First_Welfare_Theorem-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-First_Welfare_Theorem-2018-08-16.tar.gz">
	+ afp-First_Welfare_Theorem-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-First_Welfare_Theorem-2017-10-10.tar.gz">
	afp-First_Welfare_Theorem-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-First_Welfare_Theorem-2017-09-05.tar.gz">
	afp-First_Welfare_Theorem-2017-09-05.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-First_Welfare_Theorem-2017-09-04.tar.gz">
	afp-First_Welfare_Theorem-2017-09-04.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Fishburn_Impossibility.html b/web/entries/Fishburn_Impossibility.html
	--- a/web/entries/Fishburn_Impossibility.html
	+++ b/web/entries/Fishburn_Impossibility.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Incompatibility of Fishburn-Strategyproofness and Pareto-Efficiency - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">I</font>ncompatibility

	of

	<font class="first">F</font>ishburn-Strategyproofness

	and

	<font class="first">P</font>areto-Efficiency

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Incompatibility of Fishburn-Strategyproofness and Pareto-Efficiency</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://dss.in.tum.de/staff/brandt.html">Felix Brandt</a>,
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>,
	<a href="http://dss.in.tum.de/staff/christian-saile.html">Christian Saile</a> and
	<a href="http://dss.in.tum.de/staff/christian-stricker.html">Christian Stricker</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-03-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This formalisation contains the proof that there is no
	anonymous Social Choice Function for at least three agents and
	alternatives that fulfils both Pareto-Efficiency and
	Fishburn-Strategyproofness. It was derived from a proof of <a
	href="http://dss.in.tum.de/files/brandt-research/stratset.pdf">Brandt
	<em>et al.</em></a>, which relies on an unverified
	translation of a fixed finite instance of the original problem to SAT.
	This Isabelle proof contains a machine-checked version of both the
	statement for exactly three agents and alternatives and the lifting to
	the general case.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Fishburn_Impossibility-AFP,
	author = {Felix Brandt and Manuel Eberl and Christian Saile and Christian Stricker},
	title = {The Incompatibility of Fishburn-Strategyproofness and Pareto-Efficiency},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Fishburn_Impossibility.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Randomised_Social_Choice.html">Randomised_Social_Choice</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Fishburn_Impossibility/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Fishburn_Impossibility/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Fishburn_Impossibility/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Fishburn_Impossibility-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Fishburn_Impossibility-2018-08-16.tar.gz">
	+ afp-Fishburn_Impossibility-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Fishburn_Impossibility-2018-06-10.tar.gz">
	afp-Fishburn_Impossibility-2018-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2017:
	<a href="../release/afp-Fishburn_Impossibility-2018-03-23.tar.gz">
	afp-Fishburn_Impossibility-2018-03-23.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Fisher_Yates.html b/web/entries/Fisher_Yates.html
	--- a/web/entries/Fisher_Yates.html
	+++ b/web/entries/Fisher_Yates.html
	@@ -1,182 +1,187 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Fisher–Yates shuffle - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>isher–Yates

	shuffle

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Fisher–Yates shuffle</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-09-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This work defines and proves the correctness of the Fisher–Yates
	algorithm for shuffling – i.e. producing a random permutation – of a
	list. The algorithm proceeds by traversing the list and in
	each step swapping the current element with a random element from the
	remaining list.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Fisher_Yates-AFP,
	author = {Manuel Eberl},
	title = {Fisher–Yates shuffle},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Fisher_Yates.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Fisher_Yates/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Fisher_Yates/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Fisher_Yates/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Fisher_Yates-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Fisher_Yates-2018-08-16.tar.gz">
	+ afp-Fisher_Yates-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Fisher_Yates-2017-10-10.tar.gz">
	afp-Fisher_Yates-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Fisher_Yates-2016-12-17.tar.gz">
	afp-Fisher_Yates-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Flow_Networks.html b/web/entries/Flow_Networks.html
	--- a/web/entries/Flow_Networks.html
	+++ b/web/entries/Flow_Networks.html
	@@ -1,194 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Flow Networks and the Min-Cut-Max-Flow Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>low

	<font class="first">N</font>etworks

	and

	the

	<font class="first">M</font>in-Cut-Max-Flow

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Flow Networks and the Min-Cut-Max-Flow Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	S. Reza Sefidgar
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-06-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formalization of flow networks and the Min-Cut-Max-Flow
	theorem. Our formal proof closely follows a standard textbook proof,
	and is accessible even without being an expert in Isabelle/HOL, the
	interactive theorem prover used for the formalization.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Flow_Networks-AFP,
	author = {Peter Lammich and S. Reza Sefidgar},
	title = {Flow Networks and the Min-Cut-Max-Flow Theorem},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Flow_Networks.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CAVA_Automata.html">CAVA_Automata</a>, <a href="DFS_Framework.html">DFS_Framework</a>, <a href="Program-Conflict-Analysis.html">Program-Conflict-Analysis</a>, <a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="EdmondsKarp_Maxflow.html">EdmondsKarp_Maxflow</a>, <a href="Prpu_Maxflow.html">Prpu_Maxflow</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Flow_Networks/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Flow_Networks/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Flow_Networks/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Flow_Networks-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Flow_Networks-2018-08-16.tar.gz">
	+ afp-Flow_Networks-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Flow_Networks-2017-10-10.tar.gz">
	afp-Flow_Networks-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Flow_Networks-2017-06-02.tar.gz">
	afp-Flow_Networks-2017-06-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Floyd_Warshall.html b/web/entries/Floyd_Warshall.html
	--- a/web/entries/Floyd_Warshall.html
	+++ b/web/entries/Floyd_Warshall.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Floyd-Warshall Algorithm for Shortest Paths - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">F</font>loyd-Warshall

	<font class="first">A</font>lgorithm

	for

	<font class="first">S</font>hortest

	<font class="first">P</font>aths

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Floyd-Warshall Algorithm for Shortest Paths</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a> and
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The Floyd-Warshall algorithm [Flo62, Roy59, War62] is a classic
	dynamic programming algorithm to compute the length of all shortest
	paths between any two vertices in a graph (i.e. to solve the all-pairs
	shortest path problem, or APSP for short). Given a representation of
	the graph as a matrix of weights M, it computes another matrix M'
	which represents a graph with the same path lengths and contains the
	length of the shortest path between any two vertices i and j. This is
	only possible if the graph does not contain any negative cycles.
	However, in this case the Floyd-Warshall algorithm will detect the
	situation by calculating a negative diagonal entry. This entry
	includes a formalization of the algorithm and of these key properties.
	The algorithm is refined to an efficient imperative version using the
	Imperative Refinement Framework.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Floyd_Warshall-AFP,
	author = {Simon Wimmer and Peter Lammich},
	title = {The Floyd-Warshall Algorithm for Shortest Paths},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Floyd_Warshall.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Floyd_Warshall/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Floyd_Warshall/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Floyd_Warshall/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Floyd_Warshall-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Floyd_Warshall-2018-08-16.tar.gz">
	+ afp-Floyd_Warshall-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Floyd_Warshall-2017-10-10.tar.gz">
	afp-Floyd_Warshall-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Floyd_Warshall-2017-05-09.tar.gz">
	afp-Floyd_Warshall-2017-05-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Flyspeck-Tame.html b/web/entries/Flyspeck-Tame.html
	--- a/web/entries/Flyspeck-Tame.html
	+++ b/web/entries/Flyspeck-Tame.html
	@@ -1,276 +1,281 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Flyspeck I: Tame Graphs - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>lyspeck

	<font class="first">I</font>:

	<font class="first">T</font>ame

	<font class="first">G</font>raphs

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Flyspeck I: Tame Graphs</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Gertrud Bauer and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2006-05-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	These theories present the verified enumeration of <i>tame</i> plane graphs
	as defined by Thomas C. Hales in his proof of the Kepler Conjecture in his
	book <i>Dense Sphere Packings. A Blueprint for Formal Proofs.</i> [CUP 2012].
	The values of the constants in the definition of tameness are identical to
	those in the <a href="https://code.google.com/p/flyspeck/">Flyspeck project</a>.
	The <a href="http://www21.in.tum.de/~nipkow/pubs/Flyspeck/">IJCAR 2006 paper by Nipkow, Bauer and Schultz</a> refers to the original version of Hales' proof,
	the <a href="http://www21.in.tum.de/~nipkow/pubs/itp11/">ITP 2011 paper by Nipkow</a> refers to the Blueprint version of the proof.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2010-11-02]: modified theories to reflect the modified definition of tameness in Hales' revised proof.<br>
	[2014-07-03]: modified constants in def of tameness and Archive according to the final state of the Flyspeck proof.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Flyspeck-Tame-AFP,
	author = {Gertrud Bauer and Tobias Nipkow},
	title = {Flyspeck I: Tame Graphs},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2006,
	note = {\url{http://isa-afp.org/entries/Flyspeck-Tame.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Trie.html">Trie</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Flyspeck-Tame/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Flyspeck-Tame/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Flyspeck-Tame/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Flyspeck-Tame-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Flyspeck-Tame-2018-08-17.tar.gz">
	+ afp-Flyspeck-Tame-2018-08-17.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Flyspeck-Tame-2017-10-10.tar.gz">
	afp-Flyspeck-Tame-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Flyspeck-Tame-2016-12-17.tar.gz">
	afp-Flyspeck-Tame-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Flyspeck-Tame-2016-02-22.tar.gz">
	afp-Flyspeck-Tame-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Flyspeck-Tame-2015-05-27.tar.gz">
	afp-Flyspeck-Tame-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Flyspeck-Tame-2014-08-28.tar.gz">
	afp-Flyspeck-Tame-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Flyspeck-Tame-2013-12-11.tar.gz">
	afp-Flyspeck-Tame-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Flyspeck-Tame-2013-11-17.tar.gz">
	afp-Flyspeck-Tame-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Flyspeck-Tame-2013-03-02.tar.gz">
	afp-Flyspeck-Tame-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Flyspeck-Tame-2013-02-16.tar.gz">
	afp-Flyspeck-Tame-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Flyspeck-Tame-2012-05-25.tar.gz">
	afp-Flyspeck-Tame-2012-05-25.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Flyspeck-Tame-2011-10-11.tar.gz">
	afp-Flyspeck-Tame-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Flyspeck-Tame-2011-02-11.tar.gz">
	afp-Flyspeck-Tame-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Flyspeck-Tame-2010-06-30.tar.gz">
	afp-Flyspeck-Tame-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Flyspeck-Tame-2009-12-12.tar.gz">
	afp-Flyspeck-Tame-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Flyspeck-Tame-2009-04-29.tar.gz">
	afp-Flyspeck-Tame-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Flyspeck-Tame-2008-06-10.tar.gz">
	afp-Flyspeck-Tame-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Flyspeck-Tame-2008-01-04.tar.gz">
	afp-Flyspeck-Tame-2008-01-04.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Flyspeck-Tame-2007-11-27.tar.gz">
	afp-Flyspeck-Tame-2007-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FocusStreamsCaseStudies.html b/web/entries/FocusStreamsCaseStudies.html
	--- a/web/entries/FocusStreamsCaseStudies.html
	+++ b/web/entries/FocusStreamsCaseStudies.html
	@@ -1,222 +1,227 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stream Processing Components: Isabelle/HOL Formalisation and Case Studies - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tream

	<font class="first">P</font>rocessing

	<font class="first">C</font>omponents:

	<font class="first">I</font>sabelle/HOL

	<font class="first">F</font>ormalisation

	and

	<font class="first">C</font>ase

	<font class="first">S</font>tudies

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stream Processing Components: Isabelle/HOL Formalisation and Case Studies</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Maria Spichkova (maria /dot/ spichkova /at/ rmit /dot/ edu /dot/ au)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-11-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This set of theories presents an Isabelle/HOL formalisation of stream processing components introduced
	in Focus,
	a framework for formal specification and development of interactive systems.
	This is an extended and updated version of the formalisation, which was
	elaborated within the methodology "Focus on Isabelle".
	In addition, we also applied the formalisation on three case studies
	that cover different application areas: process control (Steam Boiler System),
	data transmission (FlexRay communication protocol),
	memory and processing components (Automotive-Gateway System).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FocusStreamsCaseStudies-AFP,
	author = {Maria Spichkova},
	title = {Stream Processing Components: Isabelle/HOL Formalisation and Case Studies},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/FocusStreamsCaseStudies.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FocusStreamsCaseStudies/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FocusStreamsCaseStudies/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FocusStreamsCaseStudies/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FocusStreamsCaseStudies-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FocusStreamsCaseStudies-2018-08-16.tar.gz">
	+ afp-FocusStreamsCaseStudies-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FocusStreamsCaseStudies-2017-10-10.tar.gz">
	afp-FocusStreamsCaseStudies-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FocusStreamsCaseStudies-2016-12-17.tar.gz">
	afp-FocusStreamsCaseStudies-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-FocusStreamsCaseStudies-2016-02-22.tar.gz">
	afp-FocusStreamsCaseStudies-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-FocusStreamsCaseStudies-2015-05-27.tar.gz">
	afp-FocusStreamsCaseStudies-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-FocusStreamsCaseStudies-2014-08-28.tar.gz">
	afp-FocusStreamsCaseStudies-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-FocusStreamsCaseStudies-2013-12-11.tar.gz">
	afp-FocusStreamsCaseStudies-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-FocusStreamsCaseStudies-2013-11-18.tar.gz">
	afp-FocusStreamsCaseStudies-2013-11-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Formal_SSA.html b/web/entries/Formal_SSA.html
	--- a/web/entries/Formal_SSA.html
	+++ b/web/entries/Formal_SSA.html
	@@ -1,227 +1,232 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Verified Construction of Static Single Assignment Form - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erified

	<font class="first">C</font>onstruction

	of

	<font class="first">S</font>tatic

	<font class="first">S</font>ingle

	<font class="first">A</font>ssignment

	<font class="first">F</font>orm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Verified Construction of Static Single Assignment Form</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Sebastian Ullrich (sebasti /at/ nullri /dot/ ch) and
	<a href="http://pp.ipd.kit.edu/person.php?id=88">Denis Lohner</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-02-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	We define a functional variant of the static single assignment (SSA)
	form construction algorithm described by <a
	href="https://doi.org/10.1007/978-3-642-37051-9_6">Braun et al.</a>,
	which combines simplicity and efficiency. The definition is based on a
	general, abstract control flow graph representation using Isabelle locales.
	</p>
	<p>
	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.
	</p>
	<p>
	Furthermore, we use a generic instantiation based on typedefs in order
	to extract OCaml code and replace the unverified SSA construction
	algorithm of the <a href="https://doi.org/10.1145/2579080">CompCertSSA
	project</a> with it.
	</p>
	<p>
	A more detailed description of the verified SSA construction can be found
	in the paper <a href="https://doi.org/10.1145/2892208.2892211">Verified
	Construction of Static Single Assignment Form</a>, CC 2016.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Formal_SSA.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CAVA_Automata.html">CAVA_Automata</a>, <a href="Collections.html">Collections</a>, <a href="Dijkstra_Shortest_Path.html">Dijkstra_Shortest_Path</a>, <a href="Slicing.html">Slicing</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Minimal_SSA.html">Minimal_SSA</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Formal_SSA/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Formal_SSA/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Formal_SSA/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Formal_SSA-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Formal_SSA-2018-08-16.tar.gz">
	+ afp-Formal_SSA-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Formal_SSA-2017-10-10.tar.gz">
	afp-Formal_SSA-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Formal_SSA-2016-12-17.tar.gz">
	afp-Formal_SSA-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Formal_SSA-2016-02-22.tar.gz">
	afp-Formal_SSA-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Formal_SSA-2016-02-08.tar.gz">
	afp-Formal_SSA-2016-02-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Formula_Derivatives.html b/web/entries/Formula_Derivatives.html
	--- a/web/entries/Formula_Derivatives.html
	+++ b/web/entries/Formula_Derivatives.html
	@@ -1,208 +1,213 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Derivatives of Logical Formulas - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>erivatives

	of

	<font class="first">L</font>ogical

	<font class="first">F</font>ormulas

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Derivatives of Logical Formulas</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-05-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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 <em>not</em> 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).
	<p>
	The WS1S instance is described in the draft paper <a
	href="https://people.inf.ethz.ch/trayteld/papers/csl15-ws1s_derivatives/index.html">A
	Coalgebraic Decision Procedure for WS1S</a> by the author.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Formula_Derivatives-AFP,
	author = {Dmitriy Traytel},
	title = {Derivatives of Logical Formulas},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Formula_Derivatives.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive_Languages.html">Coinductive_Languages</a>, <a href="Deriving.html">Deriving</a>, <a href="List-Index.html">List-Index</a>, <a href="Show.html">Show</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Formula_Derivatives/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Formula_Derivatives/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Formula_Derivatives/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Formula_Derivatives-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Formula_Derivatives-2018-08-16.tar.gz">
	+ afp-Formula_Derivatives-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Formula_Derivatives-2017-10-10.tar.gz">
	afp-Formula_Derivatives-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Formula_Derivatives-2016-12-17.tar.gz">
	afp-Formula_Derivatives-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Formula_Derivatives-2016-02-22.tar.gz">
	afp-Formula_Derivatives-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Formula_Derivatives-2015-05-28.tar.gz">
	afp-Formula_Derivatives-2015-05-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Free-Boolean-Algebra.html b/web/entries/Free-Boolean-Algebra.html
	--- a/web/entries/Free-Boolean-Algebra.html
	+++ b/web/entries/Free-Boolean-Algebra.html
	@@ -1,239 +1,244 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Free Boolean Algebra - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ree

	<font class="first">B</font>oolean

	<font class="first">A</font>lgebra

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Free Boolean Algebra</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Brian Huffman
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-03-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This theory defines a type constructor representing the free Boolean algebra over a set of generators. Values of type (α)<i>formula</i> represent propositional formulas with uninterpreted variables from type α, ordered by implication. In addition to all the standard Boolean algebra operations, the library also provides a function for building homomorphisms to any other Boolean algebra type.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Free-Boolean-Algebra-AFP,
	author = {Brian Huffman},
	title = {Free Boolean Algebra},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Free-Boolean-Algebra.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Free-Boolean-Algebra/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Free-Boolean-Algebra/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Free-Boolean-Algebra/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Free-Boolean-Algebra-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Free-Boolean-Algebra-2018-08-16.tar.gz">
	+ afp-Free-Boolean-Algebra-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Free-Boolean-Algebra-2017-10-10.tar.gz">
	afp-Free-Boolean-Algebra-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Free-Boolean-Algebra-2016-12-17.tar.gz">
	afp-Free-Boolean-Algebra-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Free-Boolean-Algebra-2016-02-22.tar.gz">
	afp-Free-Boolean-Algebra-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Free-Boolean-Algebra-2015-05-27.tar.gz">
	afp-Free-Boolean-Algebra-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Free-Boolean-Algebra-2014-08-28.tar.gz">
	afp-Free-Boolean-Algebra-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Free-Boolean-Algebra-2013-12-11.tar.gz">
	afp-Free-Boolean-Algebra-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Free-Boolean-Algebra-2013-11-17.tar.gz">
	afp-Free-Boolean-Algebra-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Free-Boolean-Algebra-2013-03-02.tar.gz">
	afp-Free-Boolean-Algebra-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Free-Boolean-Algebra-2013-02-16.tar.gz">
	afp-Free-Boolean-Algebra-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Free-Boolean-Algebra-2012-05-24.tar.gz">
	afp-Free-Boolean-Algebra-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Free-Boolean-Algebra-2011-10-11.tar.gz">
	afp-Free-Boolean-Algebra-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Free-Boolean-Algebra-2011-02-11.tar.gz">
	afp-Free-Boolean-Algebra-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Free-Boolean-Algebra-2010-06-30.tar.gz">
	afp-Free-Boolean-Algebra-2010-06-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Free-Boolean-Algebra-2010-03-29.tar.gz">
	afp-Free-Boolean-Algebra-2010-03-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Free-Groups.html b/web/entries/Free-Groups.html
	--- a/web/entries/Free-Groups.html
	+++ b/web/entries/Free-Groups.html
	@@ -1,239 +1,244 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Free Groups - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ree

	<font class="first">G</font>roups

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Free Groups</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Joachim Breitner (joachim /at/ cis /dot/ upenn /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-06-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Free Groups are, in a sense, the most generic kind of group. They
	are defined over a set of generators with no additional relations in between
	them. They play an important role in the definition of group presentations
	and in other fields. This theory provides the definition of Free Group as
	the set of fully canceled words in the generators. The universal property is
	proven, as well as some isomorphisms results about Free Groups.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2011-12-11]: Added the Ping Pong Lemma.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Free-Groups-AFP,
	author = {Joachim Breitner},
	title = {Free Groups},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Free-Groups.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Applicative_Lifting.html">Applicative_Lifting</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Free-Groups/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Free-Groups/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Free-Groups/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Free-Groups-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Free-Groups-2018-08-16.tar.gz">
	+ afp-Free-Groups-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Free-Groups-2017-10-10.tar.gz">
	afp-Free-Groups-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Free-Groups-2016-12-17.tar.gz">
	afp-Free-Groups-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Free-Groups-2016-02-22.tar.gz">
	afp-Free-Groups-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Free-Groups-2015-05-27.tar.gz">
	afp-Free-Groups-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Free-Groups-2014-08-28.tar.gz">
	afp-Free-Groups-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Free-Groups-2013-12-11.tar.gz">
	afp-Free-Groups-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Free-Groups-2013-11-17.tar.gz">
	afp-Free-Groups-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Free-Groups-2013-02-16.tar.gz">
	afp-Free-Groups-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Free-Groups-2012-05-24.tar.gz">
	afp-Free-Groups-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Free-Groups-2011-10-11.tar.gz">
	afp-Free-Groups-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Free-Groups-2011-02-11.tar.gz">
	afp-Free-Groups-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Free-Groups-2010-07-01.tar.gz">
	afp-Free-Groups-2010-07-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FunWithFunctions.html b/web/entries/FunWithFunctions.html
	--- a/web/entries/FunWithFunctions.html
	+++ b/web/entries/FunWithFunctions.html
	@@ -1,239 +1,244 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Fun With Functions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>un

	<font class="first">W</font>ith

	<font class="first">F</font>unctions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Fun With Functions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-08-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This is a collection of cute puzzles of the form ``Show that if a function satisfies the following constraints, it must be ...'' Please add further examples to this collection!</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FunWithFunctions-AFP,
	author = {Tobias Nipkow},
	title = {Fun With Functions},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/FunWithFunctions.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FunWithFunctions/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FunWithFunctions/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FunWithFunctions/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FunWithFunctions-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FunWithFunctions-2018-08-16.tar.gz">
	+ afp-FunWithFunctions-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FunWithFunctions-2017-10-10.tar.gz">
	afp-FunWithFunctions-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FunWithFunctions-2016-12-17.tar.gz">
	afp-FunWithFunctions-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-FunWithFunctions-2016-02-22.tar.gz">
	afp-FunWithFunctions-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-FunWithFunctions-2015-05-27.tar.gz">
	afp-FunWithFunctions-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-FunWithFunctions-2014-08-28.tar.gz">
	afp-FunWithFunctions-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-FunWithFunctions-2013-12-11.tar.gz">
	afp-FunWithFunctions-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-FunWithFunctions-2013-11-17.tar.gz">
	afp-FunWithFunctions-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-FunWithFunctions-2013-02-16.tar.gz">
	afp-FunWithFunctions-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-FunWithFunctions-2012-05-24.tar.gz">
	afp-FunWithFunctions-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-FunWithFunctions-2011-10-11.tar.gz">
	afp-FunWithFunctions-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-FunWithFunctions-2011-02-11.tar.gz">
	afp-FunWithFunctions-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-FunWithFunctions-2010-07-01.tar.gz">
	afp-FunWithFunctions-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-FunWithFunctions-2009-12-12.tar.gz">
	afp-FunWithFunctions-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-FunWithFunctions-2009-04-29.tar.gz">
	afp-FunWithFunctions-2009-04-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/FunWithTilings.html b/web/entries/FunWithTilings.html
	--- a/web/entries/FunWithTilings.html
	+++ b/web/entries/FunWithTilings.html
	@@ -1,240 +1,245 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Fun With Tilings - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>un

	<font class="first">W</font>ith

	<font class="first">T</font>ilings

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Fun With Tilings</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a> and
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-11-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Tilings are defined inductively. It is shown that one form of mutilated chess board cannot be tiled with dominoes, while another one can be tiled with L-shaped tiles. Please add further fun examples of this kind!</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{FunWithTilings-AFP,
	author = {Tobias Nipkow and Lawrence C. Paulson},
	title = {Fun With Tilings},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/FunWithTilings.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FunWithTilings/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/FunWithTilings/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/FunWithTilings/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-FunWithTilings-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-FunWithTilings-2018-08-16.tar.gz">
	+ afp-FunWithTilings-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-FunWithTilings-2017-10-10.tar.gz">
	afp-FunWithTilings-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-FunWithTilings-2016-12-17.tar.gz">
	afp-FunWithTilings-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-FunWithTilings-2016-02-22.tar.gz">
	afp-FunWithTilings-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-FunWithTilings-2015-05-27.tar.gz">
	afp-FunWithTilings-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-FunWithTilings-2014-08-28.tar.gz">
	afp-FunWithTilings-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-FunWithTilings-2013-12-11.tar.gz">
	afp-FunWithTilings-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-FunWithTilings-2013-11-17.tar.gz">
	afp-FunWithTilings-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-FunWithTilings-2013-02-16.tar.gz">
	afp-FunWithTilings-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-FunWithTilings-2012-05-24.tar.gz">
	afp-FunWithTilings-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-FunWithTilings-2011-10-11.tar.gz">
	afp-FunWithTilings-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-FunWithTilings-2011-02-11.tar.gz">
	afp-FunWithTilings-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-FunWithTilings-2010-07-01.tar.gz">
	afp-FunWithTilings-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-FunWithTilings-2009-12-12.tar.gz">
	afp-FunWithTilings-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-FunWithTilings-2009-04-29.tar.gz">
	afp-FunWithTilings-2009-04-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Functional-Automata.html b/web/entries/Functional-Automata.html
	--- a/web/entries/Functional-Automata.html
	+++ b/web/entries/Functional-Automata.html
	@@ -1,274 +1,279 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Functional Automata - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>unctional

	<font class="first">A</font>utomata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Functional Automata</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-03-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This theory defines deterministic and nondeterministic automata in a functional representation: the transition function/relation and the finality predicate are just functions. Hence the state space may be infinite. It is shown how to convert regular expressions into such automata. A scanner (generator) is implemented with the help of functional automata: the scanner chops the input up into longest recognized substrings. Finally we also show how to convert a certain subclass of functional automata (essentially the finite deterministic ones) into regular sets.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Functional-Automata-AFP,
	author = {Tobias Nipkow},
	title = {Functional Automata},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Functional-Automata.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Regular-Sets.html">Regular-Sets</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Functional-Automata/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Functional-Automata/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Functional-Automata/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Functional-Automata-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Functional-Automata-2018-08-16.tar.gz">
	+ afp-Functional-Automata-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Functional-Automata-2017-10-10.tar.gz">
	afp-Functional-Automata-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Functional-Automata-2016-12-17.tar.gz">
	afp-Functional-Automata-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Functional-Automata-2016-02-22.tar.gz">
	afp-Functional-Automata-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Functional-Automata-2015-05-27.tar.gz">
	afp-Functional-Automata-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Functional-Automata-2014-08-28.tar.gz">
	afp-Functional-Automata-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Functional-Automata-2013-12-11.tar.gz">
	afp-Functional-Automata-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Functional-Automata-2013-11-17.tar.gz">
	afp-Functional-Automata-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Functional-Automata-2013-03-02.tar.gz">
	afp-Functional-Automata-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Functional-Automata-2013-02-16.tar.gz">
	afp-Functional-Automata-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Functional-Automata-2012-05-24.tar.gz">
	afp-Functional-Automata-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Functional-Automata-2011-10-11.tar.gz">
	afp-Functional-Automata-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Functional-Automata-2011-02-11.tar.gz">
	afp-Functional-Automata-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Functional-Automata-2010-07-01.tar.gz">
	afp-Functional-Automata-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Functional-Automata-2009-12-12.tar.gz">
	afp-Functional-Automata-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Functional-Automata-2009-04-29.tar.gz">
	afp-Functional-Automata-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Functional-Automata-2008-06-10.tar.gz">
	afp-Functional-Automata-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Functional-Automata-2007-11-27.tar.gz">
	afp-Functional-Automata-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Functional-Automata-2005-10-14.tar.gz">
	afp-Functional-Automata-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Functional-Automata-2004-05-21.tar.gz">
	afp-Functional-Automata-2004-05-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Functional-Automata-2004-04-20.tar.gz">
	afp-Functional-Automata-2004-04-20.tar.gz
	</a>
	</li>
	<li>Isabelle 2003:
	<a href="../release/afp-Functional-Automata-2004-03-30.tar.gz">
	afp-Functional-Automata-2004-03-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Functional_Ordered_Resolution_Prover.html b/web/entries/Functional_Ordered_Resolution_Prover.html
	--- a/web/entries/Functional_Ordered_Resolution_Prover.html
	+++ b/web/entries/Functional_Ordered_Resolution_Prover.html
	@@ -1,193 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Verified Functional Implementation of Bachmair and Ganzinger's Ordered Resolution Prover - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">V</font>erified

	<font class="first">F</font>unctional

	<font class="first">I</font>mplementation

	of

	<font class="first">B</font>achmair

	and

	<font class="first">G</font>anzinger's

	<font class="first">O</font>rdered

	<font class="first">R</font>esolution

	<font class="first">P</font>rover

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Verified Functional Implementation of Bachmair and Ganzinger's Ordered Resolution Prover</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Anders Schlichtkrull (andschl /at/ dtu /dot/ dk),
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl) and
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-11-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This Isabelle/HOL formalization refines the abstract ordered
	resolution prover presented in Section 4.3 of Bachmair and
	Ganzinger's "Resolution Theorem Proving" chapter in the
	<i>Handbook of Automated Reasoning</i>. The result is a
	functional implementation of a first-order prover.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Functional_Ordered_Resolution_Prover-AFP,
	author = {Anders Schlichtkrull and Jasmin Christian Blanchette and Dmitriy Traytel},
	title = {A Verified Functional Implementation of Bachmair and Ganzinger's Ordered Resolution Prover},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Functional_Ordered_Resolution_Prover.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="First_Order_Terms.html">First_Order_Terms</a>, <a href="Nested_Multisets_Ordinals.html">Nested_Multisets_Ordinals</a>, <a href="Open_Induction.html">Open_Induction</a>, <a href="Ordered_Resolution_Prover.html">Ordered_Resolution_Prover</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Functional_Ordered_Resolution_Prover/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Functional_Ordered_Resolution_Prover/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Functional_Ordered_Resolution_Prover/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Functional_Ordered_Resolution_Prover-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Functional_Ordered_Resolution_Prover-2018-11-29.tar.gz">
	+ afp-Functional_Ordered_Resolution_Prover-2018-11-29.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/GPU_Kernel_PL.html b/web/entries/GPU_Kernel_PL.html
	--- a/web/entries/GPU_Kernel_PL.html
	+++ b/web/entries/GPU_Kernel_PL.html
	@@ -1,217 +1,222 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Syntax and semantics of a GPU kernel programming language - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>yntax

	and

	semantics

	of

	a

	<font class="first">G</font>PU

	kernel

	programming

	language

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Syntax and semantics of a GPU kernel programming language</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	John Wickerson
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-04-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This document accompanies the article "The Design and
	Implementation of a Verification Technique for GPU Kernels"
	by Adam Betts, Nathan Chong, Alastair F. Donaldson, Jeroen
	Ketema, Shaz Qadeer, Paul Thomson and John Wickerson. It
	formalises all of the definitions provided in Sections 3
	and 4 of the article.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{GPU_Kernel_PL-AFP,
	author = {John Wickerson},
	title = {Syntax and semantics of a GPU kernel programming language},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/GPU_Kernel_PL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GPU_Kernel_PL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/GPU_Kernel_PL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GPU_Kernel_PL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-GPU_Kernel_PL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-GPU_Kernel_PL-2018-08-16.tar.gz">
	+ afp-GPU_Kernel_PL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-GPU_Kernel_PL-2017-10-10.tar.gz">
	afp-GPU_Kernel_PL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-GPU_Kernel_PL-2016-12-17.tar.gz">
	afp-GPU_Kernel_PL-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-GPU_Kernel_PL-2016-02-22.tar.gz">
	afp-GPU_Kernel_PL-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-GPU_Kernel_PL-2015-05-27.tar.gz">
	afp-GPU_Kernel_PL-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-GPU_Kernel_PL-2014-08-28.tar.gz">
	afp-GPU_Kernel_PL-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-GPU_Kernel_PL-2014-04-06.tar.gz">
	afp-GPU_Kernel_PL-2014-04-06.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Gabow_SCC.html b/web/entries/Gabow_SCC.html
	--- a/web/entries/Gabow_SCC.html
	+++ b/web/entries/Gabow_SCC.html
	@@ -1,223 +1,228 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Verified Efficient Implementation of Gabow's Strongly Connected Components Algorithm - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erified

	<font class="first">E</font>fficient

	<font class="first">I</font>mplementation

	of

	<font class="first">G</font>abow's

	<font class="first">S</font>trongly

	<font class="first">C</font>onnected

	<font class="first">C</font>omponents

	<font class="first">A</font>lgorithm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Verified Efficient Implementation of Gabow's Strongly Connected Components Algorithm</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-05-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present an Isabelle/HOL formalization of Gabow's algorithm for
	finding the strongly connected components of a directed graph.
	Using data refinement techniques, we extract efficient code that
	performs comparable to a reference implementation in Java.
	Our style of formalization allows for re-using large parts of the proofs
	when defining variants of the algorithm. We demonstrate this by
	verifying an algorithm for the emptiness check of generalized Büchi
	automata, re-using most of the existing proofs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Gabow_SCC-AFP,
	author = {Peter Lammich},
	title = {Verified Efficient Implementation of Gabow's Strongly Connected Components Algorithm},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Gabow_SCC.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CAVA_Automata.html">CAVA_Automata</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CAVA_LTL_Modelchecker.html">CAVA_LTL_Modelchecker</a>, <a href="Transition_Systems_and_Automata.html">Transition_Systems_and_Automata</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Gabow_SCC/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Gabow_SCC/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Gabow_SCC/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Gabow_SCC-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Gabow_SCC-2018-08-16.tar.gz">
	+ afp-Gabow_SCC-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Gabow_SCC-2017-10-10.tar.gz">
	afp-Gabow_SCC-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Gabow_SCC-2016-12-17.tar.gz">
	afp-Gabow_SCC-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Gabow_SCC-2016-02-22.tar.gz">
	afp-Gabow_SCC-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Gabow_SCC-2015-05-27.tar.gz">
	afp-Gabow_SCC-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Gabow_SCC-2014-08-28.tar.gz">
	afp-Gabow_SCC-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Gabow_SCC-2014-05-29.tar.gz">
	afp-Gabow_SCC-2014-05-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Game_Based_Crypto.html b/web/entries/Game_Based_Crypto.html
	--- a/web/entries/Game_Based_Crypto.html
	+++ b/web/entries/Game_Based_Crypto.html
	@@ -1,209 +1,214 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Game-based cryptography in HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>ame-based

	cryptography

	in

	<font class="first">H</font>OL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Game-based cryptography in HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>,
	S. Reza Sefidgar and
	Bhargav Bhatt (bhargav /dot/ bhatt /at/ inf /dot/ ethz /dot/ ch)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>In this AFP entry, we show how to specify game-based cryptographic
	security notions and formally prove secure several cryptographic
	constructions from the literature using the CryptHOL framework. Among
	others, we formalise the notions of a random oracle, a pseudo-random
	function, an unpredictable function, and of encryption schemes that are
	indistinguishable under chosen plaintext and/or ciphertext attacks. We
	prove the random-permutation/random-function switching lemma, security
	of the Elgamal and hashed Elgamal public-key encryption scheme and
	correctness and security of several constructions with pseudo-random
	functions.
	</p><p>Our proofs follow the game-hopping style advocated by
	Shoup and Bellare and Rogaway, from which most of the examples have
	been taken. We generalise some of their results such that they can be
	reused in other proofs. Thanks to CryptHOL's integration with
	Isabelle's parametricity infrastructure, many simple hops are easily
	justified using the theory of representation independence.</p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-09-28]:
	added the CryptHOL tutorial for game-based cryptography
	(revision 489a395764ae)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Game_Based_Crypto-AFP,
	author = {Andreas Lochbihler and S. Reza Sefidgar and Bhargav Bhatt},
	title = {Game-based cryptography in HOL},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Game_Based_Crypto.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CryptHOL.html">CryptHOL</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Multi_Party_Computation.html">Multi_Party_Computation</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Game_Based_Crypto/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Game_Based_Crypto/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Game_Based_Crypto/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Game_Based_Crypto-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Game_Based_Crypto-2018-08-16.tar.gz">
	+ afp-Game_Based_Crypto-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Game_Based_Crypto-2017-10-10.tar.gz">
	afp-Game_Based_Crypto-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Game_Based_Crypto-2017-05-11.tar.gz">
	afp-Game_Based_Crypto-2017-05-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Gauss-Jordan-Elim-Fun.html b/web/entries/Gauss-Jordan-Elim-Fun.html
	--- a/web/entries/Gauss-Jordan-Elim-Fun.html
	+++ b/web/entries/Gauss-Jordan-Elim-Fun.html
	@@ -1,234 +1,239 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Gauss-Jordan Elimination for Matrices Represented as Functions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>auss-Jordan

	<font class="first">E</font>limination

	for

	<font class="first">M</font>atrices

	<font class="first">R</font>epresented

	as

	<font class="first">F</font>unctions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Gauss-Jordan Elimination for Matrices Represented as Functions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-08-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This theory provides a compact formulation of Gauss-Jordan elimination for matrices represented as functions. Its distinctive feature is succinctness. It is not meant for large computations.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Gauss-Jordan-Elim-Fun-AFP,
	author = {Tobias Nipkow},
	title = {Gauss-Jordan Elimination for Matrices Represented as Functions},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/Gauss-Jordan-Elim-Fun.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Markov_Models.html">Markov_Models</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Gauss-Jordan-Elim-Fun/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Gauss-Jordan-Elim-Fun/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Gauss-Jordan-Elim-Fun/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Gauss-Jordan-Elim-Fun-2018-08-16.tar.gz">
	+ afp-Gauss-Jordan-Elim-Fun-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2017-10-10.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2016-12-17.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2016-02-22.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2015-05-27.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2014-08-28.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2013-12-11.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2013-11-17.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2013-02-16.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2012-05-24.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2011-10-11.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Gauss-Jordan-Elim-Fun-2011-08-19.tar.gz">
	afp-Gauss-Jordan-Elim-Fun-2011-08-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Gauss_Jordan.html b/web/entries/Gauss_Jordan.html
	--- a/web/entries/Gauss_Jordan.html
	+++ b/web/entries/Gauss_Jordan.html
	@@ -1,203 +1,208 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Gauss-Jordan Algorithm and Its Applications - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>auss-Jordan

	<font class="first">A</font>lgorithm

	and

	<font class="first">I</font>ts

	<font class="first">A</font>pplications

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Gauss-Jordan Algorithm and Its Applications</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a> and
	<a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-09-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The Gauss-Jordan algorithm states that any matrix over a field can be transformed by means of elementary row operations to a matrix in reduced row echelon form. The formalization is based on the Rank Nullity Theorem entry of the AFP and on the HOL-Multivariate-Analysis session of Isabelle, where matrices are represented as functions over finite types. We have set up the code generator to make this representation executable. In order to improve the performance, a refinement to immutable arrays has been carried out. We have formalized some of the applications of the Gauss-Jordan algorithm. Thanks to this development, the following facts can be computed over matrices whose elements belong to a field: Ranks, Determinants, Inverses, Bases and dimensions and Solutions of systems of linear equations. Code can be exported to SML and Haskell.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Gauss_Jordan-AFP,
	author = {Jose Divasón and Jesús Aransay},
	title = {Gauss-Jordan Algorithm and Its Applications},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Gauss_Jordan.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Rank_Nullity_Theorem.html">Rank_Nullity_Theorem</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Echelon_Form.html">Echelon_Form</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a>, <a href="QR_Decomposition.html">QR_Decomposition</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Gauss_Jordan/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Gauss_Jordan/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Gauss_Jordan/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Gauss_Jordan-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Gauss_Jordan-2018-08-16.tar.gz">
	+ afp-Gauss_Jordan-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Gauss_Jordan-2017-10-10.tar.gz">
	afp-Gauss_Jordan-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Gauss_Jordan-2016-12-17.tar.gz">
	afp-Gauss_Jordan-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Gauss_Jordan-2016-02-22.tar.gz">
	afp-Gauss_Jordan-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Gauss_Jordan-2015-05-27.tar.gz">
	afp-Gauss_Jordan-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Gauss_Jordan-2014-09-03.tar.gz">
	afp-Gauss_Jordan-2014-09-03.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/GenClock.html b/web/entries/GenClock.html
	--- a/web/entries/GenClock.html
	+++ b/web/entries/GenClock.html
	@@ -1,269 +1,274 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of a Generalized Protocol for Clock Synchronization - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	a

	<font class="first">G</font>eneralized

	<font class="first">P</font>rotocol

	for

	<font class="first">C</font>lock

	<font class="first">S</font>ynchronization

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of a Generalized Protocol for Clock Synchronization</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Alwen Tiu (ATiu /at/ ntu /dot/ edu /dot/ sg)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2005-06-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalize the generalized Byzantine fault-tolerant clock synchronization protocol of Schneider. This protocol abstracts from particular algorithms or implementations for clock synchronization. This abstraction includes several assumptions on the behaviors of physical clocks and on general properties of concrete algorithms/implementations. Based on these assumptions the correctness of the protocol is proved by Schneider. His proof was later verified by Shankar using the theorem prover EHDM (precursor to PVS). Our formalization in Isabelle/HOL is based on Shankar's formalization.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{GenClock-AFP,
	author = {Alwen Tiu},
	title = {Formalization of a Generalized Protocol for Clock Synchronization},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2005,
	note = {\url{http://isa-afp.org/entries/GenClock.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GenClock/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/GenClock/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GenClock/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-GenClock-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-GenClock-2018-08-16.tar.gz">
	+ afp-GenClock-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-GenClock-2017-10-10.tar.gz">
	afp-GenClock-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-GenClock-2016-12-17.tar.gz">
	afp-GenClock-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-GenClock-2016-02-22.tar.gz">
	afp-GenClock-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-GenClock-2015-05-27.tar.gz">
	afp-GenClock-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-GenClock-2014-08-28.tar.gz">
	afp-GenClock-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-GenClock-2013-12-11.tar.gz">
	afp-GenClock-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-GenClock-2013-11-17.tar.gz">
	afp-GenClock-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-GenClock-2013-02-16.tar.gz">
	afp-GenClock-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-GenClock-2012-05-24.tar.gz">
	afp-GenClock-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-GenClock-2011-10-11.tar.gz">
	afp-GenClock-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-GenClock-2011-02-11.tar.gz">
	afp-GenClock-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-GenClock-2010-07-01.tar.gz">
	afp-GenClock-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-GenClock-2009-12-12.tar.gz">
	afp-GenClock-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-GenClock-2009-04-29.tar.gz">
	afp-GenClock-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-GenClock-2008-06-10.tar.gz">
	afp-GenClock-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-GenClock-2007-11-27.tar.gz">
	afp-GenClock-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-GenClock-2005-10-14.tar.gz">
	afp-GenClock-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-GenClock-2005-06-24.tar.gz">
	afp-GenClock-2005-06-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/General-Triangle.html b/web/entries/General-Triangle.html
	--- a/web/entries/General-Triangle.html
	+++ b/web/entries/General-Triangle.html
	@@ -1,228 +1,233 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The General Triangle Is Unique - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">G</font>eneral

	<font class="first">T</font>riangle

	<font class="first">I</font>s

	<font class="first">U</font>nique

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The General Triangle Is Unique</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Joachim Breitner (joachim /at/ cis /dot/ upenn /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-04-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Some acute-angled triangles are special, e.g. right-angled or isoscele triangles. Some are not of this kind, but, without measuring angles, look as if they were. In that sense, there is exactly one general triangle. This well-known fact is proven here formally.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{General-Triangle-AFP,
	author = {Joachim Breitner},
	title = {The General Triangle Is Unique},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/General-Triangle.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/General-Triangle/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/General-Triangle/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/General-Triangle/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-General-Triangle-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-General-Triangle-2018-08-16.tar.gz">
	+ afp-General-Triangle-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-General-Triangle-2017-10-10.tar.gz">
	afp-General-Triangle-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-General-Triangle-2016-12-17.tar.gz">
	afp-General-Triangle-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-General-Triangle-2016-02-22.tar.gz">
	afp-General-Triangle-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-General-Triangle-2015-05-27.tar.gz">
	afp-General-Triangle-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-General-Triangle-2014-08-28.tar.gz">
	afp-General-Triangle-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-General-Triangle-2013-12-11.tar.gz">
	afp-General-Triangle-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-General-Triangle-2013-11-17.tar.gz">
	afp-General-Triangle-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-General-Triangle-2013-02-16.tar.gz">
	afp-General-Triangle-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-General-Triangle-2012-05-24.tar.gz">
	afp-General-Triangle-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-General-Triangle-2011-10-11.tar.gz">
	afp-General-Triangle-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-General-Triangle-2011-04-01.tar.gz">
	afp-General-Triangle-2011-04-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Generic_Deriving.html b/web/entries/Generic_Deriving.html
	--- a/web/entries/Generic_Deriving.html
	+++ b/web/entries/Generic_Deriving.html
	@@ -1,184 +1,190 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Deriving generic class instances for datatypes - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>eriving

	generic

	class

	instances

	for

	datatypes

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Deriving generic class instances for datatypes</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Jonas Rädle (jonas /dot/ raedle /at/ tum /dot/ de) and
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-11-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>We provide a framework for automatically deriving instances for
	generic type classes. Our approach is inspired by Haskell's
	<i>generic-deriving</i> package and Scala's
	<i>shapeless</i> library. In addition to generating the
	code for type class functions, we also attempt to automatically prove
	type class laws for these instances. As of now, however, some manual
	proofs are still required for recursive datatypes.</p>
	<p>Note: There are already articles in the AFP that provide
	automatic instantiation for a number of classes. Concretely, <a href="https://www.isa-afp.org/entries/Deriving.html">Deriving</a> allows the automatic instantiation of comparators, linear orders, equality, and hashing. <a href="https://www.isa-afp.org/entries/Show.html">Show</a> instantiates a Haskell-style <i>show</i> class.</p><p>Our approach works for arbitrary classes (with some Isabelle/HOL overhead for each class), but a smaller set of datatypes.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Generic_Deriving-AFP,
	author = {Jonas Rädle and Lars Hupel},
	title = {Deriving generic class instances for datatypes},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Generic_Deriving.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Generic_Deriving/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Generic_Deriving/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Generic_Deriving/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Generic_Deriving-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Generic_Deriving-2018-11-21.tar.gz">
	+ afp-Generic_Deriving-2018-11-21.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/GewirthPGCProof.html b/web/entries/GewirthPGCProof.html
	--- a/web/entries/GewirthPGCProof.html
	+++ b/web/entries/GewirthPGCProof.html
	@@ -1,204 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalisation and Evaluation of Alan Gewirth's Proof for the Principle of Generic Consistency in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalisation

	and

	<font class="first">E</font>valuation

	of

	<font class="first">A</font>lan

	<font class="first">G</font>ewirth's

	<font class="first">P</font>roof

	for

	the

	<font class="first">P</font>rinciple

	of

	<font class="first">G</font>eneric

	<font class="first">C</font>onsistency

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalisation and Evaluation of Alan Gewirth's Proof for the Principle of Generic Consistency in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	David Fuenmayor (davfuenmayor /at/ gmail /dot/ com) and
	<a href="http://christoph-benzmueller.de">Christoph Benzmüller</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-10-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	An ambitious ethical theory ---Alan Gewirth's "Principle of
	Generic Consistency"--- is encoded and analysed in Isabelle/HOL.
	Gewirth's theory has stirred much attention in philosophy and
	ethics and has been proposed as a potential means to bound the impact
	of artificial general intelligence.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2019-04-09]:
	added proof for a stronger variant of the PGC and examplary inferences
	(revision 88182cb0a2f6)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{GewirthPGCProof-AFP,
	author = {David Fuenmayor and Christoph Benzmüller},
	title = {Formalisation and Evaluation of Alan Gewirth's Proof for the Principle of Generic Consistency in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/GewirthPGCProof.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GewirthPGCProof/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/GewirthPGCProof/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GewirthPGCProof/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-GewirthPGCProof-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-GewirthPGCProof-2018-10-31.tar.gz">
	+ afp-GewirthPGCProof-2018-10-31.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Girth_Chromatic.html b/web/entries/Girth_Chromatic.html
	--- a/web/entries/Girth_Chromatic.html
	+++ b/web/entries/Girth_Chromatic.html
	@@ -1,231 +1,236 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Probabilistic Proof of the Girth-Chromatic Number Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">P</font>robabilistic

	<font class="first">P</font>roof

	of

	the

	<font class="first">G</font>irth-Chromatic

	<font class="first">N</font>umber

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Probabilistic Proof of the Girth-Chromatic Number Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-02-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This works presents a formalization of the Girth-Chromatic number theorem in graph theory, stating that graphs with arbitrarily large girth and chromatic number exist. The proof uses the theory of Random Graphs to prove the existence with probabilistic arguments.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Girth_Chromatic-AFP,
	author = {Lars Noschinski},
	title = {A Probabilistic Proof of the Girth-Chromatic Number Theorem},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Girth_Chromatic.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Random_Graph_Subgraph_Threshold.html">Random_Graph_Subgraph_Threshold</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Girth_Chromatic/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Girth_Chromatic/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Girth_Chromatic/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Girth_Chromatic-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Girth_Chromatic-2018-08-16.tar.gz">
	+ afp-Girth_Chromatic-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Girth_Chromatic-2017-10-10.tar.gz">
	afp-Girth_Chromatic-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Girth_Chromatic-2016-12-17.tar.gz">
	afp-Girth_Chromatic-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Girth_Chromatic-2016-02-22.tar.gz">
	afp-Girth_Chromatic-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Girth_Chromatic-2015-05-27.tar.gz">
	afp-Girth_Chromatic-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Girth_Chromatic-2014-08-28.tar.gz">
	afp-Girth_Chromatic-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Girth_Chromatic-2013-12-11.tar.gz">
	afp-Girth_Chromatic-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Girth_Chromatic-2013-11-17.tar.gz">
	afp-Girth_Chromatic-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Girth_Chromatic-2013-02-16.tar.gz">
	afp-Girth_Chromatic-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Girth_Chromatic-2012-05-24.tar.gz">
	afp-Girth_Chromatic-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Girth_Chromatic-2012-02-06.tar.gz">
	afp-Girth_Chromatic-2012-02-06.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/GoedelGod.html b/web/entries/GoedelGod.html
	--- a/web/entries/GoedelGod.html
	+++ b/web/entries/GoedelGod.html
	@@ -1,215 +1,220 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Gödel's God in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>ödel's

	<font class="first">G</font>od

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Gödel's God in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://christoph-benzmueller.de">Christoph Benzmüller</a> and
	<a href="http://www.logic.at/staff/bruno/">Bruno Woltzenlogel Paleo</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-11-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Dana Scott's version of Gödel's proof of God's existence is formalized in quantified
	modal logic KB (QML KB).
	QML KB is modeled as a fragment of classical higher-order logic (HOL);
	thus, the formalization is essentially a formalization in HOL.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{GoedelGod-AFP,
	author = {Christoph Benzmüller and Bruno Woltzenlogel Paleo},
	title = {Gödel's God in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/GoedelGod.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GoedelGod/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/GoedelGod/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GoedelGod/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-GoedelGod-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-GoedelGod-2018-08-16.tar.gz">
	+ afp-GoedelGod-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-GoedelGod-2017-10-10.tar.gz">
	afp-GoedelGod-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-GoedelGod-2016-12-17.tar.gz">
	afp-GoedelGod-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-GoedelGod-2016-02-22.tar.gz">
	afp-GoedelGod-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-GoedelGod-2015-05-27.tar.gz">
	afp-GoedelGod-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-GoedelGod-2014-08-28.tar.gz">
	afp-GoedelGod-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-GoedelGod-2013-12-11.tar.gz">
	afp-GoedelGod-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-GoedelGod-2013-11-19.tar.gz">
	afp-GoedelGod-2013-11-19.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-GoedelGod-2013-11-18.tar.gz">
	afp-GoedelGod-2013-11-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/GraphMarkingIBP.html b/web/entries/GraphMarkingIBP.html
	--- a/web/entries/GraphMarkingIBP.html
	+++ b/web/entries/GraphMarkingIBP.html
	@@ -1,260 +1,265 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Verification of the Deutsch-Schorr-Waite Graph Marking Algorithm using Data Refinement - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erification

	of

	the

	<font class="first">D</font>eutsch-Schorr-Waite

	<font class="first">G</font>raph

	<font class="first">M</font>arking

	<font class="first">A</font>lgorithm

	using

	<font class="first">D</font>ata

	<font class="first">R</font>efinement

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Verification of the Deutsch-Schorr-Waite Graph Marking Algorithm using Data Refinement</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Viorel Preoteasa (viorel /dot/ preoteasa /at/ aalto /dot/ fi) and
	<a href="http://users.abo.fi/Ralph-Johan.Back/">Ralph-Johan Back</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-05-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The verification of the Deutsch-Schorr-Waite graph marking algorithm is used as a benchmark in many formalizations of pointer programs. The main purpose of this mechanization is to show how data refinement of invariant based programs can be used in verifying practical algorithms. The verification starts with an abstract algorithm working on a graph given by a relation <i>next</i> on nodes. Gradually the abstract program is refined into Deutsch-Schorr-Waite graph marking algorithm where only one bit per graph node of additional memory is used for marking.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2012-01-05]: Updated for the new definition of data refinement and the new syntax for demonic and angelic update statements</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{GraphMarkingIBP-AFP,
	author = {Viorel Preoteasa and Ralph-Johan Back},
	title = {Verification of the Deutsch-Schorr-Waite Graph Marking Algorithm using Data Refinement},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/GraphMarkingIBP.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="DataRefinementIBP.html">DataRefinementIBP</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GraphMarkingIBP/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/GraphMarkingIBP/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/GraphMarkingIBP/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-GraphMarkingIBP-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-GraphMarkingIBP-2018-08-16.tar.gz">
	+ afp-GraphMarkingIBP-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-GraphMarkingIBP-2017-10-10.tar.gz">
	afp-GraphMarkingIBP-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-GraphMarkingIBP-2016-12-17.tar.gz">
	afp-GraphMarkingIBP-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-GraphMarkingIBP-2016-02-22.tar.gz">
	afp-GraphMarkingIBP-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-GraphMarkingIBP-2015-05-27.tar.gz">
	afp-GraphMarkingIBP-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-GraphMarkingIBP-2014-08-28.tar.gz">
	afp-GraphMarkingIBP-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-GraphMarkingIBP-2013-12-11.tar.gz">
	afp-GraphMarkingIBP-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-GraphMarkingIBP-2013-11-17.tar.gz">
	afp-GraphMarkingIBP-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-GraphMarkingIBP-2013-02-16.tar.gz">
	afp-GraphMarkingIBP-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-GraphMarkingIBP-2012-05-24.tar.gz">
	afp-GraphMarkingIBP-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-GraphMarkingIBP-2012-03-15.tar.gz">
	afp-GraphMarkingIBP-2012-03-15.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-GraphMarkingIBP-2011-10-11.tar.gz">
	afp-GraphMarkingIBP-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-GraphMarkingIBP-2011-02-11.tar.gz">
	afp-GraphMarkingIBP-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-GraphMarkingIBP-2010-07-01.tar.gz">
	afp-GraphMarkingIBP-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-GraphMarkingIBP-2010-05-28.tar.gz">
	afp-GraphMarkingIBP-2010-05-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Graph_Saturation.html b/web/entries/Graph_Saturation.html
	--- a/web/entries/Graph_Saturation.html
	+++ b/web/entries/Graph_Saturation.html
	@@ -1,174 +1,180 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Graph Saturation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>raph

	<font class="first">S</font>aturation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Graph Saturation</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Sebastiaan J. C. Joosten
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-11-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This is an Isabelle/HOL formalisation of graph saturation, closely
	following a <a href="https://doi.org/10.1016/j.jlamp.2018.06.005">paper by the author</a> on graph saturation.
	Nine out of ten lemmas of the original paper are proven in this
	formalisation. The formalisation additionally includes two theorems
	that show the main premise of the paper: that consistency and
	entailment are decided through graph saturation. This formalisation
	does not give executable code, and it did not implement any of the
	optimisations suggested in the paper.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Graph_Saturation-AFP,
	author = {Sebastiaan J. C. Joosten},
	title = {Graph Saturation},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Graph_Saturation.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Graph_Saturation/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Graph_Saturation/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Graph_Saturation/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Graph_Saturation-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Graph_Saturation-2018-11-28.tar.gz">
	+ afp-Graph_Saturation-2018-11-28.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Graph_Theory.html b/web/entries/Graph_Theory.html
	--- a/web/entries/Graph_Theory.html
	+++ b/web/entries/Graph_Theory.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Graph Theory - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>raph

	<font class="first">T</font>heory

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Graph Theory</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-04-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This development provides a formalization of directed graphs, supporting (labelled) multi-edges and infinite graphs. A polymorphic edge type allows edges to be treated as pairs of vertices, if multi-edges are not required. Formalized properties are i.a. walks (and related concepts), connectedness and subgraphs and basic properties of isomorphisms.
	<p>
	This formalization is used to prove characterizations of Euler Trails, Shortest Paths and Kuratowski subgraphs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Graph_Theory-AFP,
	author = {Lars Noschinski},
	title = {Graph Theory},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Graph_Theory.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Parity_Game.html">Parity_Game</a>, <a href="Planarity_Certificates.html">Planarity_Certificates</a>, <a href="ShortestPath.html">ShortestPath</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Graph_Theory/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Graph_Theory/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Graph_Theory/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Graph_Theory-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Graph_Theory-2018-08-16.tar.gz">
	+ afp-Graph_Theory-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Graph_Theory-2017-10-10.tar.gz">
	afp-Graph_Theory-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Graph_Theory-2016-12-17.tar.gz">
	afp-Graph_Theory-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Graph_Theory-2016-02-22.tar.gz">
	afp-Graph_Theory-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Graph_Theory-2015-05-27.tar.gz">
	afp-Graph_Theory-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Graph_Theory-2014-08-28.tar.gz">
	afp-Graph_Theory-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Graph_Theory-2013-12-11.tar.gz">
	afp-Graph_Theory-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Graph_Theory-2013-11-17.tar.gz">
	afp-Graph_Theory-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Graph_Theory-2013-05-02.tar.gz">
	afp-Graph_Theory-2013-05-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Green.html b/web/entries/Green.html
	--- a/web/entries/Green.html
	+++ b/web/entries/Green.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>An Isabelle/HOL formalisation of Green's Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>n

	<font class="first">I</font>sabelle/HOL

	formalisation

	of

	<font class="first">G</font>reen's

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">An Isabelle/HOL formalisation of Green's Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://home.in.tum.de/~mansour/">Mohammad Abdulaziz</a> and
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-01-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalise a statement of Green’s theorem—the first formalisation to
	our knowledge—in Isabelle/HOL. The theorem statement that we formalise
	is enough for most applications, especially in physics and
	engineering. Our formalisation is made possible by a novel proof that
	avoids the ubiquitous line integral cancellation argument. This
	eliminates the need to formalise orientations and region boundaries
	explicitly with respect to the outwards-pointing normal vector.
	Instead we appeal to a homological argument about equivalences between
	paths.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Green-AFP,
	author = {Mohammad Abdulaziz and Lawrence C. Paulson},
	title = {An Isabelle/HOL formalisation of Green's Theorem},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Green.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Green/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Green/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Green/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Green-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Green-2018-08-16.tar.gz">
	+ afp-Green-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Green-2018-01-12.tar.gz">
	afp-Green-2018-01-12.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Groebner_Bases.html b/web/entries/Groebner_Bases.html
	--- a/web/entries/Groebner_Bases.html
	+++ b/web/entries/Groebner_Bases.html
	@@ -1,203 +1,208 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Gröbner Bases Theory - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>röbner

	<font class="first">B</font>ases

	<font class="first">T</font>heory

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Gröbner Bases Theory</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a> and
	<a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This formalization is concerned with the theory of Gröbner bases in
	(commutative) multivariate polynomial rings over fields, originally
	developed by Buchberger in his 1965 PhD thesis. Apart from the
	statement and proof of the main theorem of the theory, the
	formalization also implements Buchberger's algorithm for actually
	computing Gröbner bases as a tail-recursive function, thus allowing to
	effectively decide ideal membership in finitely generated polynomial
	ideals. Furthermore, all functions can be executed on a concrete
	representation of multivariate polynomials as association lists.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2019-04-18]: Specialized Gröbner bases to less abstract representation of polynomials, where
	power-products are represented as polynomial mappings.<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Groebner_Bases-AFP,
	author = {Fabian Immler and Alexander Maletzky},
	title = {Gröbner Bases Theory},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Groebner_Bases.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Deriving.html">Deriving</a>, <a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a>, <a href="Polynomials.html">Polynomials</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	- <td class="data"><a href="Signature_Groebner.html">Signature_Groebner</a> </td></tr>
	+ <td class="data"><a href="Groebner_Macaulay.html">Groebner_Macaulay</a>, <a href="Nullstellensatz.html">Nullstellensatz</a>, <a href="Signature_Groebner.html">Signature_Groebner</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Groebner_Bases/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Groebner_Bases/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Groebner_Bases/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Groebner_Bases-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Groebner_Bases-2018-08-16.tar.gz">
	+ afp-Groebner_Bases-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Groebner_Bases-2017-10-10.tar.gz">
	afp-Groebner_Bases-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Groebner_Bases-2016-12-17.tar.gz">
	afp-Groebner_Bases-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Groebner_Bases-2016-05-02.tar.gz">
	afp-Groebner_Bases-2016-05-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Groebner_Macaulay.html b/web/entries/Groebner_Macaulay.html
	new file mode 100644
	--- /dev/null
	+++ b/web/entries/Groebner_Macaulay.html
	@@ -0,0 +1,192 @@
	+<!DOCTYPE html>
	+<html lang="en">
	+<head>
	+<meta charset="utf-8">
	+<title>Gröbner Bases, Macaulay Matrices and Dubé's Degree Bounds - Archive of Formal Proofs
	+</title>
	+<link rel="stylesheet" type="text/css" href="../front.css">
	+<link rel="icon" href="../images/favicon.ico" type="image/icon">
	+<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	+</head>
	+
	+<body>
	+
	+<table width="100%">
	+<tbody>
	+<tr>
	+
	+<!-- Navigation -->
	+<td width="20%" align="center" valign="top">
	+ <p> </p>
	+ <a href="http://isabelle.in.tum.de">
	+ <img src="../images/isabelle.png" width="100" height="86" border=0>
	+ </a>
	+ <p> </p>
	+ <p> </p>
	+ <table class="nav" width="80%">
	+ <tr>
	+ <td class="nav" width="100%"><a href="../index.html">Home</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../about.html">About</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../submitting.html">Submission</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../updating.html">Updating Entries</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../using.html">Using Entries</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../search.html">Search</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../statistics.html">Statistics</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../topics.html">Index</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../download.html">Download</a></td>
	+ </tr>
	+ </table>
	+ <p> </p>
	+ <p> </p>
	+</td>
	+
	+
	+<!-- Content -->
	+<td width="80%" valign="top">
	+<div align="center">
	+ <p> </p>
	+ <h1> <font class="first">G</font>röbner
	+
	+ <font class="first">B</font>ases,
	+
	+ <font class="first">M</font>acaulay
	+
	+ <font class="first">M</font>atrices
	+
	+ and
	+
	+ <font class="first">D</font>ubé's
	+
	+ <font class="first">D</font>egree
	+
	+ <font class="first">B</font>ounds
	+
	+</h1>
	+ <p> </p>
	+
	+<table width="80%" class="data">
	+<tbody>
	+<tr>
	+ <td class="datahead" width="20%">Title:</td>
	+ <td class="data" width="80%">Gröbner Bases, Macaulay Matrices and Dubé's Degree Bounds</td>
	+</tr>
	+
	+<tr>
	+ <td class="datahead">
	+ Author:
	+ </td>
	+ <td class="data">
	+ <a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>
	+ </td>
	+</tr>
	+
	+
	+
	+<tr>
	+ <td class="datahead">Submission date:</td>
	+ <td class="data">2019-06-15</td>
	+</tr>
	+
	+<tr>
	+ <td class="datahead" valign="top">Abstract:</td>
	+ <td class="abstract">
	+This entry formalizes the connection between Gröbner bases and
	+Macaulay matrices (sometimes also referred to as `generalized
	+Sylvester matrices'). In particular, it contains a method for
	+computing Gröbner bases, which proceeds by first constructing some
	+Macaulay matrix of the initial set of polynomials, then row-reducing
	+this matrix, and finally converting the result back into a set of
	+polynomials. The output is shown to be a Gröbner basis if the Macaulay
	+matrix constructed in the first step is sufficiently large. In order
	+to obtain concrete upper bounds on the size of the matrix (and hence
	+turn the method into an effectively executable algorithm), Dubé's
	+degree bounds on Gröbner bases are utilized; consequently, they are
	+also part of the formalization.</td>
	+</tr>
	+
	+
	+<tr>
	+ <td class="datahead" valign="top">BibTeX:</td>
	+ <td class="formatted">
	+ <pre>@article{Groebner_Macaulay-AFP,
	+ author = {Alexander Maletzky},
	+ title = {Gröbner Bases, Macaulay Matrices and Dubé's Degree Bounds},
	+ journal = {Archive of Formal Proofs},
	+ month = jun,
	+ year = 2019,
	+ note = {\url{http://isa-afp.org/entries/Groebner_Macaulay.html},
	+ Formal proof development},
	+ ISSN = {2150-914x},
	+}</pre>
	+ </td>
	+</tr>
	+
	+ <tr><td class="datahead">License:</td>
	+ <td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>
	+
	+
	+ <tr><td class="datahead">Depends on:</td>
	+ <td class="data"><a href="Groebner_Bases.html">Groebner_Bases</a> </td></tr>
	+
	+
	+
	+
	+ </tbody>
	+</table>
	+
	+<p></p>
	+
	+<table class="links">
	+ <tbody>
	+ <tr>
	+ <td class="links">
	+ <a href="../browser_info/current/AFP/Groebner_Macaulay/outline.pdf">Proof outline</a><br>
	+ <a href="../browser_info/current/AFP/Groebner_Macaulay/document.pdf">Proof document</a>
	+ </td>
	+ </tr>
	+ <tr>
	+ <td class="links">
	+ <a href="../browser_info/current/AFP/Groebner_Macaulay/index.html">Browse theories</a>
	+ </td></tr>
	+ <tr>
	+ <td class="links">
	+ <a href="../release/afp-Groebner_Macaulay-current.tar.gz">Download this entry</a>
	+ </td>
	+ </tr>
	+
	+
	+ <tr><td class="links">Older releases:
	+ None
	+ </td></tr>
	+
	+ </tbody>
	+</table>
	+
	+</div>
	+</td>
	+
	+</tr>
	+</tbody>
	+</table>
	+
	+<script src="../jquery.min.js"></script>
	+<script src="../script.js"></script>
	+
	+</body>
	+</html>
	\ No newline at end of file
	diff --git a/web/entries/Gromov_Hyperbolicity.html b/web/entries/Gromov_Hyperbolicity.html
	--- a/web/entries/Gromov_Hyperbolicity.html
	+++ b/web/entries/Gromov_Hyperbolicity.html
	@@ -1,186 +1,192 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Gromov Hyperbolicity - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>romov

	<font class="first">H</font>yperbolicity

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Gromov Hyperbolicity</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Sebastien Gouezel
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-01-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	A geodesic metric space is Gromov hyperbolic if all its geodesic
	triangles are thin, i.e., every side is contained in a fixed
	thickening of the two other sides. While this definition looks
	innocuous, it has proved extremely important and versatile in modern
	geometry since its introduction by Gromov. We formalize the basic
	classical properties of Gromov hyperbolic spaces, notably the Morse
	lemma asserting that quasigeodesics are close to geodesics, the
	invariance of hyperbolicity under quasi-isometries, we define and
	study the Gromov boundary and its associated distance, and prove that
	a quasi-isometry between Gromov hyperbolic spaces extends to a
	homeomorphism of the boundaries. We also prove a less classical
	theorem, by Bonk and Schramm, asserting that a Gromov hyperbolic space
	embeds isometrically in a geodesic Gromov-hyperbolic space. As the
	original proof uses a transfinite sequence of Cauchy completions, this
	is an interesting formalization exercise. Along the way, we introduce
	basic material on isometries, quasi-isometries, Lipschitz maps,
	geodesic spaces, the Hausdorff distance, the Cauchy completion of a
	metric space, and the exponential on extended real numbers.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Gromov_Hyperbolicity-AFP,
	author = {Sebastien Gouezel},
	title = {Gromov Hyperbolicity},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Gromov_Hyperbolicity.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Ergodic_Theory.html">Ergodic_Theory</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Gromov_Hyperbolicity/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Gromov_Hyperbolicity/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Gromov_Hyperbolicity/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Gromov_Hyperbolicity-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Gromov_Hyperbolicity-2018-08-16.tar.gz">
	+ afp-Gromov_Hyperbolicity-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Group-Ring-Module.html b/web/entries/Group-Ring-Module.html
	--- a/web/entries/Group-Ring-Module.html
	+++ b/web/entries/Group-Ring-Module.html
	@@ -1,280 +1,285 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Groups, Rings and Modules - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>roups,

	<font class="first">R</font>ings

	and

	<font class="first">M</font>odules

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Groups, Rings and Modules</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Hidetsune Kobayashi,
	L. Chen and
	H. Murao
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-05-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The theory of groups, rings and modules is developed to a great depth. Group theory results include Zassenhaus's theorem and the Jordan-Hoelder theorem. The ring theory development includes ideals, quotient rings and the Chinese remainder theorem. The module development includes the Nakayama lemma, exact sequences and Tensor products.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Group-Ring-Module-AFP,
	author = {Hidetsune Kobayashi and L. Chen and H. Murao},
	title = {Groups, Rings and Modules},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Group-Ring-Module.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Valuation.html">Valuation</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Group-Ring-Module/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Group-Ring-Module/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Group-Ring-Module/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Group-Ring-Module-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Group-Ring-Module-2018-08-16.tar.gz">
	+ afp-Group-Ring-Module-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Group-Ring-Module-2017-10-10.tar.gz">
	afp-Group-Ring-Module-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Group-Ring-Module-2016-12-17.tar.gz">
	afp-Group-Ring-Module-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Group-Ring-Module-2016-02-22.tar.gz">
	afp-Group-Ring-Module-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Group-Ring-Module-2015-05-27.tar.gz">
	afp-Group-Ring-Module-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Group-Ring-Module-2014-08-28.tar.gz">
	afp-Group-Ring-Module-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Group-Ring-Module-2013-12-11.tar.gz">
	afp-Group-Ring-Module-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Group-Ring-Module-2013-11-17.tar.gz">
	afp-Group-Ring-Module-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Group-Ring-Module-2013-03-02.tar.gz">
	afp-Group-Ring-Module-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Group-Ring-Module-2013-02-16.tar.gz">
	afp-Group-Ring-Module-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Group-Ring-Module-2012-05-24.tar.gz">
	afp-Group-Ring-Module-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Group-Ring-Module-2011-10-11.tar.gz">
	afp-Group-Ring-Module-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Group-Ring-Module-2011-02-11.tar.gz">
	afp-Group-Ring-Module-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Group-Ring-Module-2010-07-01.tar.gz">
	afp-Group-Ring-Module-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Group-Ring-Module-2009-12-12.tar.gz">
	afp-Group-Ring-Module-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Group-Ring-Module-2009-04-30.tar.gz">
	afp-Group-Ring-Module-2009-04-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Group-Ring-Module-2009-04-29.tar.gz">
	afp-Group-Ring-Module-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Group-Ring-Module-2008-06-10.tar.gz">
	afp-Group-Ring-Module-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Group-Ring-Module-2007-11-27.tar.gz">
	afp-Group-Ring-Module-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Group-Ring-Module-2005-10-14.tar.gz">
	afp-Group-Ring-Module-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Group-Ring-Module-2004-05-20.tar.gz">
	afp-Group-Ring-Module-2004-05-20.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Group-Ring-Module-2004-05-19.tar.gz">
	afp-Group-Ring-Module-2004-05-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/HOL-CSP.html b/web/entries/HOL-CSP.html
	--- a/web/entries/HOL-CSP.html
	+++ b/web/entries/HOL-CSP.html
	@@ -1,183 +1,189 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>HOL-CSP Version 2.0 - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>OL-CSP

	<font class="first">V</font>ersion

	<font class="first">2</font>.0

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">HOL-CSP Version 2.0</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Safouan Taha (safouan /dot/ taha /at/ lri /dot/ fr),
	Lina Ye (lina /dot/ ye /at/ lri /dot/ fr) and
	Burkhart Wolff (wolff /at/ lri /dot/ fr)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-04-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This is a complete formalization of the work of Hoare and Roscoe on
	the denotational semantics of the Failure/Divergence Model of CSP. It
	follows essentially the presentation of CSP in Roscoe’s Book ”Theory
	and Practice of Concurrency” [8] and the semantic details in a joint
	Paper of Roscoe and Brooks ”An improved failures model for
	communicating processes". The present work is based on a prior
	formalization attempt, called HOL-CSP 1.0, done in 1997 by H. Tej and
	B. Wolff with the Isabelle proof technology available at that time.
	This work revealed minor, but omnipresent foundational errors in key
	concepts like the process invariant. The present version HOL-CSP
	profits from substantially improved libraries (notably HOLCF),
	improved automated proof techniques, and structured proof techniques
	in Isar and is substantially shorter but more complete.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{HOL-CSP-AFP,
	author = {Safouan Taha and Lina Ye and Burkhart Wolff},
	title = {HOL-CSP Version 2.0},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/HOL-CSP.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HOL-CSP/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/HOL-CSP/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HOL-CSP/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-HOL-CSP-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-HOL-CSP-2019-04-29.tar.gz">
	+ afp-HOL-CSP-2019-04-29.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/HOLCF-Prelude.html b/web/entries/HOLCF-Prelude.html
	--- a/web/entries/HOLCF-Prelude.html
	+++ b/web/entries/HOLCF-Prelude.html
	@@ -1,185 +1,190 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>HOLCF-Prelude - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>OLCF-Prelude

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">HOLCF-Prelude</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Joachim Breitner (joachim /at/ cis /dot/ upenn /dot/ edu),
	Brian Huffman,
	Neil Mitchell and
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-07-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The Isabelle/HOLCF-Prelude is a formalization of a large part of
	Haskell's standard prelude in Isabelle/HOLCF. We use it to prove
	the correctness of the Eratosthenes' Sieve, in its
	self-referential implementation commonly used to showcase
	Haskell's laziness; prove correctness of GHC's
	"fold/build" rule and related rewrite rules; and certify a
	number of hints suggested by HLint.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{HOLCF-Prelude-AFP,
	author = {Joachim Breitner and Brian Huffman and Neil Mitchell and Christian Sternagel},
	title = {HOLCF-Prelude},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/HOLCF-Prelude.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HOLCF-Prelude/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/HOLCF-Prelude/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HOLCF-Prelude/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-HOLCF-Prelude-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-HOLCF-Prelude-2018-08-16.tar.gz">
	+ afp-HOLCF-Prelude-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-HOLCF-Prelude-2017-10-10.tar.gz">
	afp-HOLCF-Prelude-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-HOLCF-Prelude-2017-07-15.tar.gz">
	afp-HOLCF-Prelude-2017-07-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/HRB-Slicing.html b/web/entries/HRB-Slicing.html
	--- a/web/entries/HRB-Slicing.html
	+++ b/web/entries/HRB-Slicing.html
	@@ -1,255 +1,260 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Backing up Slicing: Verifying the Interprocedural Two-Phase Horwitz-Reps-Binkley Slicer - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>acking

	up

	<font class="first">S</font>licing:

	<font class="first">V</font>erifying

	the

	<font class="first">I</font>nterprocedural

	<font class="first">T</font>wo-Phase

	<font class="first">H</font>orwitz-Reps-Binkley

	<font class="first">S</font>licer

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Backing up Slicing: Verifying the Interprocedural Two-Phase Horwitz-Reps-Binkley Slicer</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-11-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">After verifying <a href="Slicing.html">dynamic and static interprocedural slicing</a>, we present a modular framework for static interprocedural slicing. To this end, we formalized the standard two-phase slicer from Horwitz, Reps and Binkley (see their TOPLAS 12(1) 1990 paper) together with summary edges as presented by Reps et al. (see FSE 1994). The framework is again modular in the programming language by using an abstract CFG, defined via structural and well-formedness properties. Using a weak simulation between the original and sliced graph, we were able to prove the correctness of static interprocedural slicing. We also instantiate our framework with a simple While language with procedures. This shows that the chosen abstractions are indeed valid.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{HRB-Slicing-AFP,
	author = {Daniel Wasserrab},
	title = {Backing up Slicing: Verifying the Interprocedural Two-Phase Horwitz-Reps-Binkley Slicer},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/HRB-Slicing.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Jinja.html">Jinja</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="InformationFlowSlicing_Inter.html">InformationFlowSlicing_Inter</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HRB-Slicing/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/HRB-Slicing/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HRB-Slicing/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-HRB-Slicing-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-HRB-Slicing-2018-08-16.tar.gz">
	+ afp-HRB-Slicing-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-HRB-Slicing-2017-10-10.tar.gz">
	afp-HRB-Slicing-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-HRB-Slicing-2016-12-17.tar.gz">
	afp-HRB-Slicing-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-HRB-Slicing-2016-02-22.tar.gz">
	afp-HRB-Slicing-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-HRB-Slicing-2015-05-27.tar.gz">
	afp-HRB-Slicing-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-HRB-Slicing-2014-08-28.tar.gz">
	afp-HRB-Slicing-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-HRB-Slicing-2013-12-11.tar.gz">
	afp-HRB-Slicing-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-HRB-Slicing-2013-11-17.tar.gz">
	afp-HRB-Slicing-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-HRB-Slicing-2013-02-16.tar.gz">
	afp-HRB-Slicing-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-HRB-Slicing-2012-05-24.tar.gz">
	afp-HRB-Slicing-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-HRB-Slicing-2011-10-11.tar.gz">
	afp-HRB-Slicing-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-HRB-Slicing-2011-02-11.tar.gz">
	afp-HRB-Slicing-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-HRB-Slicing-2010-07-01.tar.gz">
	afp-HRB-Slicing-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-HRB-Slicing-2009-12-12.tar.gz">
	afp-HRB-Slicing-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-HRB-Slicing-2009-11-19.tar.gz">
	afp-HRB-Slicing-2009-11-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Heard_Of.html b/web/entries/Heard_Of.html
	--- a/web/entries/Heard_Of.html
	+++ b/web/entries/Heard_Of.html
	@@ -1,259 +1,264 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Verifying Fault-Tolerant Distributed Algorithms in the Heard-Of Model - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erifying

	<font class="first">F</font>ault-Tolerant

	<font class="first">D</font>istributed

	<font class="first">A</font>lgorithms

	in

	the

	<font class="first">H</font>eard-Of

	<font class="first">M</font>odel

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Verifying Fault-Tolerant Distributed Algorithms in the Heard-Of Model</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Henri Debrat (henri /dot/ debrat /at/ loria /dot/ fr) and
	<a href="http://www.loria.fr/~merz">Stephan Merz</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-07-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Distributed computing is inherently based on replication, promising
	increased tolerance to failures of individual computing nodes or
	communication channels. Realizing this promise, however, involves
	quite subtle algorithmic mechanisms, and requires precise statements
	about the kinds and numbers of faults that an algorithm tolerates (such
	as process crashes, communication faults or corrupted values). The
	landmark theorem due to Fischer, Lynch, and Paterson shows that it is
	impossible to achieve Consensus among N asynchronously communicating
	nodes in the presence of even a single permanent failure. Existing
	solutions must rely on assumptions of "partial synchrony".
	<p>
	Indeed, there have been numerous misunderstandings on what exactly a given
	algorithm is supposed to realize in what kinds of environments. Moreover, the
	abundance of subtly different computational models complicates comparisons
	between different algorithms. Charron-Bost and Schiper introduced the Heard-Of
	model for representing algorithms and failure assumptions in a uniform
	framework, simplifying comparisons between algorithms.
	<p>
	In this contribution, we represent the Heard-Of model in Isabelle/HOL. We define
	two semantics of runs of algorithms with different unit of atomicity and relate
	these through a reduction theorem that allows us to verify algorithms in the
	coarse-grained semantics (where proofs are easier) and infer their correctness
	for the fine-grained one (which corresponds to actual executions). We
	instantiate the framework by verifying six Consensus algorithms that differ in
	the underlying algorithmic mechanisms and the kinds of faults they tolerate.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Heard_Of-AFP,
	author = {Henri Debrat and Stephan Merz},
	title = {Verifying Fault-Tolerant Distributed Algorithms in the Heard-Of Model},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Heard_Of.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Stuttering_Equivalence.html">Stuttering_Equivalence</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Consensus_Refined.html">Consensus_Refined</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Heard_Of/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Heard_Of/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Heard_Of/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Heard_Of-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Heard_Of-2018-08-16.tar.gz">
	+ afp-Heard_Of-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Heard_Of-2017-10-10.tar.gz">
	afp-Heard_Of-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Heard_Of-2016-12-17.tar.gz">
	afp-Heard_Of-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Heard_Of-2016-02-22.tar.gz">
	afp-Heard_Of-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Heard_Of-2015-05-27.tar.gz">
	afp-Heard_Of-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Heard_Of-2014-08-28.tar.gz">
	afp-Heard_Of-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Heard_Of-2013-12-11.tar.gz">
	afp-Heard_Of-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Heard_Of-2013-11-17.tar.gz">
	afp-Heard_Of-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Heard_Of-2013-03-02.tar.gz">
	afp-Heard_Of-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Heard_Of-2013-02-16.tar.gz">
	afp-Heard_Of-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Heard_Of-2012-07-30.tar.gz">
	afp-Heard_Of-2012-07-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/HereditarilyFinite.html b/web/entries/HereditarilyFinite.html
	--- a/web/entries/HereditarilyFinite.html
	+++ b/web/entries/HereditarilyFinite.html
	@@ -1,220 +1,225 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Hereditarily Finite Sets - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">H</font>ereditarily

	<font class="first">F</font>inite

	<font class="first">S</font>ets

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Hereditarily Finite Sets</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-11-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The theory of hereditarily finite sets is formalised, following
	the <a href="http://journals.impan.gov.pl/dm/Inf/422-0-1.html">development</a> of Swierczkowski.
	An HF set is a finite collection of other HF sets; they enjoy an induction principle
	and satisfy all the axioms of ZF set theory apart from the axiom of infinity, which is negated.
	All constructions that are possible in ZF set theory (Cartesian products, disjoint sums, natural numbers,
	functions) without using infinite sets are possible here.
	The definition of addition for the HF sets follows Kirby.
	This development forms the foundation for the Isabelle proof of Gödel's incompleteness theorems,
	which has been <a href="Incompleteness.html">formalised separately</a>.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-02-23]: Added the theory "Finitary" defining the class of types that can be embedded in hf, including int, char, option, list, etc.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{HereditarilyFinite-AFP,
	author = {Lawrence C. Paulson},
	title = {The Hereditarily Finite Sets},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/HereditarilyFinite.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Finite_Automata_HF.html">Finite_Automata_HF</a>, <a href="Incompleteness.html">Incompleteness</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HereditarilyFinite/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/HereditarilyFinite/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HereditarilyFinite/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-HereditarilyFinite-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-HereditarilyFinite-2018-08-16.tar.gz">
	+ afp-HereditarilyFinite-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-HereditarilyFinite-2017-10-10.tar.gz">
	afp-HereditarilyFinite-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-HereditarilyFinite-2016-12-17.tar.gz">
	afp-HereditarilyFinite-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-HereditarilyFinite-2016-02-22.tar.gz">
	afp-HereditarilyFinite-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-HereditarilyFinite-2015-05-27.tar.gz">
	afp-HereditarilyFinite-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-HereditarilyFinite-2014-08-28.tar.gz">
	afp-HereditarilyFinite-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-HereditarilyFinite-2013-12-11.tar.gz">
	afp-HereditarilyFinite-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-HereditarilyFinite-2013-11-17.tar.gz">
	afp-HereditarilyFinite-2013-11-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Hermite.html b/web/entries/Hermite.html
	--- a/web/entries/Hermite.html
	+++ b/web/entries/Hermite.html
	@@ -1,192 +1,197 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Hermite Normal Form - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>ermite

	<font class="first">N</font>ormal

	<font class="first">F</font>orm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Hermite Normal Form</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a> and
	<a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-07-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Hermite Normal Form is a canonical matrix analogue of Reduced Echelon Form, but involving matrices over more general rings. In this work we formalise an algorithm to compute the Hermite Normal Form of a matrix by means of elementary row operations, taking advantage of the Echelon Form AFP entry. We have proven the correctness of such an algorithm and refined it to immutable arrays. Furthermore, we have also formalised the uniqueness of the Hermite Normal Form of a matrix. Code can be exported and some examples of execution involving integer matrices and polynomial matrices are presented as well.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Hermite-AFP,
	author = {Jose Divasón and Jesús Aransay},
	title = {Hermite Normal Form},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Hermite.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Echelon_Form.html">Echelon_Form</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Hermite/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Hermite/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Hermite/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Hermite-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Hermite-2018-08-16.tar.gz">
	+ afp-Hermite-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Hermite-2017-10-10.tar.gz">
	afp-Hermite-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Hermite-2016-12-17.tar.gz">
	afp-Hermite-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Hermite-2016-02-22.tar.gz">
	afp-Hermite-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Hermite-2015-07-07.tar.gz">
	afp-Hermite-2015-07-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Hidden_Markov_Models.html b/web/entries/Hidden_Markov_Models.html
	--- a/web/entries/Hidden_Markov_Models.html
	+++ b/web/entries/Hidden_Markov_Models.html
	@@ -1,186 +1,191 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Hidden Markov Models - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>idden

	<font class="first">M</font>arkov

	<font class="first">M</font>odels

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Hidden Markov Models</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-05-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry contains a formalization of hidden Markov models [3] based
	on Johannes Hölzl's formalization of discrete time Markov chains
	[1]. The basic definitions are provided and the correctness of two
	main (dynamic programming) algorithms for hidden Markov models is
	proved: the forward algorithm for computing the likelihood of an
	observed sequence, and the Viterbi algorithm for decoding the most
	probable hidden state sequence. The Viterbi algorithm is made
	executable including memoization. Hidden markov models have various
	applications in natural language processing. For an introduction see
	Jurafsky and Martin [2].</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Hidden_Markov_Models-AFP,
	author = {Simon Wimmer},
	title = {Hidden Markov Models},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Hidden_Markov_Models.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Markov_Models.html">Markov_Models</a>, <a href="Monad_Memo_DP.html">Monad_Memo_DP</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Hidden_Markov_Models/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Hidden_Markov_Models/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Hidden_Markov_Models/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Hidden_Markov_Models-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Hidden_Markov_Models-2018-08-16.tar.gz">
	+ afp-Hidden_Markov_Models-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Hidden_Markov_Models-2018-05-25.tar.gz">
	afp-Hidden_Markov_Models-2018-05-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Higher_Order_Terms.html b/web/entries/Higher_Order_Terms.html
	--- a/web/entries/Higher_Order_Terms.html
	+++ b/web/entries/Higher_Order_Terms.html
	@@ -1,195 +1,201 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>An Algebra for Higher-Order Terms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>n

	<font class="first">A</font>lgebra

	for

	<font class="first">H</font>igher-Order

	<font class="first">T</font>erms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">An Algebra for Higher-Order Terms</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	Yu Zhang
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-01-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	In this formalization, I introduce a higher-order term algebra,
	generalizing the notions of free variables, matching, and
	substitution. The need arose from the work on a <a
	href="http://dx.doi.org/10.1007/978-3-319-89884-1_35">verified
	compiler from Isabelle to CakeML</a>. Terms can be thought of as
	consisting of a generic (free variables, constants, application) and
	a specific part. As example applications, this entry provides
	instantiations for de-Bruijn terms, terms with named variables, and
	<a
	href="https://www.isa-afp.org/entries/Lambda_Free_RPOs.html">Blanchette’s
	λ-free higher-order terms</a>. Furthermore, I
	implement translation functions between de-Bruijn terms and named
	terms and prove their correctness.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Higher_Order_Terms-AFP,
	author = {Lars Hupel},
	title = {An Algebra for Higher-Order Terms},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Higher_Order_Terms.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Datatype_Order_Generator.html">Datatype_Order_Generator</a>, <a href="Lambda_Free_RPOs.html">Lambda_Free_RPOs</a>, <a href="List-Index.html">List-Index</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Higher_Order_Terms/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Higher_Order_Terms/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Higher_Order_Terms/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Higher_Order_Terms-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Higher_Order_Terms-2019-01-15.tar.gz">
	+ afp-Higher_Order_Terms-2019-01-15.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Hoare_Time.html b/web/entries/Hoare_Time.html
	--- a/web/entries/Hoare_Time.html
	+++ b/web/entries/Hoare_Time.html
	@@ -1,192 +1,197 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Hoare Logics for Time Bounds - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>oare

	<font class="first">L</font>ogics

	for

	<font class="first">T</font>ime

	<font class="first">B</font>ounds

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Hoare Logics for Time Bounds</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.in.tum.de/~haslbema">Maximilian P. L. Haslbeck</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-02-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We study three different Hoare logics for reasoning about time bounds
	of imperative programs and formalize them in Isabelle/HOL: a classical
	Hoare like logic due to Nielson, a logic with potentials due to
	Carbonneaux <i>et al.</i> and a <i>separation
	logic</i> following work by Atkey, Chaguérand and Pottier.
	These logics are formally shown to be sound and complete. Verification
	condition generators are developed and are shown sound and complete
	too. We also consider variants of the systems where we abstract from
	multiplicative constants in the running time bounds, thus supporting a
	big-O style of reasoning. Finally we compare the expressive power of
	the three systems.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Hoare_Time-AFP,
	author = {Maximilian P. L. Haslbeck and Tobias Nipkow},
	title = {Hoare Logics for Time Bounds},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Hoare_Time.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Separation_Algebra.html">Separation_Algebra</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Hoare_Time/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Hoare_Time/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Hoare_Time/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Hoare_Time-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Hoare_Time-2018-08-16.tar.gz">
	+ afp-Hoare_Time-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Hoare_Time-2018-02-26.tar.gz">
	afp-Hoare_Time-2018-02-26.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/HotelKeyCards.html b/web/entries/HotelKeyCards.html
	--- a/web/entries/HotelKeyCards.html
	+++ b/web/entries/HotelKeyCards.html
	@@ -1,251 +1,256 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Hotel Key Card System - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>otel

	<font class="first">K</font>ey

	<font class="first">C</font>ard

	<font class="first">S</font>ystem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Hotel Key Card System</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2006-09-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Two models of an electronic hotel key card system are contrasted: a state based and a trace based one. Both are defined, verified, and proved equivalent in the theorem prover Isabelle/HOL. It is shown that if a guest follows a certain safety policy regarding her key cards, she can be sure that nobody but her can enter her room.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{HotelKeyCards-AFP,
	author = {Tobias Nipkow},
	title = {Hotel Key Card System},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2006,
	note = {\url{http://isa-afp.org/entries/HotelKeyCards.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HotelKeyCards/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/HotelKeyCards/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HotelKeyCards/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-HotelKeyCards-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-HotelKeyCards-2018-08-16.tar.gz">
	+ afp-HotelKeyCards-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-HotelKeyCards-2017-10-10.tar.gz">
	afp-HotelKeyCards-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-HotelKeyCards-2016-12-17.tar.gz">
	afp-HotelKeyCards-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-HotelKeyCards-2016-02-22.tar.gz">
	afp-HotelKeyCards-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-HotelKeyCards-2015-05-27.tar.gz">
	afp-HotelKeyCards-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-HotelKeyCards-2014-08-28.tar.gz">
	afp-HotelKeyCards-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-HotelKeyCards-2013-12-11.tar.gz">
	afp-HotelKeyCards-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-HotelKeyCards-2013-11-17.tar.gz">
	afp-HotelKeyCards-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-HotelKeyCards-2013-02-16.tar.gz">
	afp-HotelKeyCards-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-HotelKeyCards-2012-05-24.tar.gz">
	afp-HotelKeyCards-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-HotelKeyCards-2011-10-11.tar.gz">
	afp-HotelKeyCards-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-HotelKeyCards-2011-02-11.tar.gz">
	afp-HotelKeyCards-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-HotelKeyCards-2010-07-01.tar.gz">
	afp-HotelKeyCards-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-HotelKeyCards-2009-12-12.tar.gz">
	afp-HotelKeyCards-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-HotelKeyCards-2009-04-29.tar.gz">
	afp-HotelKeyCards-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-HotelKeyCards-2008-06-10.tar.gz">
	afp-HotelKeyCards-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-HotelKeyCards-2007-11-27.tar.gz">
	afp-HotelKeyCards-2007-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Huffman.html b/web/entries/Huffman.html
	--- a/web/entries/Huffman.html
	+++ b/web/entries/Huffman.html
	@@ -1,260 +1,265 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Textbook Proof of Huffman's Algorithm - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">T</font>extbook

	<font class="first">P</font>roof

	of

	<font class="first">H</font>uffman's

	<font class="first">A</font>lgorithm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Textbook Proof of Huffman's Algorithm</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-10-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Huffman's algorithm is a procedure for constructing a binary tree with minimum weighted path length. This report presents a formal proof of the correctness of Huffman's algorithm written using Isabelle/HOL. Our proof closely follows the sketches found in standard algorithms textbooks, uncovering a few snags in the process. Another distinguishing feature of our formalization is the use of custom induction rules to help Isabelle's automatic tactics, leading to very short proofs for most of the lemmas.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Huffman-AFP,
	author = {Jasmin Christian Blanchette},
	title = {The Textbook Proof of Huffman's Algorithm},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/Huffman.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Huffman/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Huffman/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Huffman/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Huffman-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Huffman-2018-08-16.tar.gz">
	+ afp-Huffman-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Huffman-2017-10-10.tar.gz">
	afp-Huffman-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Huffman-2016-12-17.tar.gz">
	afp-Huffman-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Huffman-2016-02-22.tar.gz">
	afp-Huffman-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Huffman-2015-05-27.tar.gz">
	afp-Huffman-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Huffman-2014-08-28.tar.gz">
	afp-Huffman-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Huffman-2013-12-11.tar.gz">
	afp-Huffman-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Huffman-2013-11-17.tar.gz">
	afp-Huffman-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Huffman-2013-03-02.tar.gz">
	afp-Huffman-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Huffman-2013-02-16.tar.gz">
	afp-Huffman-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Huffman-2012-05-24.tar.gz">
	afp-Huffman-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Huffman-2011-10-11.tar.gz">
	afp-Huffman-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Huffman-2011-02-11.tar.gz">
	afp-Huffman-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Huffman-2010-07-01.tar.gz">
	afp-Huffman-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Huffman-2009-12-12.tar.gz">
	afp-Huffman-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Huffman-2009-04-29.tar.gz">
	afp-Huffman-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Huffman-2008-10-21.tar.gz">
	afp-Huffman-2008-10-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Huffman-2008-10-15.tar.gz">
	afp-Huffman-2008-10-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Hybrid_Multi_Lane_Spatial_Logic.html b/web/entries/Hybrid_Multi_Lane_Spatial_Logic.html
	--- a/web/entries/Hybrid_Multi_Lane_Spatial_Logic.html
	+++ b/web/entries/Hybrid_Multi_Lane_Spatial_Logic.html
	@@ -1,185 +1,190 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Hybrid Multi-Lane Spatial Logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>ybrid

	<font class="first">M</font>ulti-Lane

	<font class="first">S</font>patial

	<font class="first">L</font>ogic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Hybrid Multi-Lane Spatial Logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Sven Linker (s /dot/ linker /at/ liverpool /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-11-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a semantic embedding of a spatio-temporal multi-modal
	logic, specifically defined to reason about motorway traffic, into
	Isabelle/HOL. The semantic model is an abstraction of a motorway,
	emphasising local spatial properties, and parameterised by the types
	of sensors deployed in the vehicles. We use the logic to define
	controller constraints to ensure safety, i.e., the absence of
	collisions on the motorway. After proving safety with a restrictive
	definition of sensors, we relax these assumptions and show how to
	amend the controller constraints to still guarantee safety.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Hybrid_Multi_Lane_Spatial_Logic-AFP,
	author = {Sven Linker},
	title = {Hybrid Multi-Lane Spatial Logic},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Hybrid_Multi_Lane_Spatial_Logic.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Hybrid_Multi_Lane_Spatial_Logic/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Hybrid_Multi_Lane_Spatial_Logic/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Hybrid_Multi_Lane_Spatial_Logic/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Hybrid_Multi_Lane_Spatial_Logic-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Hybrid_Multi_Lane_Spatial_Logic-2018-08-16.tar.gz">
	+ afp-Hybrid_Multi_Lane_Spatial_Logic-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Hybrid_Multi_Lane_Spatial_Logic-2017-11-09.tar.gz">
	afp-Hybrid_Multi_Lane_Spatial_Logic-2017-11-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/HyperCTL.html b/web/entries/HyperCTL.html
	--- a/web/entries/HyperCTL.html
	+++ b/web/entries/HyperCTL.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A shallow embedding of HyperCTL* - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	shallow

	embedding

	of

	<font class="first">H</font>yperCTL*

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A shallow embedding of HyperCTL*</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.react.uni-saarland.de/people/rabe.html">Markus N. Rabe</a>,
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-04-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalize HyperCTL*, a temporal logic for expressing security properties. We
	first define a shallow embedding of HyperCTL*, within which we prove inductive and coinductive
	rules for the operators. Then we show that a HyperCTL* formula captures Goguen-Meseguer
	noninterference, a landmark information flow property. We also define a deep embedding and
	connect it to the shallow embedding by a denotational semantics, for which we prove sanity w.r.t.
	dependence on the free variables. Finally, we show that under some finiteness assumptions about
	the model, noninterference is given by a (finitary) syntactic formula.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{HyperCTL-AFP,
	author = {Markus N. Rabe and Peter Lammich and Andrei Popescu},
	title = {A shallow embedding of HyperCTL*},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/HyperCTL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HyperCTL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/HyperCTL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/HyperCTL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-HyperCTL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-HyperCTL-2018-08-16.tar.gz">
	+ afp-HyperCTL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-HyperCTL-2017-10-10.tar.gz">
	afp-HyperCTL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-HyperCTL-2016-12-17.tar.gz">
	afp-HyperCTL-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-HyperCTL-2016-02-22.tar.gz">
	afp-HyperCTL-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-HyperCTL-2015-05-27.tar.gz">
	afp-HyperCTL-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-HyperCTL-2014-08-28.tar.gz">
	afp-HyperCTL-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-HyperCTL-2014-04-16.tar.gz">
	afp-HyperCTL-2014-04-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/IEEE_Floating_Point.html b/web/entries/IEEE_Floating_Point.html
	--- a/web/entries/IEEE_Floating_Point.html
	+++ b/web/entries/IEEE_Floating_Point.html
	@@ -1,240 +1,245 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Formal Model of IEEE Floating Point Arithmetic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">F</font>ormal

	<font class="first">M</font>odel

	of

	<font class="first">I</font>EEE

	<font class="first">F</font>loating

	<font class="first">P</font>oint

	<font class="first">A</font>rithmetic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Formal Model of IEEE Floating Point Arithmetic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lei Yu (ly271 /at/ cam /dot/ ac /dot/ uk)
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributors:
	</td>
	<td class="data">
	Fabian Hellauer (hellauer /at/ in /dot/ tum /dot/ de) and
	<a href="http://www21.in.tum.de/~immler">Fabian Immler</a>
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-07-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This development provides a formal model of IEEE-754 floating-point arithmetic. This formalization, including formal specification of the standard and proofs of important properties of floating-point arithmetic, forms the foundation for verifying programs with floating-point computation. There is also a code generation setup for floats so that we can execute programs using this formalization in functional programming languages.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2017-09-25]: Added conversions from and to software floating point numbers
	(by Fabian Hellauer and Fabian Immler).<br>
	[2018-02-05]: 'Modernized' representation following the formalization in HOL4:
	former "float_format" and predicate "is_valid" is now encoded in a type "('e, 'f) float" where
	'e and 'f encode the size of exponent and fraction.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{IEEE_Floating_Point-AFP,
	author = {Lei Yu},
	title = {A Formal Model of IEEE Floating Point Arithmetic},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/IEEE_Floating_Point.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Word_Lib.html">Word_Lib</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CakeML.html">CakeML</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/IEEE_Floating_Point/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/IEEE_Floating_Point/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/IEEE_Floating_Point/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-IEEE_Floating_Point-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-IEEE_Floating_Point-2018-08-16.tar.gz">
	+ afp-IEEE_Floating_Point-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-IEEE_Floating_Point-2017-10-10.tar.gz">
	afp-IEEE_Floating_Point-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-IEEE_Floating_Point-2016-12-17.tar.gz">
	afp-IEEE_Floating_Point-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-IEEE_Floating_Point-2016-02-22.tar.gz">
	afp-IEEE_Floating_Point-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-IEEE_Floating_Point-2015-05-27.tar.gz">
	afp-IEEE_Floating_Point-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-IEEE_Floating_Point-2014-08-28.tar.gz">
	afp-IEEE_Floating_Point-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-IEEE_Floating_Point-2013-12-11.tar.gz">
	afp-IEEE_Floating_Point-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-IEEE_Floating_Point-2013-11-17.tar.gz">
	afp-IEEE_Floating_Point-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-IEEE_Floating_Point-2013-07-28.tar.gz">
	afp-IEEE_Floating_Point-2013-07-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/IMAP-CRDT.html b/web/entries/IMAP-CRDT.html
	--- a/web/entries/IMAP-CRDT.html
	+++ b/web/entries/IMAP-CRDT.html
	@@ -1,187 +1,192 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The IMAP CmRDT - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">I</font>MAP

	<font class="first">C</font>mRDT

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The IMAP CmRDT</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Tim Jungnickel (tim /dot/ jungnickel /at/ tu-berlin /dot/ de),
	Lennart Oldenburg and
	Matthias Loibl
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-11-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We provide our Isabelle/HOL formalization of a Conflict-free
	Replicated Datatype for Internet Message Access Protocol commands.
	We show that Strong Eventual Consistency (SEC) is guaranteed
	by proving the commutativity of concurrent operations. We base our
	formalization on the recently proposed "framework for
	establishing Strong Eventual Consistency for Conflict-free Replicated
	Datatypes" (AFP.CRDT) from Gomes et al. Hence, we provide an
	additional example of how the recently proposed framework can be used
	to design and prove CRDTs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{IMAP-CRDT-AFP,
	author = {Tim Jungnickel and Lennart Oldenburg and Matthias Loibl},
	title = {The IMAP CmRDT},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/IMAP-CRDT.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CRDT.html">CRDT</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/IMAP-CRDT/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/IMAP-CRDT/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/IMAP-CRDT/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-IMAP-CRDT-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-IMAP-CRDT-2018-08-16.tar.gz">
	+ afp-IMAP-CRDT-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-IMAP-CRDT-2017-11-10.tar.gz">
	afp-IMAP-CRDT-2017-11-10.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/IMP2.html b/web/entries/IMP2.html
	--- a/web/entries/IMP2.html
	+++ b/web/entries/IMP2.html
	@@ -1,195 +1,203 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>IMP2 – Simple Program Verification in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>MP2

	<font class="first">–</font>

	<font class="first">S</font>imple

	<font class="first">P</font>rogram

	<font class="first">V</font>erification

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">IMP2 – Simple Program Verification in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-01-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	IMP2 is a simple imperative language together with Isabelle tooling to
	create a program verification environment in Isabelle/HOL. The tools
	include a C-like syntax, a verification condition generator, and
	Isabelle commands for the specification of programs. The framework is
	modular, i.e., it allows easy reuse of already proved programs within
	larger programs. This entry comes with a quickstart guide and a large
	collection of examples, spanning basic algorithms with simple proofs
	to more advanced algorithms and proof techniques like data refinement.
	Some highlights from the examples are: <ul> <li>Bisection
	Square Root, </li> <li>Extended Euclid, </li>
	<li>Exponentiation by Squaring, </li> <li>Binary
	Search, </li> <li>Insertion Sort, </li>
	<li>Quicksort, </li> <li>Depth First Search.
	</li> </ul> The abstract syntax and semantics are very
	simple and well-documented. They are suitable to be used in a course,
	as extension to the IMP language which comes with the Isabelle
	distribution. While this entry is limited to a simple imperative
	language, the ideas could be extended to more sophisticated languages.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{IMP2-AFP,
	author = {Peter Lammich and Simon Wimmer},
	title = {IMP2 – Simple Program Verification in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/IMP2.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	-
	+ <tr><td class="datahead">Used by:</td>
	+ <td class="data"><a href="IMP2_Binary_Heap.html">IMP2_Binary_Heap</a> </td></tr>
	+


	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/IMP2/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/IMP2/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/IMP2/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-IMP2-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-IMP2-2019-01-15.tar.gz">
	+ afp-IMP2-2019-01-15.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/IMP2_Binary_Heap.html b/web/entries/IMP2_Binary_Heap.html
	new file mode 100644
	--- /dev/null
	+++ b/web/entries/IMP2_Binary_Heap.html
	@@ -0,0 +1,182 @@
	+<!DOCTYPE html>
	+<html lang="en">
	+<head>
	+<meta charset="utf-8">
	+<title>Binary Heaps for IMP2 - Archive of Formal Proofs
	+</title>
	+<link rel="stylesheet" type="text/css" href="../front.css">
	+<link rel="icon" href="../images/favicon.ico" type="image/icon">
	+<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	+</head>
	+
	+<body>
	+
	+<table width="100%">
	+<tbody>
	+<tr>
	+
	+<!-- Navigation -->
	+<td width="20%" align="center" valign="top">
	+ <p> </p>
	+ <a href="http://isabelle.in.tum.de">
	+ <img src="../images/isabelle.png" width="100" height="86" border=0>
	+ </a>
	+ <p> </p>
	+ <p> </p>
	+ <table class="nav" width="80%">
	+ <tr>
	+ <td class="nav" width="100%"><a href="../index.html">Home</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../about.html">About</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../submitting.html">Submission</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../updating.html">Updating Entries</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../using.html">Using Entries</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../search.html">Search</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../statistics.html">Statistics</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../topics.html">Index</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../download.html">Download</a></td>
	+ </tr>
	+ </table>
	+ <p> </p>
	+ <p> </p>
	+</td>
	+
	+
	+<!-- Content -->
	+<td width="80%" valign="top">
	+<div align="center">
	+ <p> </p>
	+ <h1> <font class="first">B</font>inary
	+
	+ <font class="first">H</font>eaps
	+
	+ for
	+
	+ <font class="first">I</font>MP2
	+
	+</h1>
	+ <p> </p>
	+
	+<table width="80%" class="data">
	+<tbody>
	+<tr>
	+ <td class="datahead" width="20%">Title:</td>
	+ <td class="data" width="80%">Binary Heaps for IMP2</td>
	+</tr>
	+
	+<tr>
	+ <td class="datahead">
	+ Author:
	+ </td>
	+ <td class="data">
	+ Simon Griebel
	+ </td>
	+</tr>
	+
	+
	+
	+<tr>
	+ <td class="datahead">Submission date:</td>
	+ <td class="data">2019-06-13</td>
	+</tr>
	+
	+<tr>
	+ <td class="datahead" valign="top">Abstract:</td>
	+ <td class="abstract">
	+In this submission array-based binary minimum heaps are formalized.
	+The correctness of the following heap operations is proved: insert,
	+get-min, delete-min and make-heap. These are then used to verify an
	+in-place heapsort. The formalization is based on IMP2, an imperative
	+program verification framework implemented in Isabelle/HOL. The
	+verified heap functions are iterative versions of the partly recursive
	+functions found in "Algorithms and Data Structures – The Basic
	+Toolbox" by K. Mehlhorn and P. Sanders and "Introduction to
	+Algorithms" by T. H. Cormen, C. E. Leiserson, R. L. Rivest and C.
	+Stein.</td>
	+</tr>
	+
	+
	+<tr>
	+ <td class="datahead" valign="top">BibTeX:</td>
	+ <td class="formatted">
	+ <pre>@article{IMP2_Binary_Heap-AFP,
	+ author = {Simon Griebel},
	+ title = {Binary Heaps for IMP2},
	+ journal = {Archive of Formal Proofs},
	+ month = jun,
	+ year = 2019,
	+ note = {\url{http://isa-afp.org/entries/IMP2_Binary_Heap.html},
	+ Formal proof development},
	+ ISSN = {2150-914x},
	+}</pre>
	+ </td>
	+</tr>
	+
	+ <tr><td class="datahead">License:</td>
	+ <td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>
	+
	+
	+ <tr><td class="datahead">Depends on:</td>
	+ <td class="data"><a href="IMP2.html">IMP2</a> </td></tr>
	+
	+
	+
	+
	+ </tbody>
	+</table>
	+
	+<p></p>
	+
	+<table class="links">
	+ <tbody>
	+ <tr>
	+ <td class="links">
	+ <a href="../browser_info/current/AFP/IMP2_Binary_Heap/outline.pdf">Proof outline</a><br>
	+ <a href="../browser_info/current/AFP/IMP2_Binary_Heap/document.pdf">Proof document</a>
	+ </td>
	+ </tr>
	+ <tr>
	+ <td class="links">
	+ <a href="../browser_info/current/AFP/IMP2_Binary_Heap/index.html">Browse theories</a>
	+ </td></tr>
	+ <tr>
	+ <td class="links">
	+ <a href="../release/afp-IMP2_Binary_Heap-current.tar.gz">Download this entry</a>
	+ </td>
	+ </tr>
	+
	+
	+ <tr><td class="links">Older releases:
	+ None
	+ </td></tr>
	+
	+ </tbody>
	+</table>
	+
	+</div>
	+</td>
	+
	+</tr>
	+</tbody>
	+</table>
	+
	+<script src="../jquery.min.js"></script>
	+<script src="../script.js"></script>
	+
	+</body>
	+</html>
	\ No newline at end of file
	diff --git a/web/entries/IP_Addresses.html b/web/entries/IP_Addresses.html
	--- a/web/entries/IP_Addresses.html
	+++ b/web/entries/IP_Addresses.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>IP Addresses - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>P

	<font class="first">A</font>ddresses

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">IP Addresses</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>,
	<a href="http://liftm.de">Julius Michaelis</a> and
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry contains a definition of IP addresses and a library to work
	with them. Generic IP addresses are modeled as machine words of
	arbitrary length. Derived from this generic definition, IPv4 addresses
	are 32bit machine words, IPv6 addresses are 128bit words.
	Additionally, IPv4 addresses can be represented in dot-decimal
	notation and IPv6 addresses in (compressed) colon-separated notation.
	We support toString functions and parsers for both notations. Sets of
	IP addresses can be represented with a netmask (e.g.
	192.168.0.0/255.255.0.0) or in CIDR notation (e.g. 192.168.0.0/16). To
	provide executable code for set operations on IP address ranges, the
	library includes a datatype to work on arbitrary intervals of machine
	words.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{IP_Addresses-AFP,
	author = {Cornelius Diekmann and Julius Michaelis and Lars Hupel},
	title = {IP Addresses},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/IP_Addresses.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Automatic_Refinement.html">Automatic_Refinement</a>, <a href="Word_Lib.html">Word_Lib</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Simple_Firewall.html">Simple_Firewall</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/IP_Addresses/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/IP_Addresses/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/IP_Addresses/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-IP_Addresses-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-IP_Addresses-2018-08-16.tar.gz">
	+ afp-IP_Addresses-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-IP_Addresses-2017-10-10.tar.gz">
	afp-IP_Addresses-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-IP_Addresses-2016-12-17.tar.gz">
	afp-IP_Addresses-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-IP_Addresses-2016-06-28.tar.gz">
	afp-IP_Addresses-2016-06-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Imperative_Insertion_Sort.html b/web/entries/Imperative_Insertion_Sort.html
	--- a/web/entries/Imperative_Insertion_Sort.html
	+++ b/web/entries/Imperative_Insertion_Sort.html
	@@ -1,194 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Imperative Insertion Sort - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>mperative

	<font class="first">I</font>nsertion

	<font class="first">S</font>ort

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Imperative Insertion Sort</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-09-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The insertion sort algorithm of Cormen et al. (Introduction to Algorithms) is expressed in Imperative HOL and proved to be correct and terminating. For this purpose we also provide a theory about imperative loop constructs with accompanying induction/invariant rules for proving partial and total correctness. Furthermore, the formalized algorithm is fit for code generation.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Imperative_Insertion_Sort-AFP,
	author = {Christian Sternagel},
	title = {Imperative Insertion Sort},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Imperative_Insertion_Sort.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Imperative_Insertion_Sort/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Imperative_Insertion_Sort/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Imperative_Insertion_Sort/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Imperative_Insertion_Sort-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Imperative_Insertion_Sort-2018-08-16.tar.gz">
	+ afp-Imperative_Insertion_Sort-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Imperative_Insertion_Sort-2017-10-10.tar.gz">
	afp-Imperative_Insertion_Sort-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Imperative_Insertion_Sort-2016-12-17.tar.gz">
	afp-Imperative_Insertion_Sort-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Imperative_Insertion_Sort-2016-02-22.tar.gz">
	afp-Imperative_Insertion_Sort-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Imperative_Insertion_Sort-2015-05-27.tar.gz">
	afp-Imperative_Insertion_Sort-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Imperative_Insertion_Sort-2014-09-25.tar.gz">
	afp-Imperative_Insertion_Sort-2014-09-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Impossible_Geometry.html b/web/entries/Impossible_Geometry.html
	--- a/web/entries/Impossible_Geometry.html
	+++ b/web/entries/Impossible_Geometry.html
	@@ -1,236 +1,241 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Proving the Impossibility of Trisecting an Angle and Doubling the Cube - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>roving

	the

	<font class="first">I</font>mpossibility

	of

	<font class="first">T</font>risecting

	an

	<font class="first">A</font>ngle

	and

	<font class="first">D</font>oubling

	the

	<font class="first">C</font>ube

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Proving the Impossibility of Trisecting an Angle and Doubling the Cube</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Ralph Romanos (ralph /dot/ romanos /at/ student /dot/ ecp /dot/ fr) and
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-08-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Squaring the circle, doubling the cube and trisecting an angle, using a compass and straightedge alone, are classic unsolved problems first posed by the ancient Greeks. All three problems were proved to be impossible in the 19th century. The following document presents the proof of the impossibility of solving the latter two problems using Isabelle/HOL, following a proof by Carrega. The proof uses elementary methods: no Galois theory or field extensions. The set of points constructible using a compass and straightedge is defined inductively. Radical expressions, which involve only square roots and arithmetic of rational numbers, are defined, and we find that all constructive points have radical coordinates. Finally, doubling the cube and trisecting certain angles requires solving certain cubic equations that can be proved to have no rational roots. The Isabelle proofs require a great many detailed calculations.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Impossible_Geometry-AFP,
	author = {Ralph Romanos and Lawrence C. Paulson},
	title = {Proving the Impossibility of Trisecting an Angle and Doubling the Cube},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Impossible_Geometry.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Impossible_Geometry/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Impossible_Geometry/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Impossible_Geometry/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Impossible_Geometry-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Impossible_Geometry-2018-08-16.tar.gz">
	+ afp-Impossible_Geometry-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Impossible_Geometry-2017-10-10.tar.gz">
	afp-Impossible_Geometry-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Impossible_Geometry-2016-12-17.tar.gz">
	afp-Impossible_Geometry-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Impossible_Geometry-2016-02-22.tar.gz">
	afp-Impossible_Geometry-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Impossible_Geometry-2015-05-27.tar.gz">
	afp-Impossible_Geometry-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Impossible_Geometry-2014-08-28.tar.gz">
	afp-Impossible_Geometry-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Impossible_Geometry-2013-12-11.tar.gz">
	afp-Impossible_Geometry-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Impossible_Geometry-2013-11-17.tar.gz">
	afp-Impossible_Geometry-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Impossible_Geometry-2013-02-16.tar.gz">
	afp-Impossible_Geometry-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Impossible_Geometry-2012-08-07.tar.gz">
	afp-Impossible_Geometry-2012-08-07.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Impossible_Geometry-2012-08-06.tar.gz">
	afp-Impossible_Geometry-2012-08-06.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Incompleteness.html b/web/entries/Incompleteness.html
	--- a/web/entries/Incompleteness.html
	+++ b/web/entries/Incompleteness.html
	@@ -1,216 +1,221 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Gödel's Incompleteness Theorems - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">G</font>ödel's

	<font class="first">I</font>ncompleteness

	<font class="first">T</font>heorems

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Gödel's Incompleteness Theorems</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-11-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Gödel's two incompleteness theorems are formalised, following a careful <a href="http://journals.impan.gov.pl/dm/Inf/422-0-1.html">presentation</a> by Swierczkowski, in the theory of <a href="HereditarilyFinite.html">hereditarily finite sets</a>. This represents the first ever machine-assisted proof of the second incompleteness theorem. Compared with traditional formalisations using Peano arithmetic (see e.g. Boolos), coding is simpler, with no need to formalise the notion
	of multiplication (let alone that of a prime number)
	in the formalised calculus upon which the theorem is based.
	However, other technical problems had to be solved in order to complete the argument.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Incompleteness-AFP,
	author = {Lawrence C. Paulson},
	title = {Gödel's Incompleteness Theorems},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Incompleteness.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="HereditarilyFinite.html">HereditarilyFinite</a>, <a href="Nominal2.html">Nominal2</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Surprise_Paradox.html">Surprise_Paradox</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Incompleteness/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Incompleteness/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Incompleteness/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Incompleteness-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Incompleteness-2018-08-16.tar.gz">
	+ afp-Incompleteness-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Incompleteness-2017-10-10.tar.gz">
	afp-Incompleteness-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Incompleteness-2016-12-17.tar.gz">
	afp-Incompleteness-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Incompleteness-2016-02-22.tar.gz">
	afp-Incompleteness-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Incompleteness-2015-05-27.tar.gz">
	afp-Incompleteness-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Incompleteness-2014-08-28.tar.gz">
	afp-Incompleteness-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Incompleteness-2013-12-11.tar.gz">
	afp-Incompleteness-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Incompleteness-2013-12-02.tar.gz">
	afp-Incompleteness-2013-12-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Incompleteness-2013-11-17.tar.gz">
	afp-Incompleteness-2013-11-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Incredible_Proof_Machine.html b/web/entries/Incredible_Proof_Machine.html
	--- a/web/entries/Incredible_Proof_Machine.html
	+++ b/web/entries/Incredible_Proof_Machine.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The meta theory of the Incredible Proof Machine - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	meta

	theory

	of

	the

	<font class="first">I</font>ncredible

	<font class="first">P</font>roof

	<font class="first">M</font>achine

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The meta theory of the Incredible Proof Machine</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Joachim Breitner (joachim /at/ cis /dot/ upenn /dot/ edu) and
	<a href="http://pp.ipd.kit.edu/person.php?id=88">Denis Lohner</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The <a href="http://incredible.pm">Incredible Proof Machine</a> is an
	interactive visual theorem prover which represents proofs as port
	graphs. We model this proof representation in Isabelle, and prove that
	it is just as powerful as natural deduction.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Incredible_Proof_Machine-AFP,
	author = {Joachim Breitner and Denis Lohner},
	title = {The meta theory of the Incredible Proof Machine},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Incredible_Proof_Machine.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract_Completeness.html">Abstract_Completeness</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Incredible_Proof_Machine/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Incredible_Proof_Machine/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Incredible_Proof_Machine/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Incredible_Proof_Machine-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Incredible_Proof_Machine-2018-08-16.tar.gz">
	+ afp-Incredible_Proof_Machine-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Incredible_Proof_Machine-2017-10-10.tar.gz">
	afp-Incredible_Proof_Machine-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Incredible_Proof_Machine-2016-12-17.tar.gz">
	afp-Incredible_Proof_Machine-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Incredible_Proof_Machine-2016-05-20.tar.gz">
	afp-Incredible_Proof_Machine-2016-05-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Inductive_Confidentiality.html b/web/entries/Inductive_Confidentiality.html
	--- a/web/entries/Inductive_Confidentiality.html
	+++ b/web/entries/Inductive_Confidentiality.html
	@@ -1,221 +1,226 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Inductive Study of Confidentiality - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>nductive

	<font class="first">S</font>tudy

	of

	<font class="first">C</font>onfidentiality

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Inductive Study of Confidentiality</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.dmi.unict.it/~giamp/">Giampaolo Bella</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-05-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document contains the full theory files accompanying article <i>Inductive Study of Confidentiality --- for Everyone</i> in <i>Formal Aspects of Computing</i>. They aim at an illustrative and didactic presentation of the Inductive Method of protocol analysis, focusing on the treatment of one of the main goals of security protocols: confidentiality against a threat model. The treatment of confidentiality, which in fact forms a key aspect of all protocol analysis tools, has been found cryptic by many learners of the Inductive Method, hence the motivation for this work. The theory files in this document guide the reader step by step towards design and proof of significant confidentiality theorems. These are developed against two threat models, the standard Dolev-Yao and a more audacious one, the General Attacker, which turns out to be particularly useful also for teaching purposes.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Inductive_Confidentiality-AFP,
	author = {Giampaolo Bella},
	title = {Inductive Study of Confidentiality},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Inductive_Confidentiality.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Inductive_Confidentiality/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Inductive_Confidentiality/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Inductive_Confidentiality/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Inductive_Confidentiality-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Inductive_Confidentiality-2018-08-16.tar.gz">
	+ afp-Inductive_Confidentiality-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Inductive_Confidentiality-2017-10-10.tar.gz">
	afp-Inductive_Confidentiality-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Inductive_Confidentiality-2016-12-17.tar.gz">
	afp-Inductive_Confidentiality-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Inductive_Confidentiality-2016-02-22.tar.gz">
	afp-Inductive_Confidentiality-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Inductive_Confidentiality-2015-05-27.tar.gz">
	afp-Inductive_Confidentiality-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Inductive_Confidentiality-2014-08-28.tar.gz">
	afp-Inductive_Confidentiality-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Inductive_Confidentiality-2013-12-11.tar.gz">
	afp-Inductive_Confidentiality-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Inductive_Confidentiality-2013-11-17.tar.gz">
	afp-Inductive_Confidentiality-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Inductive_Confidentiality-2013-02-16.tar.gz">
	afp-Inductive_Confidentiality-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Inductive_Confidentiality-2012-05-24.tar.gz">
	afp-Inductive_Confidentiality-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Inductive_Confidentiality-2012-05-02.tar.gz">
	afp-Inductive_Confidentiality-2012-05-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/InfPathElimination.html b/web/entries/InfPathElimination.html
	--- a/web/entries/InfPathElimination.html
	+++ b/web/entries/InfPathElimination.html
	@@ -1,222 +1,227 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Infeasible Paths Elimination by Symbolic Execution Techniques: Proof of Correctness and Preservation of Paths - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>nfeasible

	<font class="first">P</font>aths

	<font class="first">E</font>limination

	by

	<font class="first">S</font>ymbolic

	<font class="first">E</font>xecution

	<font class="first">T</font>echniques:

	<font class="first">P</font>roof

	of

	<font class="first">C</font>orrectness

	and

	<font class="first">P</font>reservation

	of

	<font class="first">P</font>aths

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Infeasible Paths Elimination by Symbolic Execution Techniques: Proof of Correctness and Preservation of Paths</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Romain Aissat,
	Frederic Voisin and
	Burkhart Wolff (wolff /at/ lri /dot/ fr)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-08-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	TRACER is a tool for verifying safety properties of sequential C
	programs. TRACER attempts at building a finite symbolic execution
	graph which over-approximates the set of all concrete reachable states
	and the set of feasible paths. We present an abstract framework for
	TRACER and similar CEGAR-like systems. The framework provides 1) a
	graph- transformation based method for reducing the feasible paths in
	control-flow graphs, 2) a model for symbolic execution, subsumption,
	predicate abstraction and invariant generation. In this framework we
	formally prove two key properties: correct construction of the
	symbolic states and preservation of feasible paths. The framework
	focuses on core operations, leaving to concrete prototypes to “fit in”
	heuristics for combining them. The accompanying paper (published in
	ITP 2016) can be found at
	https://www.lri.fr/∼wolff/papers/conf/2016-itp-InfPathsNSE.pdf.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{InfPathElimination-AFP,
	author = {Romain Aissat and Frederic Voisin and Burkhart Wolff},
	title = {Infeasible Paths Elimination by Symbolic Execution Techniques: Proof of Correctness and Preservation of Paths},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/InfPathElimination.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/InfPathElimination/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/InfPathElimination/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/InfPathElimination/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-InfPathElimination-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-InfPathElimination-2018-08-16.tar.gz">
	+ afp-InfPathElimination-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-InfPathElimination-2017-10-10.tar.gz">
	afp-InfPathElimination-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-InfPathElimination-2016-12-17.tar.gz">
	afp-InfPathElimination-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-InfPathElimination-2016-08-18.tar.gz">
	afp-InfPathElimination-2016-08-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/InformationFlowSlicing.html b/web/entries/InformationFlowSlicing.html
	--- a/web/entries/InformationFlowSlicing.html
	+++ b/web/entries/InformationFlowSlicing.html
	@@ -1,264 +1,269 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Information Flow Noninterference via Slicing - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>nformation

	<font class="first">F</font>low

	<font class="first">N</font>oninterference

	via

	<font class="first">S</font>licing

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Information Flow Noninterference via Slicing</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-03-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	In this contribution, we show how correctness proofs for <a
	href="Slicing.html">intra-</a> and <a
	href="HRB-Slicing.html">interprocedural slicing</a> can be used to prove
	that slicing is able to guarantee information flow noninterference.
	Moreover, we also illustrate how to lift the control flow graphs of the
	respective frameworks such that they fulfil the additional assumptions
	needed in the noninterference proofs. A detailed description of the
	intraprocedural proof and its interplay with the slicing framework can be
	found in the PLAS'09 paper by Wasserrab et al.
	</p>
	<p>
	This entry contains the part for intra-procedural slicing. See entry
	<a href="InformationFlowSlicing_Inter.html">InformationFlowSlicing_Inter</a>
	for the inter-procedural part.
	</p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2016-06-10]: The original entry <a
	href="InformationFlowSlicing.html">InformationFlowSlicing</a> contained both
	the <a href="InformationFlowSlicing_Inter.html">inter-</a> and <a
	href="InformationFlowSlicing.html">intra-procedural</a> case was split into
	two for easier maintenance.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{InformationFlowSlicing-AFP,
	author = {Daniel Wasserrab},
	title = {Information Flow Noninterference via Slicing},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/InformationFlowSlicing.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Slicing.html">Slicing</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/InformationFlowSlicing/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/InformationFlowSlicing/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/InformationFlowSlicing/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-InformationFlowSlicing-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-InformationFlowSlicing-2018-08-16.tar.gz">
	+ afp-InformationFlowSlicing-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-InformationFlowSlicing-2017-10-10.tar.gz">
	afp-InformationFlowSlicing-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-InformationFlowSlicing-2016-12-17.tar.gz">
	afp-InformationFlowSlicing-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-InformationFlowSlicing-2016-02-22.tar.gz">
	afp-InformationFlowSlicing-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-InformationFlowSlicing-2015-05-27.tar.gz">
	afp-InformationFlowSlicing-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-InformationFlowSlicing-2014-08-28.tar.gz">
	afp-InformationFlowSlicing-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-InformationFlowSlicing-2013-12-11.tar.gz">
	afp-InformationFlowSlicing-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-InformationFlowSlicing-2013-11-17.tar.gz">
	afp-InformationFlowSlicing-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-InformationFlowSlicing-2013-02-16.tar.gz">
	afp-InformationFlowSlicing-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-InformationFlowSlicing-2012-05-24.tar.gz">
	afp-InformationFlowSlicing-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-InformationFlowSlicing-2011-10-11.tar.gz">
	afp-InformationFlowSlicing-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-InformationFlowSlicing-2011-02-11.tar.gz">
	afp-InformationFlowSlicing-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-InformationFlowSlicing-2010-07-01.tar.gz">
	afp-InformationFlowSlicing-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-InformationFlowSlicing-2010-03-23.tar.gz">
	afp-InformationFlowSlicing-2010-03-23.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/InformationFlowSlicing_Inter.html b/web/entries/InformationFlowSlicing_Inter.html
	--- a/web/entries/InformationFlowSlicing_Inter.html
	+++ b/web/entries/InformationFlowSlicing_Inter.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Inter-Procedural Information Flow Noninterference via Slicing - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>nter-Procedural

	<font class="first">I</font>nformation

	<font class="first">F</font>low

	<font class="first">N</font>oninterference

	via

	<font class="first">S</font>licing

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Inter-Procedural Information Flow Noninterference via Slicing</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-03-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	In this contribution, we show how correctness proofs for <a
	href="Slicing.html">intra-</a> and <a
	href="HRB-Slicing.html">interprocedural slicing</a> can be used to prove
	that slicing is able to guarantee information flow noninterference.
	Moreover, we also illustrate how to lift the control flow graphs of the
	respective frameworks such that they fulfil the additional assumptions
	needed in the noninterference proofs. A detailed description of the
	intraprocedural proof and its interplay with the slicing framework can be
	found in the PLAS'09 paper by Wasserrab et al.
	</p>
	<p>
	This entry contains the part for inter-procedural slicing. See entry
	<a href="InformationFlowSlicing.html">InformationFlowSlicing</a>
	for the intra-procedural part.
	</p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2016-06-10]: The original entry <a
	href="InformationFlowSlicing.html">InformationFlowSlicing</a> contained both
	the <a href="InformationFlowSlicing_Inter.html">inter-</a> and <a
	href="InformationFlowSlicing.html">intra-procedural</a> case was split into
	two for easier maintenance.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{InformationFlowSlicing_Inter-AFP,
	author = {Daniel Wasserrab},
	title = {Inter-Procedural Information Flow Noninterference via Slicing},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/InformationFlowSlicing_Inter.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="HRB-Slicing.html">HRB-Slicing</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/InformationFlowSlicing_Inter/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/InformationFlowSlicing_Inter/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/InformationFlowSlicing_Inter/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-InformationFlowSlicing_Inter-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-InformationFlowSlicing_Inter-2018-08-16.tar.gz">
	+ afp-InformationFlowSlicing_Inter-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-InformationFlowSlicing_Inter-2017-10-10.tar.gz">
	afp-InformationFlowSlicing_Inter-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-InformationFlowSlicing_Inter-2016-12-17.tar.gz">
	afp-InformationFlowSlicing_Inter-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Integration.html b/web/entries/Integration.html
	--- a/web/entries/Integration.html
	+++ b/web/entries/Integration.html
	@@ -1,272 +1,277 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Integration theory and random variables - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>ntegration

	theory

	and

	random

	variables

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Integration theory and random variables</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www-lti.informatik.rwth-aachen.de/~richter/">Stefan Richter</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-11-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Lebesgue-style integration plays a major role in advanced probability. We formalize concepts of elementary measure theory, real-valued random variables as Borel-measurable functions, and a stepwise inductive definition of the integral itself. All proofs are carried out in human readable style using the Isar language.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Note:</td>
	<td class="abstract">This article is of historical interest only. Lebesgue-style integration and probability theory are now available as part of the Isabelle/HOL distribution (directory Probability).</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Integration-AFP,
	author = {Stefan Richter},
	title = {Integration theory and random variables},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Integration.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Integration/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Integration/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Integration/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Integration-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Integration-2018-08-16.tar.gz">
	+ afp-Integration-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Integration-2017-10-10.tar.gz">
	afp-Integration-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Integration-2016-12-17.tar.gz">
	afp-Integration-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Integration-2016-02-22.tar.gz">
	afp-Integration-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Integration-2015-05-27.tar.gz">
	afp-Integration-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Integration-2014-08-28.tar.gz">
	afp-Integration-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Integration-2013-12-11.tar.gz">
	afp-Integration-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Integration-2013-11-17.tar.gz">
	afp-Integration-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Integration-2013-02-16.tar.gz">
	afp-Integration-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Integration-2012-05-24.tar.gz">
	afp-Integration-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Integration-2011-10-11.tar.gz">
	afp-Integration-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Integration-2011-02-11.tar.gz">
	afp-Integration-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Integration-2010-07-01.tar.gz">
	afp-Integration-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Integration-2009-12-12.tar.gz">
	afp-Integration-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Integration-2009-04-29.tar.gz">
	afp-Integration-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Integration-2008-06-10.tar.gz">
	afp-Integration-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Integration-2007-11-27.tar.gz">
	afp-Integration-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Integration-2005-10-14.tar.gz">
	afp-Integration-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Integration-2004-11-23.tar.gz">
	afp-Integration-2004-11-23.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Integration-2004-11-22.tar.gz">
	afp-Integration-2004-11-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Iptables_Semantics.html b/web/entries/Iptables_Semantics.html
	--- a/web/entries/Iptables_Semantics.html
	+++ b/web/entries/Iptables_Semantics.html
	@@ -1,202 +1,207 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Iptables Semantics - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>ptables

	<font class="first">S</font>emantics

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Iptables Semantics</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a> and
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-09-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a big step semantics of the filtering behavior of the
	Linux/netfilter iptables firewall. We provide algorithms to simplify
	complex iptables rulests to a simple firewall model (c.f. AFP entry <a
	href="https://www.isa-afp.org/entries/Simple_Firewall.html">Simple_Firewall</a>)
	and to verify spoofing protection of a ruleset.
	Internally, we embed our semantics into ternary logic, ultimately
	supporting every iptables match condition by abstracting over
	unknowns. Using this AFP entry and all entries it depends on, we
	created an easy-to-use, stand-alone haskell tool called <a
	href="http://iptables.isabelle.systems">fffuu</a>. The tool does not
	require any input —except for the <tt>iptables-save</tt> dump of
	the analyzed firewall— and presents interesting results about
	the user's ruleset. Real-Word firewall errors have been uncovered, and
	the correctness of rulesets has been proved, with the help of
	our tool.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Iptables_Semantics-AFP,
	author = {Cornelius Diekmann and Lars Hupel},
	title = {Iptables Semantics},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Iptables_Semantics.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Native_Word.html">Native_Word</a>, <a href="Routing.html">Routing</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="LOFT.html">LOFT</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Iptables_Semantics/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Iptables_Semantics/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Iptables_Semantics/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Iptables_Semantics-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Iptables_Semantics-2018-08-16.tar.gz">
	+ afp-Iptables_Semantics-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Iptables_Semantics-2017-10-10.tar.gz">
	afp-Iptables_Semantics-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Iptables_Semantics-2016-12-17.tar.gz">
	afp-Iptables_Semantics-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Iptables_Semantics-2016-09-09.tar.gz">
	afp-Iptables_Semantics-2016-09-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Irrationality_J_Hancl.html b/web/entries/Irrationality_J_Hancl.html
	--- a/web/entries/Irrationality_J_Hancl.html
	+++ b/web/entries/Irrationality_J_Hancl.html
	@@ -1,183 +1,188 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Irrational Rapidly Convergent Series - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>rrational

	<font class="first">R</font>apidly

	<font class="first">C</font>onvergent

	<font class="first">S</font>eries

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Irrational Rapidly Convergent Series</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~ak2110/">Angeliki Koutsoukou-Argyraki</a> and
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-05-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize with Isabelle/HOL a proof of a theorem by J. Hancl asserting the
	irrationality of the sum of a series consisting of rational numbers, built up
	by sequences that fulfill certain properties. Even though the criterion is a
	number theoretic result, the proof makes use only of analytical arguments. We
	also formalize a corollary of the theorem for a specific series fulfilling the
	assumptions of the theorem.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Irrationality_J_Hancl-AFP,
	author = {Angeliki Koutsoukou-Argyraki and Wenda Li},
	title = {Irrational Rapidly Convergent Series},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Irrationality_J_Hancl.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Irrationality_J_Hancl/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Irrationality_J_Hancl/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Irrationality_J_Hancl/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Irrationality_J_Hancl-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Irrationality_J_Hancl-2018-08-16.tar.gz">
	+ afp-Irrationality_J_Hancl-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Irrationality_J_Hancl-2018-05-26.tar.gz">
	afp-Irrationality_J_Hancl-2018-05-26.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Isabelle_Meta_Model.html b/web/entries/Isabelle_Meta_Model.html
	--- a/web/entries/Isabelle_Meta_Model.html
	+++ b/web/entries/Isabelle_Meta_Model.html
	@@ -1,232 +1,237 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Meta-Model for the Isabelle API - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">M</font>eta-Model

	for

	the

	<font class="first">I</font>sabelle

	<font class="first">A</font>PI

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Meta-Model for the Isabelle API</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Frédéric Tuong (tuong /at/ users /dot/ gforge /dot/ inria /dot/ fr) and
	Burkhart Wolff (wolff /at/ lri /dot/ fr)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-09-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We represent a theory <i>of</i> (a fragment of) Isabelle/HOL <i>in</i>
	Isabelle/HOL. The purpose of this exercise is to write packages for
	domain-specific specifications such as class models, B-machines, ...,
	and generally speaking, any domain-specific languages whose
	abstract syntax can be defined by a HOL "datatype". On this basis, the
	Isabelle code-generator can then be used to generate code for global
	context transformations as well as tactic code.
	<p>
	Consequently the package is geared towards
	parsing, printing and code-generation to the Isabelle API.
	It is at the moment not sufficiently rich for doing meta theory on
	Isabelle itself. Extensions in this direction are possible though.
	<p>
	Moreover, the chosen fragment is fairly rudimentary. However it should be
	easily adapted to one's needs if a package is written on top of it.
	The supported API contains types, terms, transformation of
	global context like definitions and data-type declarations as well
	as infrastructure for Isar-setups.
	<p>
	This theory is drawn from the
	<a href="http://isa-afp.org/entries/Featherweight_OCL.html">Featherweight OCL</a>
	project where
	it is used to construct a package for object-oriented data-type theories
	generated from UML class diagrams. The Featherweight OCL, for example, allows for
	both the direct execution of compiled tactic code by the Isabelle API
	as well as the generation of ".thy"-files for debugging purposes.
	<p>
	Gained experience from this project shows that the compiled code is sufficiently
	efficient for practical purposes while being based on a formal <i>model</i>
	on which properties of the package can be proven such as termination of certain
	transformations, correctness, etc.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Isabelle_Meta_Model-AFP,
	author = {Frédéric Tuong and Burkhart Wolff},
	title = {A Meta-Model for the Isabelle API},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Isabelle_Meta_Model.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Isabelle_Meta_Model/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Isabelle_Meta_Model/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Isabelle_Meta_Model/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Isabelle_Meta_Model-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Isabelle_Meta_Model-2018-08-16.tar.gz">
	+ afp-Isabelle_Meta_Model-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Isabelle_Meta_Model-2017-10-10.tar.gz">
	afp-Isabelle_Meta_Model-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Isabelle_Meta_Model-2016-12-17.tar.gz">
	afp-Isabelle_Meta_Model-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Isabelle_Meta_Model-2016-02-22.tar.gz">
	afp-Isabelle_Meta_Model-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Isabelle_Meta_Model-2015-09-28.tar.gz">
	afp-Isabelle_Meta_Model-2015-09-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Isabelle_Meta_Model-2015-09-25.tar.gz">
	afp-Isabelle_Meta_Model-2015-09-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Jinja.html b/web/entries/Jinja.html
	--- a/web/entries/Jinja.html
	+++ b/web/entries/Jinja.html
	@@ -1,266 +1,271 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Jinja is not Java - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">J</font>inja

	is

	not

	<font class="first">J</font>ava

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Jinja is not Java</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.cse.unsw.edu.au/~kleing/">Gerwin Klein</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2005-06-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We introduce Jinja, a Java-like programming language with a formal semantics designed to exhibit core features of the Java language architecture. Jinja is a compromise between realism of the language and tractability and clarity of the formal semantics. The following aspects are formalised: a big and a small step operational semantics for Jinja and a proof of their equivalence; a type system and a definite initialisation analysis; a type safety proof of the small step semantics; a virtual machine (JVM), its operational semantics and its type system; a type safety proof for the JVM; a bytecode verifier, i.e. data flow analyser for the JVM; a correctness proof of the bytecode verifier w.r.t. the type system; a compiler and a proof that it preserves semantics and well-typedness. The emphasis of this work is not on particular language features but on providing a unified model of the source language, the virtual machine and the compiler. The whole development has been carried out in the theorem prover Isabelle/HOL.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Jinja-AFP,
	author = {Gerwin Klein and Tobias Nipkow},
	title = {Jinja is not Java},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2005,
	note = {\url{http://isa-afp.org/entries/Jinja.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="List-Index.html">List-Index</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="HRB-Slicing.html">HRB-Slicing</a>, <a href="Slicing.html">Slicing</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Jinja/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Jinja/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Jinja/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Jinja-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Jinja-2018-08-16.tar.gz">
	+ afp-Jinja-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Jinja-2017-10-10.tar.gz">
	afp-Jinja-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Jinja-2016-12-17.tar.gz">
	afp-Jinja-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Jinja-2016-02-22.tar.gz">
	afp-Jinja-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Jinja-2015-05-27.tar.gz">
	afp-Jinja-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Jinja-2014-08-28.tar.gz">
	afp-Jinja-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Jinja-2013-12-11.tar.gz">
	afp-Jinja-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Jinja-2013-11-17.tar.gz">
	afp-Jinja-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Jinja-2013-02-16.tar.gz">
	afp-Jinja-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Jinja-2012-05-24.tar.gz">
	afp-Jinja-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Jinja-2011-10-11.tar.gz">
	afp-Jinja-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Jinja-2011-02-11.tar.gz">
	afp-Jinja-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Jinja-2010-07-01.tar.gz">
	afp-Jinja-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Jinja-2009-12-12.tar.gz">
	afp-Jinja-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Jinja-2009-04-29.tar.gz">
	afp-Jinja-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Jinja-2008-06-10.tar.gz">
	afp-Jinja-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Jinja-2007-11-27.tar.gz">
	afp-Jinja-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Jinja-2006-08-08.tar.gz">
	afp-Jinja-2006-08-08.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Jinja-2005-10-14.tar.gz">
	afp-Jinja-2005-10-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/JinjaThreads.html b/web/entries/JinjaThreads.html
	--- a/web/entries/JinjaThreads.html
	+++ b/web/entries/JinjaThreads.html
	@@ -1,312 +1,317 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Jinja with Threads - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">J</font>inja

	with

	<font class="first">T</font>hreads

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Jinja with Threads</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2007-12-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We extend the Jinja source code semantics by Klein and Nipkow with Java-style arrays and threads. Concurrency is captured in a generic framework semantics for adding concurrency through interleaving to a sequential semantics, which features dynamic thread creation, inter-thread communication via shared memory, lock synchronisation and joins. Also, threads can suspend themselves and be notified by others. We instantiate the framework with the adapted versions of both Jinja source and byte code and show type safety for the multithreaded case. Equally, the compiler from source to byte code is extended, for which we prove weak bisimilarity between the source code small step semantics and the defensive Jinja virtual machine. On top of this, we formalise the JMM and show the DRF guarantee and consistency. For description of the different parts, see Lochbihler's papers at FOOL 2008, ESOP 2010, ITP 2011, and ESOP 2012.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2008-04-23]:
	added bytecode formalisation with arrays and threads, added thread joins
	(revision f74a8be156a7)<br>
	[2009-04-27]:
	added verified compiler from source code to bytecode;
	encapsulate native methods in separate semantics
	(revision e4f26541e58a)<br>
	[2009-11-30]:
	extended compiler correctness proof to infinite and deadlocking computations
	(revision e50282397435)<br>
	[2010-06-08]:
	added thread interruption;
	new abstract memory model with sequential consistency as implementation
	(revision 0cb9e8dbd78d)<br>
	[2010-06-28]:
	new thread interruption model
	(revision c0440d0a1177)<br>
	[2010-10-15]:
	preliminary version of the Java memory model for source code
	(revision 02fee0ef3ca2)<br>
	[2010-12-16]:
	improved version of the Java memory model, also for bytecode
	executable scheduler for source code semantics
	(revision 1f41c1842f5a)<br>
	[2011-02-02]:
	simplified code generator setup
	new random scheduler
	(revision 3059dafd013f)<br>
	[2011-07-21]:
	new interruption model,
	generalized JMM proof of DRF guarantee,
	allow class Object to declare methods and fields,
	simplified subtyping relation,
	corrected division and modulo implementation
	(revision 46e4181ed142)<br>
	[2012-02-16]:
	added example programs
	(revision bf0b06c8913d)<br>
	[2012-11-21]:
	type safety proof for the Java memory model,
	allow spurious wake-ups
	(revision 76063d860ae0)<br>
	[2013-05-16]:
	support for non-deterministic memory allocators
	(revision cc3344a49ced)<br>
	[2017-10-20]:
	add an atomic compare-and-swap operation for volatile fields
	(revision a6189b1d6b30)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{JinjaThreads-AFP,
	author = {Andreas Lochbihler},
	title = {Jinja with Threads},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2007,
	note = {\url{http://isa-afp.org/entries/JinjaThreads.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Automatic_Refinement.html">Automatic_Refinement</a>, <a href="Binomial-Heaps.html">Binomial-Heaps</a>, <a href="Coinductive.html">Coinductive</a>, <a href="Collections.html">Collections</a>, <a href="FinFun.html">FinFun</a>, <a href="Finger-Trees.html">Finger-Trees</a>, <a href="Native_Word.html">Native_Word</a>, <a href="Refine_Monadic.html">Refine_Monadic</a>, <a href="Trie.html">Trie</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/JinjaThreads/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/JinjaThreads/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/JinjaThreads/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-JinjaThreads-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-JinjaThreads-2018-08-17.tar.gz">
	+ afp-JinjaThreads-2018-08-17.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-JinjaThreads-2017-10-10.tar.gz">
	afp-JinjaThreads-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-JinjaThreads-2016-12-17.tar.gz">
	afp-JinjaThreads-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-JinjaThreads-2016-02-22.tar.gz">
	afp-JinjaThreads-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-JinjaThreads-2015-05-27.tar.gz">
	afp-JinjaThreads-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-JinjaThreads-2014-08-28.tar.gz">
	afp-JinjaThreads-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-JinjaThreads-2013-12-11.tar.gz">
	afp-JinjaThreads-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-JinjaThreads-2013-11-17.tar.gz">
	afp-JinjaThreads-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-JinjaThreads-2013-02-16.tar.gz">
	afp-JinjaThreads-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-JinjaThreads-2012-05-26.tar.gz">
	afp-JinjaThreads-2012-05-26.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-JinjaThreads-2011-10-12.tar.gz">
	afp-JinjaThreads-2011-10-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-JinjaThreads-2011-10-11.tar.gz">
	afp-JinjaThreads-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-JinjaThreads-2011-02-11.tar.gz">
	afp-JinjaThreads-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-JinjaThreads-2010-07-02.tar.gz">
	afp-JinjaThreads-2010-07-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-JinjaThreads-2009-12-12.tar.gz">
	afp-JinjaThreads-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-JinjaThreads-2009-04-30.tar.gz">
	afp-JinjaThreads-2009-04-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-JinjaThreads-2009-04-29.tar.gz">
	afp-JinjaThreads-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-JinjaThreads-2008-06-10.tar.gz">
	afp-JinjaThreads-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-JinjaThreads-2007-12-03.tar.gz">
	afp-JinjaThreads-2007-12-03.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/JiveDataStoreModel.html b/web/entries/JiveDataStoreModel.html
	--- a/web/entries/JiveDataStoreModel.html
	+++ b/web/entries/JiveDataStoreModel.html
	@@ -1,259 +1,264 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Jive Data and Store Model - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">J</font>ive

	<font class="first">D</font>ata

	and

	<font class="first">S</font>tore

	<font class="first">M</font>odel

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Jive Data and Store Model</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Nicole Rauch (rauch /at/ informatik /dot/ uni-kl /dot/ de) and
	Norbert Schirmer (norbert /dot/ schirmer /at/ web /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2005-06-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document presents the formalization of an object-oriented data and store model in Isabelle/HOL. This model is being used in the Java Interactive Verification Environment, Jive.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{JiveDataStoreModel-AFP,
	author = {Nicole Rauch and Norbert Schirmer},
	title = {Jive Data and Store Model},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2005,
	note = {\url{http://isa-afp.org/entries/JiveDataStoreModel.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/JiveDataStoreModel/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/JiveDataStoreModel/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/JiveDataStoreModel/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-JiveDataStoreModel-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-JiveDataStoreModel-2018-08-16.tar.gz">
	+ afp-JiveDataStoreModel-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-JiveDataStoreModel-2017-10-10.tar.gz">
	afp-JiveDataStoreModel-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-JiveDataStoreModel-2016-12-17.tar.gz">
	afp-JiveDataStoreModel-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-JiveDataStoreModel-2016-02-22.tar.gz">
	afp-JiveDataStoreModel-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-JiveDataStoreModel-2015-05-27.tar.gz">
	afp-JiveDataStoreModel-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-JiveDataStoreModel-2014-08-28.tar.gz">
	afp-JiveDataStoreModel-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-JiveDataStoreModel-2013-12-11.tar.gz">
	afp-JiveDataStoreModel-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-JiveDataStoreModel-2013-11-17.tar.gz">
	afp-JiveDataStoreModel-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-JiveDataStoreModel-2013-02-16.tar.gz">
	afp-JiveDataStoreModel-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-JiveDataStoreModel-2012-05-24.tar.gz">
	afp-JiveDataStoreModel-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-JiveDataStoreModel-2011-10-11.tar.gz">
	afp-JiveDataStoreModel-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-JiveDataStoreModel-2011-02-11.tar.gz">
	afp-JiveDataStoreModel-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-JiveDataStoreModel-2010-07-01.tar.gz">
	afp-JiveDataStoreModel-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-JiveDataStoreModel-2009-12-12.tar.gz">
	afp-JiveDataStoreModel-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-JiveDataStoreModel-2009-04-29.tar.gz">
	afp-JiveDataStoreModel-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-JiveDataStoreModel-2008-06-10.tar.gz">
	afp-JiveDataStoreModel-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-JiveDataStoreModel-2007-11-27.tar.gz">
	afp-JiveDataStoreModel-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-JiveDataStoreModel-2005-10-14.tar.gz">
	afp-JiveDataStoreModel-2005-10-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Jordan_Hoelder.html b/web/entries/Jordan_Hoelder.html
	--- a/web/entries/Jordan_Hoelder.html
	+++ b/web/entries/Jordan_Hoelder.html
	@@ -1,196 +1,201 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Jordan-Hölder Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">J</font>ordan-Hölder

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Jordan-Hölder Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Jakob von Raumer (psxjv4 /at/ nottingham /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-09-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This submission contains theories that lead to a formalization of the proof of the Jordan-Hölder theorem about composition series of finite groups. The theories formalize the notions of isomorphism classes of groups, simple groups, normal series, composition series, maximal normal subgroups. Furthermore, they provide proofs of the second isomorphism theorem for groups, the characterization theorem for maximal normal subgroups as well as many useful lemmas about normal subgroups and factor groups. The proof is inspired by course notes of Stuart Rankin.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Jordan_Hoelder-AFP,
	author = {Jakob von Raumer},
	title = {The Jordan-Hölder Theorem},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Jordan_Hoelder.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Secondary_Sylow.html">Secondary_Sylow</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Jordan_Hoelder/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Jordan_Hoelder/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Jordan_Hoelder/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Jordan_Hoelder-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Jordan_Hoelder-2018-08-16.tar.gz">
	+ afp-Jordan_Hoelder-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Jordan_Hoelder-2017-10-10.tar.gz">
	afp-Jordan_Hoelder-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Jordan_Hoelder-2016-12-17.tar.gz">
	afp-Jordan_Hoelder-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Jordan_Hoelder-2016-02-22.tar.gz">
	afp-Jordan_Hoelder-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Jordan_Hoelder-2015-05-27.tar.gz">
	afp-Jordan_Hoelder-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Jordan_Hoelder-2014-09-11.tar.gz">
	afp-Jordan_Hoelder-2014-09-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Jordan_Normal_Form.html b/web/entries/Jordan_Normal_Form.html
	--- a/web/entries/Jordan_Normal_Form.html
	+++ b/web/entries/Jordan_Normal_Form.html
	@@ -1,226 +1,231 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Matrices, Jordan Normal Forms, and Spectral Radius Theory - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>atrices,

	<font class="first">J</font>ordan

	<font class="first">N</font>ormal

	<font class="first">F</font>orms,

	and

	<font class="first">S</font>pectral

	<font class="first">R</font>adius

	<font class="first">T</font>heory

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Matrices, Jordan Normal Forms, and Spectral Radius Theory</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a> and
	Akihisa Yamada (ayamada /at/ trs /dot/ cm /dot/ is /dot/ nagoya-u /dot/ ac /dot/ jp)
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	Alexander Bentkamp (bentkamp /at/ gmail /dot/ com)
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-08-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	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.
	</p><p>
	To formally prove this result we first studied the growth rates of matrices in Jordan normal form, and prove the result that every complex matrix has a Jordan normal form using a constructive prove via Schur decomposition.
	</p><p>
	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.
	</p><p>
	All the results have been applied to improve CeTA, our certifier to validate termination and complexity proof certificates.
	</p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2016-01-07]: Added Schur-decomposition, Gram-Schmidt orthogonalization, uniqueness of Jordan normal forms<br/>
	[2018-04-17]: Integrated lemmas from deep-learning AFP-entry of Alexander Bentkamp</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Jordan_Normal_Form.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Deep_Learning.html">Deep_Learning</a>, <a href="Farkas.html">Farkas</a>, <a href="Groebner_Bases.html">Groebner_Bases</a>, <a href="Perron_Frobenius.html">Perron_Frobenius</a>, <a href="QHLProver.html">QHLProver</a>, <a href="Stochastic_Matrices.html">Stochastic_Matrices</a>, <a href="Subresultants.html">Subresultants</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Jordan_Normal_Form/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Jordan_Normal_Form/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Jordan_Normal_Form/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Jordan_Normal_Form-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Jordan_Normal_Form-2018-08-16.tar.gz">
	+ afp-Jordan_Normal_Form-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Jordan_Normal_Form-2017-10-10.tar.gz">
	afp-Jordan_Normal_Form-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Jordan_Normal_Form-2016-12-17.tar.gz">
	afp-Jordan_Normal_Form-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Jordan_Normal_Form-2016-02-22.tar.gz">
	afp-Jordan_Normal_Form-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Jordan_Normal_Form-2015-08-23.tar.gz">
	afp-Jordan_Normal_Form-2015-08-23.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/KAD.html b/web/entries/KAD.html
	--- a/web/entries/KAD.html
	+++ b/web/entries/KAD.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Kleene Algebras with Domain - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">K</font>leene

	<font class="first">A</font>lgebras

	with

	<font class="first">D</font>omain

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Kleene Algebras with Domain</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Victor B. F. Gomes (vb358 /at/ cl /dot/ cam /dot/ ac /dot/ uk),
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>,
	<a href="http://www.hoefner-online.de/">Peter Höfner</a>,
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a> and
	Tjark Weber (tjark /dot/ weber /at/ it /dot/ uu /dot/ se)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-04-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Kleene algebras with domain are Kleene algebras endowed with an
	operation that maps each element of the algebra to its domain of
	definition (or its complement) in abstract fashion. They form a simple
	algebraic basis for Hoare logics, dynamic logics or predicate
	transformer semantics. We formalise a modular hierarchy of algebras
	with domain and antidomain (domain complement) operations in
	Isabelle/HOL that ranges from domain and antidomain semigroups to
	modal Kleene algebras and divergence Kleene algebras. We link these
	algebras with models of binary relations and program traces. We
	include some examples from modal logics, termination and program
	analysis.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{KAD-AFP,
	author = {Victor B. F. Gomes and Walter Guttmann and Peter Höfner and Georg Struth and Tjark Weber},
	title = {Kleene Algebras with Domain},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/KAD.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Kleene_Algebra.html">Kleene_Algebra</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Algebraic_VCs.html">Algebraic_VCs</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/KAD/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/KAD/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/KAD/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-KAD-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-KAD-2018-08-16.tar.gz">
	+ afp-KAD-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-KAD-2017-10-10.tar.gz">
	afp-KAD-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-KAD-2016-12-17.tar.gz">
	afp-KAD-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-KAD-2016-04-12.tar.gz">
	afp-KAD-2016-04-12.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/KAT_and_DRA.html b/web/entries/KAT_and_DRA.html
	--- a/web/entries/KAT_and_DRA.html
	+++ b/web/entries/KAT_and_DRA.html
	@@ -1,224 +1,229 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Kleene Algebra with Tests and Demonic Refinement Algebras - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">K</font>leene

	<font class="first">A</font>lgebra

	with

	<font class="first">T</font>ests

	and

	<font class="first">D</font>emonic

	<font class="first">R</font>efinement

	<font class="first">A</font>lgebras

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Kleene Algebra with Tests and Demonic Refinement Algebras</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Alasdair Armstrong,
	Victor B. F. Gomes (vb358 /at/ cl /dot/ cam /dot/ ac /dot/ uk) and
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-01-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalise Kleene algebra with tests (KAT) and demonic refinement
	algebra (DRA) in Isabelle/HOL. KAT is relevant for program verification
	and correctness proofs in the partial correctness setting. While DRA
	targets similar applications in the context of total correctness. Our
	formalisation contains the two most important models of these algebras:
	binary relations in the case of KAT and predicate transformers in the
	case of DRA. In addition, we derive the inference rules for Hoare logic
	in KAT and its relational model and present a simple formally verified
	program verification tool prototype based on the algebraic approach.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{KAT_and_DRA-AFP,
	author = {Alasdair Armstrong and Victor B. F. Gomes and Georg Struth},
	title = {Kleene Algebra with Tests and Demonic Refinement Algebras},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/KAT_and_DRA.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Kleene_Algebra.html">Kleene_Algebra</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Algebraic_VCs.html">Algebraic_VCs</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/KAT_and_DRA/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/KAT_and_DRA/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/KAT_and_DRA/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-KAT_and_DRA-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-KAT_and_DRA-2018-08-16.tar.gz">
	+ afp-KAT_and_DRA-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-KAT_and_DRA-2017-10-10.tar.gz">
	afp-KAT_and_DRA-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-KAT_and_DRA-2016-12-17.tar.gz">
	afp-KAT_and_DRA-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-KAT_and_DRA-2016-02-22.tar.gz">
	afp-KAT_and_DRA-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-KAT_and_DRA-2015-05-27.tar.gz">
	afp-KAT_and_DRA-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-KAT_and_DRA-2014-08-28.tar.gz">
	afp-KAT_and_DRA-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-KAT_and_DRA-2014-01-29.tar.gz">
	afp-KAT_and_DRA-2014-01-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/KBPs.html b/web/entries/KBPs.html
	--- a/web/entries/KBPs.html
	+++ b/web/entries/KBPs.html
	@@ -1,235 +1,240 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Knowledge-based programs - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">K</font>nowledge-based

	programs

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Knowledge-based programs</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-05-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2012-03-06]: Add some more views and revive the code generation.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{KBPs-AFP,
	author = {Peter Gammie},
	title = {Knowledge-based programs},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/KBPs.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Transitive-Closure.html">Transitive-Closure</a>, <a href="Trie.html">Trie</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="LTL_to_DRA.html">LTL_to_DRA</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/KBPs/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/KBPs/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/KBPs/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-KBPs-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-KBPs-2018-08-16.tar.gz">
	+ afp-KBPs-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-KBPs-2017-10-10.tar.gz">
	afp-KBPs-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-KBPs-2016-12-17.tar.gz">
	afp-KBPs-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-KBPs-2016-02-22.tar.gz">
	afp-KBPs-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-KBPs-2015-05-27.tar.gz">
	afp-KBPs-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-KBPs-2014-08-28.tar.gz">
	afp-KBPs-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-KBPs-2013-12-11.tar.gz">
	afp-KBPs-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-KBPs-2013-11-17.tar.gz">
	afp-KBPs-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-KBPs-2013-03-02.tar.gz">
	afp-KBPs-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-KBPs-2013-02-16.tar.gz">
	afp-KBPs-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-KBPs-2012-05-24.tar.gz">
	afp-KBPs-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-KBPs-2011-10-11.tar.gz">
	afp-KBPs-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-KBPs-2011-05-19.tar.gz">
	afp-KBPs-2011-05-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/KD_Tree.html b/web/entries/KD_Tree.html
	--- a/web/entries/KD_Tree.html
	+++ b/web/entries/KD_Tree.html
	@@ -1,181 +1,187 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Multidimensional Binary Search Trees - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>ultidimensional

	<font class="first">B</font>inary

	<font class="first">S</font>earch

	<font class="first">T</font>rees

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Multidimensional Binary Search Trees</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Martin Rau
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-05-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides a formalization of multidimensional binary trees,
	also known as k-d trees. It includes a balanced build algorithm as
	well as the nearest neighbor algorithm and the range search algorithm.
	It is based on the papers <a
	href="https://dl.acm.org/citation.cfm?doid=361002.361007">Multidimensional
	binary search trees used for associative searching</a> and <a
	href="https://dl.acm.org/citation.cfm?doid=355744.355745">
	An Algorithm for Finding Best Matches in Logarithmic Expected
	Time</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{KD_Tree-AFP,
	author = {Martin Rau},
	title = {Multidimensional Binary Search Trees},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/KD_Tree.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Median_Of_Medians_Selection.html">Median_Of_Medians_Selection</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/KD_Tree/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/KD_Tree/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/KD_Tree/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-KD_Tree-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-KD_Tree-2019-06-04.tar.gz">
	+ afp-KD_Tree-2019-06-04.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Key_Agreement_Strong_Adversaries.html b/web/entries/Key_Agreement_Strong_Adversaries.html
	--- a/web/entries/Key_Agreement_Strong_Adversaries.html
	+++ b/web/entries/Key_Agreement_Strong_Adversaries.html
	@@ -1,199 +1,204 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Refining Authenticated Key Agreement with Strong Adversaries - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>efining

	<font class="first">A</font>uthenticated

	<font class="first">K</font>ey

	<font class="first">A</font>greement

	with

	<font class="first">S</font>trong

	<font class="first">A</font>dversaries

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Refining Authenticated Key Agreement with Strong Adversaries</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Joseph Lallemand (joseph /dot/ lallemand /at/ loria /dot/ fr) and
	Christoph Sprenger (sprenger /at/ inf /dot/ ethz /dot/ ch)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-01-31</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We develop a family of key agreement protocols that are correct by
	construction. Our work substantially extends prior work on developing
	security protocols by refinement. First, we strengthen the adversary
	by allowing him to compromise different resources of protocol
	participants, such as their long-term keys or their session keys. This
	enables the systematic development of protocols that ensure strong
	properties such as perfect forward secrecy. Second, we broaden the
	class of protocols supported to include those with non-atomic keys and
	equationally defined cryptographic operators. We use these extensions
	to develop key agreement protocols including signed Diffie-Hellman and
	the core of IKEv1 and SKEME.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Key_Agreement_Strong_Adversaries-AFP,
	author = {Joseph Lallemand and Christoph Sprenger},
	title = {Refining Authenticated Key Agreement with Strong Adversaries},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Key_Agreement_Strong_Adversaries.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Key_Agreement_Strong_Adversaries/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Key_Agreement_Strong_Adversaries/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Key_Agreement_Strong_Adversaries/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Key_Agreement_Strong_Adversaries-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Key_Agreement_Strong_Adversaries-2018-08-16.tar.gz">
	+ afp-Key_Agreement_Strong_Adversaries-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Key_Agreement_Strong_Adversaries-2017-10-10.tar.gz">
	afp-Key_Agreement_Strong_Adversaries-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Key_Agreement_Strong_Adversaries-2017-02-03.tar.gz">
	afp-Key_Agreement_Strong_Adversaries-2017-02-03.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Kleene_Algebra.html b/web/entries/Kleene_Algebra.html
	--- a/web/entries/Kleene_Algebra.html
	+++ b/web/entries/Kleene_Algebra.html
	@@ -1,243 +1,248 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Kleene Algebra - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">K</font>leene

	<font class="first">A</font>lgebra

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Kleene Algebra</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Alasdair Armstrong,
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a> and
	Tjark Weber (tjark /dot/ weber /at/ it /dot/ uu /dot/ se)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-01-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	These files contain a formalisation of variants of Kleene algebras and
	their most important models as axiomatic type classes in Isabelle/HOL.
	Kleene algebras are foundational structures in computing with
	applications ranging from automata and language theory to computational
	modeling, program construction and verification.
	<p>
	We start with formalising dioids, which are additively idempotent
	semirings, and expand them by axiomatisations of the Kleene star for
	finite iteration and an omega operation for infinite iteration. We
	show that powersets over a given monoid, (regular) languages, sets of
	paths in a graph, sets of computation traces, binary relations and
	formal power series form Kleene algebras, and consider further models
	based on lattices, max-plus semirings and min-plus semirings. We also
	demonstrate that dioids are closed under the formation of matrices
	(proofs for Kleene algebras remain to be completed).
	<p>
	On the one hand we have aimed at a reference formalisation of variants
	of Kleene algebras that covers a wide range of variants and the core
	theorems in a structured and modular way and provides readable proofs
	at text book level. On the other hand, we intend to use this algebraic
	hierarchy and its models as a generic algebraic middle-layer from which
	programming applications can quickly be explored, implemented and verified.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Kleene_Algebra-AFP,
	author = {Alasdair Armstrong and Georg Struth and Tjark Weber},
	title = {Kleene Algebra},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Kleene_Algebra.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="KAD.html">KAD</a>, <a href="KAT_and_DRA.html">KAT_and_DRA</a>, <a href="Multirelations.html">Multirelations</a>, <a href="Quantales.html">Quantales</a>, <a href="Regular_Algebras.html">Regular_Algebras</a>, <a href="Relation_Algebra.html">Relation_Algebra</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Kleene_Algebra/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Kleene_Algebra/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Kleene_Algebra/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Kleene_Algebra-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Kleene_Algebra-2018-08-16.tar.gz">
	+ afp-Kleene_Algebra-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Kleene_Algebra-2017-10-10.tar.gz">
	afp-Kleene_Algebra-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Kleene_Algebra-2016-12-17.tar.gz">
	afp-Kleene_Algebra-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Kleene_Algebra-2016-02-22.tar.gz">
	afp-Kleene_Algebra-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Kleene_Algebra-2015-05-27.tar.gz">
	afp-Kleene_Algebra-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Kleene_Algebra-2014-08-28.tar.gz">
	afp-Kleene_Algebra-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Kleene_Algebra-2013-12-11.tar.gz">
	afp-Kleene_Algebra-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Kleene_Algebra-2013-11-17.tar.gz">
	afp-Kleene_Algebra-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Kleene_Algebra-2013-03-02.tar.gz">
	afp-Kleene_Algebra-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Kleene_Algebra-2013-02-16.tar.gz">
	afp-Kleene_Algebra-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Kleene_Algebra-2013-01-16.tar.gz">
	afp-Kleene_Algebra-2013-01-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Knot_Theory.html b/web/entries/Knot_Theory.html
	--- a/web/entries/Knot_Theory.html
	+++ b/web/entries/Knot_Theory.html
	@@ -1,196 +1,201 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Knot Theory - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">K</font>not

	<font class="first">T</font>heory

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Knot Theory</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	T.V.H. Prathamesh (prathamesh /at/ imsc /dot/ res /dot/ in)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-01-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This work contains a formalization of some topics in knot theory.
	The concepts that were formalized include definitions of tangles, links,
	framed links and link/tangle equivalence. The formalization is based on a
	formulation of links in terms of tangles. We further construct and prove the
	invariance of the Bracket polynomial. Bracket polynomial is an invariant of
	framed links closely linked to the Jones polynomial. This is perhaps the first
	attempt to formalize any aspect of knot theory in an interactive proof assistant.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Knot_Theory-AFP,
	author = {T.V.H. Prathamesh},
	title = {Knot Theory},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Knot_Theory.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Matrix_Tensor.html">Matrix_Tensor</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Knot_Theory/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Knot_Theory/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Knot_Theory/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Knot_Theory-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Knot_Theory-2018-08-16.tar.gz">
	+ afp-Knot_Theory-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Knot_Theory-2017-10-10.tar.gz">
	afp-Knot_Theory-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Knot_Theory-2016-12-17.tar.gz">
	afp-Knot_Theory-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Knot_Theory-2016-02-22.tar.gz">
	afp-Knot_Theory-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Knot_Theory-2016-01-20.tar.gz">
	afp-Knot_Theory-2016-01-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Knuth_Morris_Pratt.html b/web/entries/Knuth_Morris_Pratt.html
	--- a/web/entries/Knuth_Morris_Pratt.html
	+++ b/web/entries/Knuth_Morris_Pratt.html
	@@ -1,197 +1,202 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The string search algorithm by Knuth, Morris and Pratt - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	string

	search

	algorithm

	by

	<font class="first">K</font>nuth,

	<font class="first">M</font>orris

	and

	<font class="first">P</font>ratt

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The string search algorithm by Knuth, Morris and Pratt</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Fabian Hellauer (hellauer /at/ in /dot/ tum /dot/ de) and
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-12-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The Knuth-Morris-Pratt algorithm is often used to show that the
	problem of finding a string <i>s</i> in a text
	<i>t</i> can be solved deterministically in
	<i>O(\|s\| + \|t\|)</i> time. We use the Isabelle
	Refinement Framework to formulate and verify the algorithm. Via
	refinement, we apply some optimisations and finally use the
	<em>Sepref</em> tool to obtain executable code in
	<em>Imperative/HOL</em>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Knuth_Morris_Pratt-AFP,
	author = {Fabian Hellauer and Peter Lammich},
	title = {The string search algorithm by Knuth, Morris and Pratt},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Knuth_Morris_Pratt.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Knuth_Morris_Pratt/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Knuth_Morris_Pratt/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Knuth_Morris_Pratt/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Knuth_Morris_Pratt-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Knuth_Morris_Pratt-2018-08-16.tar.gz">
	+ afp-Knuth_Morris_Pratt-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Knuth_Morris_Pratt-2017-12-18.tar.gz">
	afp-Knuth_Morris_Pratt-2017-12-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Koenigsberg_Friendship.html b/web/entries/Koenigsberg_Friendship.html
	--- a/web/entries/Koenigsberg_Friendship.html
	+++ b/web/entries/Koenigsberg_Friendship.html
	@@ -1,221 +1,226 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Königsberg Bridge Problem and the Friendship Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">K</font>önigsberg

	<font class="first">B</font>ridge

	<font class="first">P</font>roblem

	and

	the

	<font class="first">F</font>riendship

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Königsberg Bridge Problem and the Friendship Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-07-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This development provides a formalization of undirected graphs and simple graphs, which are based on Benedikt Nordhoff and Peter Lammich's simple formalization of labelled directed graphs in the archive. Then, with our formalization of graphs, we show both necessary and sufficient conditions for Eulerian trails and circuits as well as the fact that the Königsberg Bridge Problem does not have a solution. In addition, we show the Friendship Theorem in simple graphs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Koenigsberg_Friendship-AFP,
	author = {Wenda Li},
	title = {The Königsberg Bridge Problem and the Friendship Theorem},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Koenigsberg_Friendship.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Dijkstra_Shortest_Path.html">Dijkstra_Shortest_Path</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Koenigsberg_Friendship/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Koenigsberg_Friendship/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Koenigsberg_Friendship/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Koenigsberg_Friendship-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Koenigsberg_Friendship-2018-08-16.tar.gz">
	+ afp-Koenigsberg_Friendship-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Koenigsberg_Friendship-2017-10-10.tar.gz">
	afp-Koenigsberg_Friendship-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Koenigsberg_Friendship-2016-12-17.tar.gz">
	afp-Koenigsberg_Friendship-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Koenigsberg_Friendship-2016-02-22.tar.gz">
	afp-Koenigsberg_Friendship-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Koenigsberg_Friendship-2015-05-27.tar.gz">
	afp-Koenigsberg_Friendship-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Koenigsberg_Friendship-2014-08-28.tar.gz">
	afp-Koenigsberg_Friendship-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Koenigsberg_Friendship-2013-12-11.tar.gz">
	afp-Koenigsberg_Friendship-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Koenigsberg_Friendship-2013-11-17.tar.gz">
	afp-Koenigsberg_Friendship-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Koenigsberg_Friendship-2013-07-26.tar.gz">
	afp-Koenigsberg_Friendship-2013-07-26.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Kruskal.html b/web/entries/Kruskal.html
	--- a/web/entries/Kruskal.html
	+++ b/web/entries/Kruskal.html
	@@ -1,186 +1,192 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Kruskal's Algorithm for Minimum Spanning Forest - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">K</font>ruskal's

	<font class="first">A</font>lgorithm

	for

	<font class="first">M</font>inimum

	<font class="first">S</font>panning

	<font class="first">F</font>orest

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Kruskal's Algorithm for Minimum Spanning Forest</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~haslbema/">Maximilian P.L. Haslbeck</a>,
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	Julian Biendarra
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-02-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This Isabelle/HOL formalization defines a greedy algorithm for finding
	a minimum weight basis on a weighted matroid and proves its
	correctness. This algorithm is an abstract version of Kruskal's
	algorithm. We interpret the abstract algorithm for the cycle matroid
	(i.e. forests in a graph) and refine it to imperative executable code
	using an efficient union-find data structure. Our formalization can
	be instantiated for different graph representations. We provide
	instantiations for undirected graphs and symmetric directed graphs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Kruskal-AFP,
	author = {Maximilian P.L. Haslbeck and Peter Lammich and Julian Biendarra},
	title = {Kruskal's Algorithm for Minimum Spanning Forest},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Kruskal.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="Matroids.html">Matroids</a>, <a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a>, <a href="Refine_Monadic.html">Refine_Monadic</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Kruskal/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Kruskal/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Kruskal/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Kruskal-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Kruskal-2019-02-19.tar.gz">
	+ afp-Kruskal-2019-02-19.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Kuratowski_Closure_Complement.html b/web/entries/Kuratowski_Closure_Complement.html
	--- a/web/entries/Kuratowski_Closure_Complement.html
	+++ b/web/entries/Kuratowski_Closure_Complement.html
	@@ -1,183 +1,188 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Kuratowski Closure-Complement Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">K</font>uratowski

	<font class="first">C</font>losure-Complement

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Kuratowski Closure-Complement Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a> and
	Gianpaolo Gioiosa
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-10-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We discuss a topological curiosity discovered by Kuratowski (1922):
	the fact that the number of distinct operators on a topological space
	generated by compositions of closure and complement never exceeds 14,
	and is exactly 14 in the case of R. In addition, we prove a theorem
	due to Chagrov (1982) that classifies topological spaces according to
	the number of such operators they support.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Kuratowski_Closure_Complement-AFP,
	author = {Peter Gammie and Gianpaolo Gioiosa},
	title = {The Kuratowski Closure-Complement Theorem},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Kuratowski_Closure_Complement.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Kuratowski_Closure_Complement/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Kuratowski_Closure_Complement/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Kuratowski_Closure_Complement/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Kuratowski_Closure_Complement-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Kuratowski_Closure_Complement-2018-08-16.tar.gz">
	+ afp-Kuratowski_Closure_Complement-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Kuratowski_Closure_Complement-2017-10-27.tar.gz">
	afp-Kuratowski_Closure_Complement-2017-10-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LLL_Basis_Reduction.html b/web/entries/LLL_Basis_Reduction.html
	--- a/web/entries/LLL_Basis_Reduction.html
	+++ b/web/entries/LLL_Basis_Reduction.html
	@@ -1,203 +1,213 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A verified LLL algorithm - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	verified

	<font class="first">L</font>LL

	algorithm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A verified LLL algorithm</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/users/bottesch/">Ralph Bottesch</a>,
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
	<a href="https://home.in.tum.de/~haslbecm">Maximilian Haslbeck</a>,
	<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a> and
	Akihisa Yamada (ayamada /at/ trs /dot/ cm /dot/ is /dot/ nagoya-u /dot/ ac /dot/ jp)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-02-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The Lenstra-Lenstra-Lovász basis reduction algorithm, also known as
	LLL algorithm, is an algorithm to find a basis with short, nearly
	orthogonal vectors of an integer lattice. Thereby, it can also be seen
	as an approximation to solve the shortest vector problem (SVP), which
	is an NP-hard problem, where the approximation quality solely depends
	on the dimension of the lattice, but not the lattice itself. The
	algorithm also possesses many applications in diverse fields of
	computer science, from cryptanalysis to number theory, but it is
	specially well-known since it was used to implement the first
	polynomial-time algorithm to factor polynomials. In this work we
	present the first mechanized soundness proof of the LLL algorithm to
	compute short vectors in lattices. The formalization follows a
	textbook by von zur Gathen and Gerhard.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-04-16]: Integrated formal complexity bounds (Haslbeck, Thiemann)
	[2018-05-25]: Integrated much faster LLL implementation based on integer arithmetic (Bottesch, Haslbeck, Thiemann)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LLL_Basis_Reduction-AFP,
	author = {Ralph Bottesch and Jose Divasón and Maximilian Haslbeck and Sebastiaan Joosten and René Thiemann and Akihisa Yamada},
	title = {A verified LLL algorithm},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/LLL_Basis_Reduction.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Algebraic_Numbers.html">Algebraic_Numbers</a>, <a href="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	- <td class="data"><a href="LLL_Factorization.html">LLL_Factorization</a> </td></tr>
	+ <td class="data"><a href="Linear_Inequalities.html">Linear_Inequalities</a>, <a href="LLL_Factorization.html">LLL_Factorization</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LLL_Basis_Reduction/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LLL_Basis_Reduction/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LLL_Basis_Reduction/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LLL_Basis_Reduction-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LLL_Basis_Reduction-2018-09-07.tar.gz">
	+ afp-LLL_Basis_Reduction-2018-09-07.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LLL_Basis_Reduction-2018-08-16.tar.gz">
	+ afp-LLL_Basis_Reduction-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LLL_Basis_Reduction-2018-02-03.tar.gz">
	afp-LLL_Basis_Reduction-2018-02-03.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LLL_Factorization.html b/web/entries/LLL_Factorization.html
	--- a/web/entries/LLL_Factorization.html
	+++ b/web/entries/LLL_Factorization.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A verified factorization algorithm for integer polynomials with polynomial complexity - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	verified

	factorization

	algorithm

	for

	integer

	polynomials

	with

	polynomial

	complexity

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A verified factorization algorithm for integer polynomials with polynomial complexity</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
	<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a> and
	Akihisa Yamada (ayamada /at/ trs /dot/ cm /dot/ is /dot/ nagoya-u /dot/ ac /dot/ jp)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-02-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Short vectors in lattices and factors of integer polynomials are
	related. Each factor of an integer polynomial belongs to a certain
	lattice. When factoring polynomials, the condition that we are looking
	for an irreducible polynomial means that we must look for a small
	element in a lattice, which can be done by a basis reduction
	algorithm. In this development we formalize this connection and
	thereby one main application of the LLL basis reduction algorithm: an
	algorithm to factor square-free integer polynomials which runs in
	polynomial time. The work is based on our previous
	Berlekamp–Zassenhaus development, where the exponential reconstruction
	phase has been replaced by the polynomial-time basis reduction
	algorithm. Thanks to this formalization we found a serious flaw in a
	textbook.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LLL_Factorization-AFP,
	author = {Jose Divasón and Sebastiaan Joosten and René Thiemann and Akihisa Yamada},
	title = {A verified factorization algorithm for integer polynomials with polynomial complexity},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/LLL_Factorization.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="LLL_Basis_Reduction.html">LLL_Basis_Reduction</a>, <a href="Perron_Frobenius.html">Perron_Frobenius</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LLL_Factorization/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LLL_Factorization/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LLL_Factorization/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LLL_Factorization-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LLL_Factorization-2018-08-16.tar.gz">
	+ afp-LLL_Factorization-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LLL_Factorization-2018-02-07.tar.gz">
	afp-LLL_Factorization-2018-02-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LOFT.html b/web/entries/LOFT.html
	--- a/web/entries/LOFT.html
	+++ b/web/entries/LOFT.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>LOFT — Verified Migration of Linux Firewalls to SDN - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>OFT

	<font class="first">—</font>

	<font class="first">V</font>erified

	<font class="first">M</font>igration

	of

	<font class="first">L</font>inux

	<font class="first">F</font>irewalls

	to

	<font class="first">S</font>DN

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">LOFT — Verified Migration of Linux Firewalls to SDN</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://liftm.de">Julius Michaelis</a> and
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-10-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present LOFT — Linux firewall OpenFlow Translator, a system that
	transforms the main routing table and FORWARD chain of iptables of a
	Linux-based firewall into a set of static OpenFlow rules. Our
	implementation is verified against a model of a simplified Linux-based
	router and we can directly show how much of the original functionality
	is preserved.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LOFT-AFP,
	author = {Julius Michaelis and Cornelius Diekmann},
	title = {LOFT — Verified Migration of Linux Firewalls to SDN},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/LOFT.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Iptables_Semantics.html">Iptables_Semantics</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LOFT/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LOFT/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LOFT/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LOFT-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LOFT-2018-08-16.tar.gz">
	+ afp-LOFT-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LOFT-2017-10-10.tar.gz">
	afp-LOFT-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-LOFT-2016-12-17.tar.gz">
	afp-LOFT-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-LOFT-2016-10-21.tar.gz">
	afp-LOFT-2016-10-21.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LTL.html b/web/entries/LTL.html
	--- a/web/entries/LTL.html
	+++ b/web/entries/LTL.html
	@@ -1,208 +1,213 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Linear Temporal Logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>inear

	<font class="first">T</font>emporal

	<font class="first">L</font>ogic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Linear Temporal Logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Salomon Sickert (s /dot/ sickert /at/ tum /dot/ de)
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	Benedikt Seidl (benedikt /dot/ seidl /at/ tum /dot/ de)
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-03-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This theory provides a formalisation of linear temporal logic (LTL)
	and unifies previous formalisations within the AFP. This entry
	establishes syntax and semantics for this logic and decouples it from
	existing entries, yielding a common environment for theories reasoning
	about LTL. Furthermore a parser written in SML and an executable
	simplifier are provided.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2019-03-12]:
	Support for additional operators, implementation of common equivalence relations,
	definition of syntactic fragments of LTL and the minimal disjunctive normal form. <br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LTL-AFP,
	author = {Salomon Sickert},
	title = {Linear Temporal Logic},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/LTL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Boolean_Expression_Checkers.html">Boolean_Expression_Checkers</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="LTL_Master_Theorem.html">LTL_Master_Theorem</a>, <a href="LTL_to_DRA.html">LTL_to_DRA</a>, <a href="LTL_to_GBA.html">LTL_to_GBA</a>, <a href="Promela.html">Promela</a>, <a href="Stuttering_Equivalence.html">Stuttering_Equivalence</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LTL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LTL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LTL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LTL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LTL-2018-08-16.tar.gz">
	+ afp-LTL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LTL-2017-10-10.tar.gz">
	afp-LTL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-LTL-2016-12-17.tar.gz">
	afp-LTL-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-LTL-2016-03-02.tar.gz">
	afp-LTL-2016-03-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LTL_Master_Theorem.html b/web/entries/LTL_Master_Theorem.html
	--- a/web/entries/LTL_Master_Theorem.html
	+++ b/web/entries/LTL_Master_Theorem.html
	@@ -1,197 +1,203 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Compositional and Unified Translation of LTL into ω-Automata - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">C</font>ompositional

	and

	<font class="first">U</font>nified

	<font class="first">T</font>ranslation

	of

	<font class="first">L</font>TL

	into

	ω-Automata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Compositional and Unified Translation of LTL into ω-Automata</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Benedikt Seidl (benedikt /dot/ seidl /at/ tum /dot/ de) and
	Salomon Sickert (s /dot/ sickert /at/ tum /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-04-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formalisation of the unified translation approach of
	linear temporal logic (LTL) into ω-automata from [1]. This approach
	decomposes LTL formulas into ``simple'' languages and allows
	a clear separation of concerns: first, we formalise the purely logical
	result yielding this decomposition; second, we instantiate this
	generic theory to obtain a construction for deterministic
	(state-based) Rabin automata (DRA). We extract from this particular
	instantiation an executable tool translating LTL to DRAs. To the best
	of our knowledge this is the first verified translation from LTL to
	DRAs that is proven to be double exponential in the worst case which
	asymptotically matches the known lower bound.
	<p>
	[1] Javier Esparza, Jan Kretínský, Salomon Sickert. One Theorem to Rule Them All:
	A Unified Translation of LTL into ω-Automata. LICS 2018</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LTL_Master_Theorem-AFP,
	author = {Benedikt Seidl and Salomon Sickert},
	title = {A Compositional and Unified Translation of LTL into ω-Automata},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/LTL_Master_Theorem.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="LTL.html">LTL</a>, <a href="Transition_Systems_and_Automata.html">Transition_Systems_and_Automata</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LTL_Master_Theorem/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LTL_Master_Theorem/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LTL_Master_Theorem/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LTL_Master_Theorem-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LTL_Master_Theorem-2019-04-17.tar.gz">
	+ afp-LTL_Master_Theorem-2019-04-17.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LTL_to_DRA.html b/web/entries/LTL_to_DRA.html
	--- a/web/entries/LTL_to_DRA.html
	+++ b/web/entries/LTL_to_DRA.html
	@@ -1,208 +1,213 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Converting Linear Temporal Logic to Deterministic (Generalized) Rabin Automata - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>onverting

	<font class="first">L</font>inear

	<font class="first">T</font>emporal

	<font class="first">L</font>ogic

	to

	<font class="first">D</font>eterministic

	<font class="first">(</font>Generalized)

	<font class="first">R</font>abin

	<font class="first">A</font>utomata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Converting Linear Temporal Logic to Deterministic (Generalized) Rabin Automata</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Salomon Sickert (s /dot/ sickert /at/ tum /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-09-04</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[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.<br>
	[2016-03-24]: Make use of the LTL entry and include the simplifier.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/LTL_to_DRA.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Boolean_Expression_Checkers.html">Boolean_Expression_Checkers</a>, <a href="KBPs.html">KBPs</a>, <a href="List-Index.html">List-Index</a>, <a href="LTL.html">LTL</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LTL_to_DRA/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LTL_to_DRA/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LTL_to_DRA/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LTL_to_DRA-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LTL_to_DRA-2018-08-16.tar.gz">
	+ afp-LTL_to_DRA-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LTL_to_DRA-2017-10-10.tar.gz">
	afp-LTL_to_DRA-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-LTL_to_DRA-2016-12-17.tar.gz">
	afp-LTL_to_DRA-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-LTL_to_DRA-2016-02-22.tar.gz">
	afp-LTL_to_DRA-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-LTL_to_DRA-2015-09-04.tar.gz">
	afp-LTL_to_DRA-2015-09-04.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LTL_to_GBA.html b/web/entries/LTL_to_GBA.html
	--- a/web/entries/LTL_to_GBA.html
	+++ b/web/entries/LTL_to_GBA.html
	@@ -1,225 +1,230 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Converting Linear-Time Temporal Logic to Generalized Büchi Automata - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>onverting

	<font class="first">L</font>inear-Time

	<font class="first">T</font>emporal

	<font class="first">L</font>ogic

	to

	<font class="first">G</font>eneralized

	<font class="first">B</font>üchi

	<font class="first">A</font>utomata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Converting Linear-Time Temporal Logic to Generalized Büchi Automata</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Alexander Schimpf (schimpfa /at/ informatik /dot/ uni-freiburg /dot/ de) and
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-05-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	<p>
	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.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/LTL_to_GBA.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CAVA_Automata.html">CAVA_Automata</a>, <a href="LTL.html">LTL</a>, <a href="Stuttering_Equivalence.html">Stuttering_Equivalence</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CAVA_LTL_Modelchecker.html">CAVA_LTL_Modelchecker</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LTL_to_GBA/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LTL_to_GBA/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LTL_to_GBA/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LTL_to_GBA-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LTL_to_GBA-2018-08-16.tar.gz">
	+ afp-LTL_to_GBA-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LTL_to_GBA-2017-10-10.tar.gz">
	afp-LTL_to_GBA-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-LTL_to_GBA-2016-12-17.tar.gz">
	afp-LTL_to_GBA-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-LTL_to_GBA-2016-02-22.tar.gz">
	afp-LTL_to_GBA-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-LTL_to_GBA-2015-05-27.tar.gz">
	afp-LTL_to_GBA-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-LTL_to_GBA-2014-08-28.tar.gz">
	afp-LTL_to_GBA-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-LTL_to_GBA-2014-05-29.tar.gz">
	afp-LTL_to_GBA-2014-05-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lam-ml-Normalization.html b/web/entries/Lam-ml-Normalization.html
	--- a/web/entries/Lam-ml-Normalization.html
	+++ b/web/entries/Lam-ml-Normalization.html
	@@ -1,235 +1,240 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Strong Normalization of Moggis's Computational Metalanguage - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>trong

	<font class="first">N</font>ormalization

	of

	<font class="first">M</font>oggis's

	<font class="first">C</font>omputational

	<font class="first">M</font>etalanguage

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Strong Normalization of Moggis's Computational Metalanguage</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Christian Doczkal (doczkal /at/ ps /dot/ uni-saarland /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-08-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Handling variable binding is one of the main difficulties in formal proofs. In this context, Moggi's computational metalanguage serves as an interesting case study. It features monadic types and a commuting conversion rule that rearranges the binding structure. Lindley and Stark have given an elegant proof of strong normalization for this calculus. The key construction in their proof is a notion of relational TT-lifting, using stacks of elimination contexts to obtain a Girard-Tait style logical relation. I give a formalization of their proof in Isabelle/HOL-Nominal with a particular emphasis on the treatment of bound variables.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lam-ml-Normalization-AFP,
	author = {Christian Doczkal},
	title = {Strong Normalization of Moggis's Computational Metalanguage},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Lam-ml-Normalization.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lam-ml-Normalization/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lam-ml-Normalization/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lam-ml-Normalization/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lam-ml-Normalization-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lam-ml-Normalization-2018-08-16.tar.gz">
	+ afp-Lam-ml-Normalization-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lam-ml-Normalization-2017-10-10.tar.gz">
	afp-Lam-ml-Normalization-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Lam-ml-Normalization-2016-12-17.tar.gz">
	afp-Lam-ml-Normalization-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Lam-ml-Normalization-2016-02-22.tar.gz">
	afp-Lam-ml-Normalization-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Lam-ml-Normalization-2015-05-27.tar.gz">
	afp-Lam-ml-Normalization-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Lam-ml-Normalization-2014-08-28.tar.gz">
	afp-Lam-ml-Normalization-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Lam-ml-Normalization-2013-12-11.tar.gz">
	afp-Lam-ml-Normalization-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Lam-ml-Normalization-2013-11-17.tar.gz">
	afp-Lam-ml-Normalization-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Lam-ml-Normalization-2013-02-16.tar.gz">
	afp-Lam-ml-Normalization-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Lam-ml-Normalization-2012-05-24.tar.gz">
	afp-Lam-ml-Normalization-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Lam-ml-Normalization-2011-10-11.tar.gz">
	afp-Lam-ml-Normalization-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Lam-ml-Normalization-2011-02-11.tar.gz">
	afp-Lam-ml-Normalization-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Lam-ml-Normalization-2010-09-01.tar.gz">
	afp-Lam-ml-Normalization-2010-09-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LambdaAuth.html b/web/entries/LambdaAuth.html
	--- a/web/entries/LambdaAuth.html
	+++ b/web/entries/LambdaAuth.html
	@@ -1,193 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of Generic Authenticated Data Structures - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	<font class="first">G</font>eneric

	<font class="first">A</font>uthenticated

	<font class="first">D</font>ata

	<font class="first">S</font>tructures

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of Generic Authenticated Data Structures</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Matthias Brun and
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-05-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Authenticated data structures are a technique for outsourcing data
	storage and maintenance to an untrusted server. The server is required
	to produce an efficiently checkable and cryptographically secure proof
	that it carried out precisely the requested computation. <a
	href="https://doi.org/10.1145/2535838.2535851">Miller et
	al.</a> introduced λ• (pronounced
	<i>lambda auth</i>)—a functional programming
	language with a built-in primitive authentication construct, which
	supports a wide range of user-specified authenticated data structures
	while guaranteeing certain correctness and security properties for all
	well-typed programs. We formalize λ• and prove its
	correctness and security properties. With Isabelle's help, we
	uncover and repair several mistakes in the informal proofs and lemma
	statements. Our findings are summarized in a <a
	href="http://people.inf.ethz.ch/trayteld/papers/lambdaauth/lambdaauth.pdf">paper
	draft</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LambdaAuth-AFP,
	author = {Matthias Brun and Dmitriy Traytel},
	title = {Formalization of Generic Authenticated Data Structures},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/LambdaAuth.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Nominal2.html">Nominal2</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LambdaAuth/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LambdaAuth/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LambdaAuth/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LambdaAuth-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LambdaAuth-2019-05-15.tar.gz">
	+ afp-LambdaAuth-2019-05-15.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LambdaMu.html b/web/entries/LambdaMu.html
	--- a/web/entries/LambdaMu.html
	+++ b/web/entries/LambdaMu.html
	@@ -1,187 +1,192 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The LambdaMu-calculus - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">L</font>ambdaMu-calculus

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The LambdaMu-calculus</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Cristina Matache (cris /dot/ matache /at/ gmail /dot/ com),
	Victor B. F. Gomes (vb358 /at/ cl /dot/ cam /dot/ ac /dot/ uk) and
	Dominic P. Mulligan (Dominic /dot/ Mulligan /at/ arm /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-08-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The propositions-as-types correspondence is ordinarily presented as
	linking the metatheory of typed λ-calculi and the proof theory of
	intuitionistic logic. Griffin observed that this correspondence could
	be extended to classical logic through the use of control operators.
	This observation set off a flurry of further research, leading to the
	development of Parigots λμ-calculus. In this work, we formalise λμ-
	calculus in Isabelle/HOL and prove several metatheoretical properties
	such as type preservation and progress.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LambdaMu-AFP,
	author = {Cristina Matache and Victor B. F. Gomes and Dominic P. Mulligan},
	title = {The LambdaMu-calculus},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/LambdaMu.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LambdaMu/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LambdaMu/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LambdaMu/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LambdaMu-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LambdaMu-2018-08-16.tar.gz">
	+ afp-LambdaMu-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LambdaMu-2017-10-10.tar.gz">
	afp-LambdaMu-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-LambdaMu-2017-08-21.tar.gz">
	afp-LambdaMu-2017-08-21.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lambda_Free_EPO.html b/web/entries/Lambda_Free_EPO.html
	--- a/web/entries/Lambda_Free_EPO.html
	+++ b/web/entries/Lambda_Free_EPO.html
	@@ -1,189 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of the Embedding Path Order for Lambda-Free Higher-Order Terms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	the

	<font class="first">E</font>mbedding

	<font class="first">P</font>ath

	<font class="first">O</font>rder

	for

	<font class="first">L</font>ambda-Free

	<font class="first">H</font>igher-Order

	<font class="first">T</font>erms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of the Embedding Path Order for Lambda-Free Higher-Order Terms</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Alexander Bentkamp (bentkamp /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-10-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This Isabelle/HOL formalization defines the Embedding Path Order (EPO)
	for higher-order terms without lambda-abstraction and proves many
	useful properties about it. In contrast to the lambda-free recursive
	path orders, it does not fully coincide with RPO on first-order terms,
	but it is compatible with arbitrary higher-order contexts.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lambda_Free_EPO-AFP,
	author = {Alexander Bentkamp},
	title = {Formalization of the Embedding Path Order for Lambda-Free Higher-Order Terms},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Lambda_Free_EPO.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Lambda_Free_RPOs.html">Lambda_Free_RPOs</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lambda_Free_EPO/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lambda_Free_EPO/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lambda_Free_EPO/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lambda_Free_EPO-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lambda_Free_EPO-2018-10-21.tar.gz">
	+ afp-Lambda_Free_EPO-2018-10-21.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lambda_Free_KBOs.html b/web/entries/Lambda_Free_KBOs.html
	--- a/web/entries/Lambda_Free_KBOs.html
	+++ b/web/entries/Lambda_Free_KBOs.html
	@@ -1,194 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of Knuth–Bendix Orders for Lambda-Free Higher-Order Terms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	<font class="first">K</font>nuth–Bendix

	<font class="first">O</font>rders

	for

	<font class="first">L</font>ambda-Free

	<font class="first">H</font>igher-Order

	<font class="first">T</font>erms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of Knuth–Bendix Orders for Lambda-Free Higher-Order Terms</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Heiko Becker (hbecker /at/ mpi-sws /dot/ org),
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl),
	Uwe Waldmann (uwe /at/ mpi-inf /dot/ mpg /dot/ de) and
	Daniel Wand (dwand /at/ mpi-inf /dot/ mpg /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-11-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This Isabelle/HOL formalization defines Knuth–Bendix orders for higher-order terms without lambda-abstraction and proves many useful properties about them. The main order fully coincides with the standard transfinite KBO with subterm coefficients on first-order terms. It appears promising as the basis of a higher-order superposition calculus.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lambda_Free_KBOs-AFP,
	author = {Heiko Becker and Jasmin Christian Blanchette and Uwe Waldmann and Daniel Wand},
	title = {Formalization of Knuth–Bendix Orders for Lambda-Free Higher-Order Terms},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Lambda_Free_KBOs.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Lambda_Free_RPOs.html">Lambda_Free_RPOs</a>, <a href="Nested_Multisets_Ordinals.html">Nested_Multisets_Ordinals</a>, <a href="Polynomials.html">Polynomials</a>, <a href="Regular-Sets.html">Regular-Sets</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lambda_Free_KBOs/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lambda_Free_KBOs/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lambda_Free_KBOs/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lambda_Free_KBOs-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lambda_Free_KBOs-2018-08-16.tar.gz">
	+ afp-Lambda_Free_KBOs-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lambda_Free_KBOs-2017-10-10.tar.gz">
	afp-Lambda_Free_KBOs-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Lambda_Free_KBOs-2016-12-17.tar.gz">
	afp-Lambda_Free_KBOs-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lambda_Free_RPOs.html b/web/entries/Lambda_Free_RPOs.html
	--- a/web/entries/Lambda_Free_RPOs.html
	+++ b/web/entries/Lambda_Free_RPOs.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of Recursive Path Orders for Lambda-Free Higher-Order Terms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	<font class="first">R</font>ecursive

	<font class="first">P</font>ath

	<font class="first">O</font>rders

	for

	<font class="first">L</font>ambda-Free

	<font class="first">H</font>igher-Order

	<font class="first">T</font>erms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of Recursive Path Orders for Lambda-Free Higher-Order Terms</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl),
	Uwe Waldmann (uwe /at/ mpi-inf /dot/ mpg /dot/ de) and
	Daniel Wand (dwand /at/ mpi-inf /dot/ mpg /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-09-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This Isabelle/HOL formalization defines recursive path orders (RPOs) for higher-order terms without lambda-abstraction and proves many useful properties about them. The main order fully coincides with the standard RPO on first-order terms also in the presence of currying, distinguishing it from previous work. An optimized variant is formalized as well. It appears promising as the basis of a higher-order superposition calculus.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lambda_Free_RPOs-AFP,
	author = {Jasmin Christian Blanchette and Uwe Waldmann and Daniel Wand},
	title = {Formalization of Recursive Path Orders for Lambda-Free Higher-Order Terms},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Lambda_Free_RPOs.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Higher_Order_Terms.html">Higher_Order_Terms</a>, <a href="Lambda_Free_EPO.html">Lambda_Free_EPO</a>, <a href="Lambda_Free_KBOs.html">Lambda_Free_KBOs</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lambda_Free_RPOs/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lambda_Free_RPOs/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lambda_Free_RPOs/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lambda_Free_RPOs-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lambda_Free_RPOs-2018-08-16.tar.gz">
	+ afp-Lambda_Free_RPOs-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lambda_Free_RPOs-2017-10-10.tar.gz">
	afp-Lambda_Free_RPOs-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Lambda_Free_RPOs-2016-12-17.tar.gz">
	afp-Lambda_Free_RPOs-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Landau_Symbols.html b/web/entries/Landau_Symbols.html
	--- a/web/entries/Landau_Symbols.html
	+++ b/web/entries/Landau_Symbols.html
	@@ -1,189 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Landau Symbols - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>andau

	<font class="first">S</font>ymbols

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Landau Symbols</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-07-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This entry provides Landau symbols to describe and reason about the asymptotic growth of functions for sufficiently large inputs. A number of simplification procedures are provided for additional convenience: cancelling of dominated terms in sums under a Landau symbol, cancelling of common factors in products, and a decision procedure for Landau expressions containing products of powers of functions like x, ln(x), ln(ln(x)) etc.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Landau_Symbols-AFP,
	author = {Manuel Eberl},
	title = {Landau Symbols},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Landau_Symbols.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Akra_Bazzi.html">Akra_Bazzi</a>, <a href="Catalan_Numbers.html">Catalan_Numbers</a>, <a href="Comparison_Sort_Lower_Bound.html">Comparison_Sort_Lower_Bound</a>, <a href="CryptHOL.html">CryptHOL</a>, <a href="Dirichlet_L.html">Dirichlet_L</a>, <a href="Dirichlet_Series.html">Dirichlet_Series</a>, <a href="Error_Function.html">Error_Function</a>, <a href="Euler_MacLaurin.html">Euler_MacLaurin</a>, <a href="Quick_Sort_Cost.html">Quick_Sort_Cost</a>, <a href="Random_BSTs.html">Random_BSTs</a>, <a href="Stirling_Formula.html">Stirling_Formula</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Landau_Symbols/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Landau_Symbols/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Landau_Symbols/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Landau_Symbols-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Landau_Symbols-2018-08-16.tar.gz">
	+ afp-Landau_Symbols-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Landau_Symbols-2017-10-10.tar.gz">
	afp-Landau_Symbols-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Landau_Symbols-2016-12-17.tar.gz">
	afp-Landau_Symbols-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Landau_Symbols-2016-02-22.tar.gz">
	afp-Landau_Symbols-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Landau_Symbols-2015-07-15.tar.gz">
	afp-Landau_Symbols-2015-07-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Latin_Square.html b/web/entries/Latin_Square.html
	--- a/web/entries/Latin_Square.html
	+++ b/web/entries/Latin_Square.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Latin Square - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>atin

	<font class="first">S</font>quare

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Latin Square</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Alexander Bentkamp (bentkamp /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	A Latin Square is a n x n table filled with integers from 1 to n where each number appears exactly once in each row and each column. A Latin Rectangle is a partially filled n x n table with r filled rows and n-r empty rows, such that each number appears at most once in each row and each column. The main result of this theory is that any Latin Rectangle can be completed to a Latin Square.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Latin_Square-AFP,
	author = {Alexander Bentkamp},
	title = {Latin Square},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Latin_Square.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Marriage.html">Marriage</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Latin_Square/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Latin_Square/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Latin_Square/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Latin_Square-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Latin_Square-2018-08-16.tar.gz">
	+ afp-Latin_Square-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Latin_Square-2017-10-10.tar.gz">
	afp-Latin_Square-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Latin_Square-2016-12-17.tar.gz">
	afp-Latin_Square-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Latin_Square-2016-02-22.tar.gz">
	afp-Latin_Square-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Latin_Square-2015-12-03.tar.gz">
	afp-Latin_Square-2015-12-03.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LatticeProperties.html b/web/entries/LatticeProperties.html
	--- a/web/entries/LatticeProperties.html
	+++ b/web/entries/LatticeProperties.html
	@@ -1,231 +1,236 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Lattice Properties - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>attice

	<font class="first">P</font>roperties

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Lattice Properties</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Viorel Preoteasa (viorel /dot/ preoteasa /at/ aalto /dot/ fi)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-09-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This formalization introduces and collects some algebraic structures based on lattices and complete lattices for use in other developments. The structures introduced are modular, and lattice ordered groups. In addition to the results proved for the new lattices, this formalization also introduces theorems about latices and complete lattices in general.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2012-01-05]: Removed the theory about distributive complete lattices which is in the standard library now.
	Added a theory about well founded and transitive relations and a result about fixpoints in complete lattices and well founded relations.
	Moved the results about conjunctive and disjunctive functions to a new theory.
	Removed the syntactic classes for inf and sup which are in the standard library now.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LatticeProperties-AFP,
	author = {Viorel Preoteasa},
	title = {Lattice Properties},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/LatticeProperties.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="DataRefinementIBP.html">DataRefinementIBP</a>, <a href="MonoBoolTranAlgebra.html">MonoBoolTranAlgebra</a>, <a href="PseudoHoops.html">PseudoHoops</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LatticeProperties/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LatticeProperties/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LatticeProperties/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LatticeProperties-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LatticeProperties-2018-08-16.tar.gz">
	+ afp-LatticeProperties-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LatticeProperties-2017-10-10.tar.gz">
	afp-LatticeProperties-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-LatticeProperties-2016-12-17.tar.gz">
	afp-LatticeProperties-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-LatticeProperties-2016-02-22.tar.gz">
	afp-LatticeProperties-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-LatticeProperties-2015-05-27.tar.gz">
	afp-LatticeProperties-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-LatticeProperties-2014-08-28.tar.gz">
	afp-LatticeProperties-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-LatticeProperties-2013-12-11.tar.gz">
	afp-LatticeProperties-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-LatticeProperties-2013-11-17.tar.gz">
	afp-LatticeProperties-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-LatticeProperties-2013-02-16.tar.gz">
	afp-LatticeProperties-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-LatticeProperties-2012-05-24.tar.gz">
	afp-LatticeProperties-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-LatticeProperties-2011-10-11.tar.gz">
	afp-LatticeProperties-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-LatticeProperties-2011-09-27.tar.gz">
	afp-LatticeProperties-2011-09-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Launchbury.html b/web/entries/Launchbury.html
	--- a/web/entries/Launchbury.html
	+++ b/web/entries/Launchbury.html
	@@ -1,245 +1,250 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Correctness of Launchbury's Natural Semantics for Lazy Evaluation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">C</font>orrectness

	of

	<font class="first">L</font>aunchbury's

	<font class="first">N</font>atural

	<font class="first">S</font>emantics

	for

	<font class="first">L</font>azy

	<font class="first">E</font>valuation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Correctness of Launchbury's Natural Semantics for Lazy Evaluation</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Joachim Breitner (joachim /at/ cis /dot/ upenn /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-01-31</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">In his seminal paper "Natural Semantics for Lazy Evaluation", John Launchbury proves his semantics correct with respect to a denotational semantics, and outlines an adequacy proof. We have formalized both semantics and machine-checked the correctness proof, clarifying some details. Furthermore, we provide a new and more direct adequacy proof that does not require intermediate operational semantics.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2014-05-24]: Added the proof of adequacy, as well as simplified and improved the existing proofs. Adjusted abstract accordingly.
	[2015-03-16]: Booleans and if-then-else added to syntax and semantics, making this entry suitable to be used by the entry "Call_Arity".</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Launchbury-AFP,
	author = {Joachim Breitner},
	title = {The Correctness of Launchbury's Natural Semantics for Lazy Evaluation},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Launchbury.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="FinFun.html">FinFun</a>, <a href="Nominal2.html">Nominal2</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Call_Arity.html">Call_Arity</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Launchbury/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Launchbury/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Launchbury/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Launchbury-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Launchbury-2018-08-16.tar.gz">
	+ afp-Launchbury-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Launchbury-2017-10-10.tar.gz">
	afp-Launchbury-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Launchbury-2016-12-17.tar.gz">
	afp-Launchbury-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Launchbury-2016-02-22.tar.gz">
	afp-Launchbury-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Launchbury-2015-05-27.tar.gz">
	afp-Launchbury-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Launchbury-2014-08-28.tar.gz">
	afp-Launchbury-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Launchbury-2014-05-25.tar.gz">
	afp-Launchbury-2014-05-25.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Launchbury-2014-05-24.tar.gz">
	afp-Launchbury-2014-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Launchbury-2013-12-11.tar.gz">
	afp-Launchbury-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Launchbury-2013-11-17.tar.gz">
	afp-Launchbury-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Launchbury-2013-02-25.tar.gz">
	afp-Launchbury-2013-02-25.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Launchbury-2013-02-24.tar.gz">
	afp-Launchbury-2013-02-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lazy-Lists-II.html b/web/entries/Lazy-Lists-II.html
	--- a/web/entries/Lazy-Lists-II.html
	+++ b/web/entries/Lazy-Lists-II.html
	@@ -1,268 +1,273 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Lazy Lists II - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>azy

	<font class="first">L</font>ists

	<font class="first">I</font>I

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Lazy Lists II</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Stefan Friedrich
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-04-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This theory contains some useful extensions to the LList (lazy list) theory by <a href="http://www.cl.cam.ac.uk/~lp15/">Larry Paulson</a>, including finite, infinite, and positive llists over an alphabet, as well as the new constants take and drop and the prefix order of llists. Finally, the notions of safety and liveness in the sense of Alpern and Schneider (1985) are defined.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lazy-Lists-II-AFP,
	author = {Stefan Friedrich},
	title = {Lazy Lists II},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Lazy-Lists-II.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Topology.html">Topology</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lazy-Lists-II/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lazy-Lists-II/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lazy-Lists-II/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lazy-Lists-II-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lazy-Lists-II-2018-08-16.tar.gz">
	+ afp-Lazy-Lists-II-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lazy-Lists-II-2017-10-10.tar.gz">
	afp-Lazy-Lists-II-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Lazy-Lists-II-2016-12-17.tar.gz">
	afp-Lazy-Lists-II-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Lazy-Lists-II-2016-02-22.tar.gz">
	afp-Lazy-Lists-II-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Lazy-Lists-II-2015-05-27.tar.gz">
	afp-Lazy-Lists-II-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Lazy-Lists-II-2014-08-28.tar.gz">
	afp-Lazy-Lists-II-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Lazy-Lists-II-2013-12-11.tar.gz">
	afp-Lazy-Lists-II-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Lazy-Lists-II-2013-11-17.tar.gz">
	afp-Lazy-Lists-II-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Lazy-Lists-II-2013-02-16.tar.gz">
	afp-Lazy-Lists-II-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Lazy-Lists-II-2012-05-24.tar.gz">
	afp-Lazy-Lists-II-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Lazy-Lists-II-2011-10-11.tar.gz">
	afp-Lazy-Lists-II-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Lazy-Lists-II-2011-02-11.tar.gz">
	afp-Lazy-Lists-II-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Lazy-Lists-II-2010-07-01.tar.gz">
	afp-Lazy-Lists-II-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Lazy-Lists-II-2009-12-12.tar.gz">
	afp-Lazy-Lists-II-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Lazy-Lists-II-2009-04-29.tar.gz">
	afp-Lazy-Lists-II-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Lazy-Lists-II-2008-06-10.tar.gz">
	afp-Lazy-Lists-II-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Lazy-Lists-II-2007-11-27.tar.gz">
	afp-Lazy-Lists-II-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Lazy-Lists-II-2005-10-14.tar.gz">
	afp-Lazy-Lists-II-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Lazy-Lists-II-2004-05-21.tar.gz">
	afp-Lazy-Lists-II-2004-05-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Lazy-Lists-II-2004-04-27.tar.gz">
	afp-Lazy-Lists-II-2004-04-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lazy_Case.html b/web/entries/Lazy_Case.html
	--- a/web/entries/Lazy_Case.html
	+++ b/web/entries/Lazy_Case.html
	@@ -1,193 +1,198 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Lazifying case constants - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>azifying

	case

	constants

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Lazifying case constants</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-04-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Isabelle's code generator performs various adaptations for target
	languages. Among others, case statements are printed as match
	expressions. Internally, this is a sophisticated procedure, because in
	HOL, case statements are represented as nested calls to the case
	combinators as generated by the datatype package. Furthermore, the
	procedure relies on laziness of match expressions in the target
	language, i.e., that branches guarded by patterns that fail to match
	are not evaluated. Similarly, <tt>if-then-else</tt> is
	printed to the corresponding construct in the target language. This
	entry provides tooling to replace these special cases in the code
	generator by ignoring these target language features, instead printing
	case expressions and <tt>if-then-else</tt> as functions.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lazy_Case-AFP,
	author = {Lars Hupel},
	title = {Lazifying case constants},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Lazy_Case.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Dict_Construction.html">Dict_Construction</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lazy_Case/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lazy_Case/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lazy_Case/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lazy_Case-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lazy_Case-2018-08-16.tar.gz">
	+ afp-Lazy_Case-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lazy_Case-2017-10-10.tar.gz">
	afp-Lazy_Case-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Lazy_Case-2017-04-20.tar.gz">
	afp-Lazy_Case-2017-04-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lehmer.html b/web/entries/Lehmer.html
	--- a/web/entries/Lehmer.html
	+++ b/web/entries/Lehmer.html
	@@ -1,208 +1,213 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Lehmer's Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ehmer's

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Lehmer's Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a> and
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-07-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">In 1927, Lehmer presented criterions for primality, based on the converse of Fermat's litte theorem. This work formalizes the second criterion from Lehmer's paper, a necessary and sufficient condition for primality.
	<p>
	As a side product we formalize some properties of Euler's phi-function,
	the notion of the order of an element of a group, and the cyclicity of the multiplicative group of a finite field.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lehmer-AFP,
	author = {Simon Wimmer and Lars Noschinski},
	title = {Lehmer's Theorem},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Lehmer.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Pratt_Certificate.html">Pratt_Certificate</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lehmer/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lehmer/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lehmer/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lehmer-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lehmer-2018-08-16.tar.gz">
	+ afp-Lehmer-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lehmer-2017-10-10.tar.gz">
	afp-Lehmer-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Lehmer-2016-12-17.tar.gz">
	afp-Lehmer-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Lehmer-2016-02-22.tar.gz">
	afp-Lehmer-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Lehmer-2015-05-27.tar.gz">
	afp-Lehmer-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Lehmer-2014-08-28.tar.gz">
	afp-Lehmer-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Lehmer-2013-12-11.tar.gz">
	afp-Lehmer-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Lehmer-2013-11-17.tar.gz">
	afp-Lehmer-2013-11-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lifting_Definition_Option.html b/web/entries/Lifting_Definition_Option.html
	--- a/web/entries/Lifting_Definition_Option.html
	+++ b/web/entries/Lifting_Definition_Option.html
	@@ -1,208 +1,213 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Lifting Definition Option - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ifting

	<font class="first">D</font>efinition

	<font class="first">O</font>ption

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Lifting Definition Option</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-10-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We implemented a command that can be used to easily generate
	elements of a restricted type <tt>{x :: 'a. P x}</tt>,
	provided the definition is of the form
	<tt>f ys = (if check ys then Some(generate ys :: 'a) else None)</tt> where
	<tt>ys</tt> is a list of variables <tt>y1 ... yn</tt> and
	<tt>check ys ==> P(generate ys)</tt> can be proved.
	<p>
	In principle, such a definition is also directly possible using the
	<tt>lift_definition</tt> command. However, then this definition will not be
	suitable for code-generation. To this end, we automated a more complex
	construction of Joachim Breitner which is amenable for code-generation, and
	where the test <tt>check ys</tt> will only be performed once. In the
	automation, one auxiliary type is created, and Isabelle's lifting- and
	transfer-package is invoked several times.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lifting_Definition_Option-AFP,
	author = {René Thiemann},
	title = {Lifting Definition Option},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Lifting_Definition_Option.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lifting_Definition_Option/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lifting_Definition_Option/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lifting_Definition_Option/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lifting_Definition_Option-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lifting_Definition_Option-2018-08-16.tar.gz">
	+ afp-Lifting_Definition_Option-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lifting_Definition_Option-2017-10-10.tar.gz">
	afp-Lifting_Definition_Option-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Lifting_Definition_Option-2016-12-17.tar.gz">
	afp-Lifting_Definition_Option-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Lifting_Definition_Option-2016-02-22.tar.gz">
	afp-Lifting_Definition_Option-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Lifting_Definition_Option-2015-05-27.tar.gz">
	afp-Lifting_Definition_Option-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Lifting_Definition_Option-2014-10-15.tar.gz">
	afp-Lifting_Definition_Option-2014-10-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LightweightJava.html b/web/entries/LightweightJava.html
	--- a/web/entries/LightweightJava.html
	+++ b/web/entries/LightweightJava.html
	@@ -1,223 +1,228 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Lightweight Java - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ightweight

	<font class="first">J</font>ava

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Lightweight Java</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://rok.strnisa.com/lj/">Rok Strniša</a> and
	<a href="http://research.microsoft.com/people/mattpark/">Matthew Parkinson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-02-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">A fully-formalized and extensible minimal imperative fragment of Java.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LightweightJava-AFP,
	author = {Rok Strniša and Matthew Parkinson},
	title = {Lightweight Java},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/LightweightJava.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LightweightJava/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LightweightJava/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LightweightJava/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LightweightJava-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LightweightJava-2018-08-16.tar.gz">
	+ afp-LightweightJava-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LightweightJava-2017-10-10.tar.gz">
	afp-LightweightJava-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-LightweightJava-2016-12-17.tar.gz">
	afp-LightweightJava-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-LightweightJava-2016-02-22.tar.gz">
	afp-LightweightJava-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-LightweightJava-2015-05-27.tar.gz">
	afp-LightweightJava-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-LightweightJava-2014-08-28.tar.gz">
	afp-LightweightJava-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-LightweightJava-2013-12-11.tar.gz">
	afp-LightweightJava-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-LightweightJava-2013-11-17.tar.gz">
	afp-LightweightJava-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-LightweightJava-2013-02-16.tar.gz">
	afp-LightweightJava-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-LightweightJava-2012-05-24.tar.gz">
	afp-LightweightJava-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-LightweightJava-2011-10-11.tar.gz">
	afp-LightweightJava-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-LightweightJava-2011-03-02.tar.gz">
	afp-LightweightJava-2011-03-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LinearQuantifierElim.html b/web/entries/LinearQuantifierElim.html
	--- a/web/entries/LinearQuantifierElim.html
	+++ b/web/entries/LinearQuantifierElim.html
	@@ -1,268 +1,273 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Quantifier Elimination for Linear Arithmetic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">Q</font>uantifier

	<font class="first">E</font>limination

	for

	<font class="first">L</font>inear

	<font class="first">A</font>rithmetic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Quantifier Elimination for Linear Arithmetic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-01-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This article formalizes quantifier elimination procedures for dense linear orders, linear real arithmetic and Presburger arithmetic. In each case both a DNF-based non-elementary algorithm and one or more (doubly) exponential NNF-based algorithms are formalized, including the well-known algorithms by Ferrante and Rackoff and by Cooper. The NNF-based algorithms for dense linear orders are new but based on Ferrante and Rackoff and on an algorithm by Loos and Weisspfenning which simulates infenitesimals. All algorithms are directly executable. In particular, they yield reflective quantifier elimination procedures for HOL itself. The formalization makes heavy use of locales and is therefore highly modular.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LinearQuantifierElim-AFP,
	author = {Tobias Nipkow},
	title = {Quantifier Elimination for Linear Arithmetic},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/LinearQuantifierElim.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LinearQuantifierElim/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LinearQuantifierElim/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LinearQuantifierElim/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LinearQuantifierElim-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LinearQuantifierElim-2018-08-16.tar.gz">
	+ afp-LinearQuantifierElim-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LinearQuantifierElim-2017-10-10.tar.gz">
	afp-LinearQuantifierElim-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-LinearQuantifierElim-2016-12-17.tar.gz">
	afp-LinearQuantifierElim-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-LinearQuantifierElim-2016-02-22.tar.gz">
	afp-LinearQuantifierElim-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-LinearQuantifierElim-2015-05-27.tar.gz">
	afp-LinearQuantifierElim-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-LinearQuantifierElim-2014-08-28.tar.gz">
	afp-LinearQuantifierElim-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-LinearQuantifierElim-2013-12-11.tar.gz">
	afp-LinearQuantifierElim-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-LinearQuantifierElim-2013-11-17.tar.gz">
	afp-LinearQuantifierElim-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-LinearQuantifierElim-2013-03-02.tar.gz">
	afp-LinearQuantifierElim-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-LinearQuantifierElim-2013-02-16.tar.gz">
	afp-LinearQuantifierElim-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-LinearQuantifierElim-2012-05-24.tar.gz">
	afp-LinearQuantifierElim-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-LinearQuantifierElim-2011-10-11.tar.gz">
	afp-LinearQuantifierElim-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-LinearQuantifierElim-2011-02-11.tar.gz">
	afp-LinearQuantifierElim-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-LinearQuantifierElim-2010-07-01.tar.gz">
	afp-LinearQuantifierElim-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-LinearQuantifierElim-2009-12-12.tar.gz">
	afp-LinearQuantifierElim-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-LinearQuantifierElim-2009-04-29.tar.gz">
	afp-LinearQuantifierElim-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-LinearQuantifierElim-2008-06-10.tar.gz">
	afp-LinearQuantifierElim-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-LinearQuantifierElim-2008-02-12.tar.gz">
	afp-LinearQuantifierElim-2008-02-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-LinearQuantifierElim-2008-01-24.tar.gz">
	afp-LinearQuantifierElim-2008-01-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-LinearQuantifierElim-2008-01-11.tar.gz">
	afp-LinearQuantifierElim-2008-01-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Linear_Inequalities.html b/web/entries/Linear_Inequalities.html
	new file mode 100644
	--- /dev/null
	+++ b/web/entries/Linear_Inequalities.html
	@@ -0,0 +1,178 @@
	+<!DOCTYPE html>
	+<html lang="en">
	+<head>
	+<meta charset="utf-8">
	+<title>Linear Inequalities - Archive of Formal Proofs
	+</title>
	+<link rel="stylesheet" type="text/css" href="../front.css">
	+<link rel="icon" href="../images/favicon.ico" type="image/icon">
	+<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	+</head>
	+
	+<body>
	+
	+<table width="100%">
	+<tbody>
	+<tr>
	+
	+<!-- Navigation -->
	+<td width="20%" align="center" valign="top">
	+ <p> </p>
	+ <a href="http://isabelle.in.tum.de">
	+ <img src="../images/isabelle.png" width="100" height="86" border=0>
	+ </a>
	+ <p> </p>
	+ <p> </p>
	+ <table class="nav" width="80%">
	+ <tr>
	+ <td class="nav" width="100%"><a href="../index.html">Home</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../about.html">About</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../submitting.html">Submission</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../updating.html">Updating Entries</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../using.html">Using Entries</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../search.html">Search</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../statistics.html">Statistics</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../topics.html">Index</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../download.html">Download</a></td>
	+ </tr>
	+ </table>
	+ <p> </p>
	+ <p> </p>
	+</td>
	+
	+
	+<!-- Content -->
	+<td width="80%" valign="top">
	+<div align="center">
	+ <p> </p>
	+ <h1> <font class="first">L</font>inear
	+
	+ <font class="first">I</font>nequalities
	+
	+</h1>
	+ <p> </p>
	+
	+<table width="80%" class="data">
	+<tbody>
	+<tr>
	+ <td class="datahead" width="20%">Title:</td>
	+ <td class="data" width="80%">Linear Inequalities</td>
	+</tr>
	+
	+<tr>
	+ <td class="datahead">
	+ Authors:
	+ </td>
	+ <td class="data">
	+ <a href="http://cl-informatik.uibk.ac.at/users/bottesch/">Ralph Bottesch</a>,
	+ Alban Reynaud and
	+ <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	+ </td>
	+</tr>
	+
	+
	+
	+<tr>
	+ <td class="datahead">Submission date:</td>
	+ <td class="data">2019-06-21</td>
	+</tr>
	+
	+<tr>
	+ <td class="datahead" valign="top">Abstract:</td>
	+ <td class="abstract">
	+We formalize results about linear inqualities, mainly from
	+Schrijver's book. The main results are the proof of the
	+fundamental theorem on linear inequalities, Farkas' lemma,
	+Carathéodory's theorem, the Farkas-Minkowsky-Weyl theorem, the
	+decomposition theorem of polyhedra, and Meyer's result that the
	+integer hull of a polyhedron is a polyhedron itself. Several theorems
	+include bounds on the appearing numbers, and in particular we provide
	+an a-priori bound on mixed-integer solutions of linear inequalities.</td>
	+</tr>
	+
	+
	+<tr>
	+ <td class="datahead" valign="top">BibTeX:</td>
	+ <td class="formatted">
	+ <pre>@article{Linear_Inequalities-AFP,
	+ author = {Ralph Bottesch and Alban Reynaud and René Thiemann},
	+ title = {Linear Inequalities},
	+ journal = {Archive of Formal Proofs},
	+ month = jun,
	+ year = 2019,
	+ note = {\url{http://isa-afp.org/entries/Linear_Inequalities.html},
	+ Formal proof development},
	+ ISSN = {2150-914x},
	+}</pre>
	+ </td>
	+</tr>
	+
	+ <tr><td class="datahead">License:</td>
	+ <td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>
	+
	+
	+ <tr><td class="datahead">Depends on:</td>
	+ <td class="data"><a href="LLL_Basis_Reduction.html">LLL_Basis_Reduction</a> </td></tr>
	+
	+
	+
	+
	+ </tbody>
	+</table>
	+
	+<p></p>
	+
	+<table class="links">
	+ <tbody>
	+ <tr>
	+ <td class="links">
	+ <a href="../browser_info/current/AFP/Linear_Inequalities/outline.pdf">Proof outline</a><br>
	+ <a href="../browser_info/current/AFP/Linear_Inequalities/document.pdf">Proof document</a>
	+ </td>
	+ </tr>
	+ <tr>
	+ <td class="links">
	+ <a href="../browser_info/current/AFP/Linear_Inequalities/index.html">Browse theories</a>
	+ </td></tr>
	+ <tr>
	+ <td class="links">
	+ <a href="../release/afp-Linear_Inequalities-current.tar.gz">Download this entry</a>
	+ </td>
	+ </tr>
	+
	+
	+ <tr><td class="links">Older releases:
	+ None
	+ </td></tr>
	+
	+ </tbody>
	+</table>
	+
	+</div>
	+</td>
	+
	+</tr>
	+</tbody>
	+</table>
	+
	+<script src="../jquery.min.js"></script>
	+<script src="../script.js"></script>
	+
	+</body>
	+</html>
	\ No newline at end of file
	diff --git a/web/entries/Linear_Recurrences.html b/web/entries/Linear_Recurrences.html
	--- a/web/entries/Linear_Recurrences.html
	+++ b/web/entries/Linear_Recurrences.html
	@@ -1,191 +1,196 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Linear Recurrences - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>inear

	<font class="first">R</font>ecurrences

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Linear Recurrences</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-10-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p> Linear recurrences with constant coefficients are an
	interesting class of recurrence equations that can be solved
	explicitly. The most famous example are certainly the Fibonacci
	numbers with the equation <i>f</i>(<i>n</i>) =
	<i>f</i>(<i>n</i>-1) +
	<i>f</i>(<i>n</i> - 2) and the quite
	non-obvious closed form
	(<i>φ</i><sup><i>n</i></sup>
	-
	(-<i>φ</i>)<sup>-<i>n</i></sup>)
	/ √<span style="text-decoration:
	overline">5</span> where φ is the golden ratio.
	</p> <p> In this work, I build on existing tools in
	Isabelle – such as formal power series and polynomial
	factorisation algorithms – to develop a theory of these
	recurrences and derive a fully executable solver for them that can be
	exported to programming languages like Haskell. </p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Linear_Recurrences-AFP,
	author = {Manuel Eberl},
	title = {Linear Recurrences},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Linear_Recurrences.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Algebraic_Numbers.html">Algebraic_Numbers</a>, <a href="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a>, <a href="Count_Complex_Roots.html">Count_Complex_Roots</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Linear_Recurrences/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Linear_Recurrences/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Linear_Recurrences/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Linear_Recurrences-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Linear_Recurrences-2018-08-16.tar.gz">
	+ afp-Linear_Recurrences-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Linear_Recurrences-2017-10-17.tar.gz">
	afp-Linear_Recurrences-2017-10-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Liouville_Numbers.html b/web/entries/Liouville_Numbers.html
	--- a/web/entries/Liouville_Numbers.html
	+++ b/web/entries/Liouville_Numbers.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Liouville numbers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>iouville

	numbers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Liouville numbers</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	Liouville numbers are a class of transcendental numbers that can be approximated
	particularly well with rational numbers. Historically, they were the first
	numbers whose transcendence was proven.
	</p><p>
	In this entry, we define the concept of Liouville numbers as well as the
	standard construction to obtain Liouville numbers (including Liouville's
	constant) and we prove their most important properties: irrationality and
	transcendence.
	</p><p>
	The proof is very elementary and requires only standard arithmetic, the Mean
	Value Theorem for polynomials, and the boundedness of polynomials on compact
	intervals.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Liouville_Numbers-AFP,
	author = {Manuel Eberl},
	title = {Liouville numbers},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Liouville_Numbers.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Liouville_Numbers/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Liouville_Numbers/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Liouville_Numbers/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Liouville_Numbers-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Liouville_Numbers-2018-08-16.tar.gz">
	+ afp-Liouville_Numbers-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Liouville_Numbers-2017-10-10.tar.gz">
	afp-Liouville_Numbers-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Liouville_Numbers-2016-12-17.tar.gz">
	afp-Liouville_Numbers-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Liouville_Numbers-2016-02-22.tar.gz">
	afp-Liouville_Numbers-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Liouville_Numbers-2016-01-05.tar.gz">
	afp-Liouville_Numbers-2016-01-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/List-Index.html b/web/entries/List-Index.html
	--- a/web/entries/List-Index.html
	+++ b/web/entries/List-Index.html
	@@ -1,234 +1,239 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>List Index - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ist

	<font class="first">I</font>ndex

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">List Index</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-02-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This theory provides functions for finding the index of an element in a list, by predicate and by value.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{List-Index-AFP,
	author = {Tobias Nipkow},
	title = {List Index},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/List-Index.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Affine_Arithmetic.html">Affine_Arithmetic</a>, <a href="Comparison_Sort_Lower_Bound.html">Comparison_Sort_Lower_Bound</a>, <a href="Formula_Derivatives.html">Formula_Derivatives</a>, <a href="Higher_Order_Terms.html">Higher_Order_Terms</a>, <a href="Jinja.html">Jinja</a>, <a href="List_Update.html">List_Update</a>, <a href="LTL_to_DRA.html">LTL_to_DRA</a>, <a href="MSO_Regex_Equivalence.html">MSO_Regex_Equivalence</a>, <a href="Nested_Multisets_Ordinals.html">Nested_Multisets_Ordinals</a>, <a href="Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a>, <a href="Planarity_Certificates.html">Planarity_Certificates</a>, <a href="Quick_Sort_Cost.html">Quick_Sort_Cost</a>, <a href="Randomised_Social_Choice.html">Randomised_Social_Choice</a>, <a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List-Index/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/List-Index/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List-Index/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-List-Index-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-List-Index-2018-08-16.tar.gz">
	+ afp-List-Index-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-List-Index-2017-10-10.tar.gz">
	afp-List-Index-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-List-Index-2016-12-17.tar.gz">
	afp-List-Index-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-List-Index-2016-02-22.tar.gz">
	afp-List-Index-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-List-Index-2015-05-27.tar.gz">
	afp-List-Index-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-List-Index-2014-08-28.tar.gz">
	afp-List-Index-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-List-Index-2013-12-11.tar.gz">
	afp-List-Index-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-List-Index-2013-11-17.tar.gz">
	afp-List-Index-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-List-Index-2013-02-16.tar.gz">
	afp-List-Index-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-List-Index-2012-05-24.tar.gz">
	afp-List-Index-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-List-Index-2011-10-11.tar.gz">
	afp-List-Index-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-List-Index-2011-02-11.tar.gz">
	afp-List-Index-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-List-Index-2010-07-01.tar.gz">
	afp-List-Index-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-List-Index-2010-02-20.tar.gz">
	afp-List-Index-2010-02-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/List-Infinite.html b/web/entries/List-Infinite.html
	--- a/web/entries/List-Infinite.html
	+++ b/web/entries/List-Infinite.html
	@@ -1,229 +1,234 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Infinite Lists - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>nfinite

	<font class="first">L</font>ists

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Infinite Lists</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	David Trachtenherz
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-02-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We introduce a theory of infinite lists in HOL formalized as functions over naturals (folder ListInf, theories ListInf and ListInf_Prefix). It also provides additional results for finite lists (theory ListInf/List2), natural numbers (folder CommonArith, esp. division/modulo, naturals with infinity), sets (folder CommonSet, esp. cutting/truncating sets, traversing sets of naturals).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{List-Infinite-AFP,
	author = {David Trachtenherz},
	title = {Infinite Lists},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/List-Infinite.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Nat-Interval-Logic.html">Nat-Interval-Logic</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List-Infinite/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/List-Infinite/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List-Infinite/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-List-Infinite-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-List-Infinite-2018-08-16.tar.gz">
	+ afp-List-Infinite-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-List-Infinite-2017-10-10.tar.gz">
	afp-List-Infinite-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-List-Infinite-2016-12-17.tar.gz">
	afp-List-Infinite-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-List-Infinite-2016-02-22.tar.gz">
	afp-List-Infinite-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-List-Infinite-2015-05-27.tar.gz">
	afp-List-Infinite-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-List-Infinite-2014-08-28.tar.gz">
	afp-List-Infinite-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-List-Infinite-2013-12-11.tar.gz">
	afp-List-Infinite-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-List-Infinite-2013-11-17.tar.gz">
	afp-List-Infinite-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-List-Infinite-2013-03-02.tar.gz">
	afp-List-Infinite-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-List-Infinite-2013-02-16.tar.gz">
	afp-List-Infinite-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-List-Infinite-2012-05-24.tar.gz">
	afp-List-Infinite-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-List-Infinite-2011-10-11.tar.gz">
	afp-List-Infinite-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-List-Infinite-2011-02-24.tar.gz">
	afp-List-Infinite-2011-02-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/List_Interleaving.html b/web/entries/List_Interleaving.html
	--- a/web/entries/List_Interleaving.html
	+++ b/web/entries/List_Interleaving.html
	@@ -1,215 +1,220 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Reasoning about Lists via List Interleaving - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>easoning

	about

	<font class="first">L</font>ists

	via

	<font class="first">L</font>ist

	<font class="first">I</font>nterleaving

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Reasoning about Lists via List Interleaving</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-06-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	Among the various mathematical tools introduced in his outstanding work on
	Communicating Sequential Processes, Hoare has defined "interleaves" as the
	predicate satisfied by any three lists such that the first list may be
	split into sublists alternately extracted from the other two ones, whatever
	is the criterion for extracting an item from either one list or the other
	in each step.
	</p><p>
	This paper enriches Hoare's definition by identifying such criterion with
	the truth value of a predicate taking as inputs the head and the tail of
	the first list. This enhanced "interleaves" predicate turns out to permit
	the proof of equalities between lists without the need of an induction.
	Some rules that allow to infer "interleaves" statements without induction,
	particularly applying to the addition or removal of a prefix to the input
	lists, are also proven. Finally, a stronger version of the predicate, named
	"Interleaves", is shown to fulfil further rules applying to the addition or
	removal of a suffix to the input lists.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{List_Interleaving-AFP,
	author = {Pasquale Noce},
	title = {Reasoning about Lists via List Interleaving},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/List_Interleaving.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Noninterference_Ipurge_Unwinding.html">Noninterference_Ipurge_Unwinding</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List_Interleaving/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/List_Interleaving/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List_Interleaving/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-List_Interleaving-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-List_Interleaving-2018-08-16.tar.gz">
	+ afp-List_Interleaving-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-List_Interleaving-2017-10-10.tar.gz">
	afp-List_Interleaving-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-List_Interleaving-2016-12-17.tar.gz">
	afp-List_Interleaving-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-List_Interleaving-2016-02-22.tar.gz">
	afp-List_Interleaving-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-List_Interleaving-2015-06-13.tar.gz">
	afp-List_Interleaving-2015-06-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/List_Inversions.html b/web/entries/List_Inversions.html
	--- a/web/entries/List_Inversions.html
	+++ b/web/entries/List_Inversions.html
	@@ -1,178 +1,184 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Inversions of a List - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">I</font>nversions

	of

	a

	<font class="first">L</font>ist

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Inversions of a List</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-02-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This entry defines the set of <em>inversions</em>
	of a list, i.e. the pairs of indices that violate sortedness. It also
	proves the correctness of the well-known
	<em>O</em>(<em>n log n</em>)
	divide-and-conquer algorithm to compute the number of
	inversions.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{List_Inversions-AFP,
	author = {Manuel Eberl},
	title = {The Inversions of a List},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/List_Inversions.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List_Inversions/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/List_Inversions/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List_Inversions/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-List_Inversions-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-List_Inversions-2019-02-21.tar.gz">
	+ afp-List_Inversions-2019-02-21.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/List_Update.html b/web/entries/List_Update.html
	--- a/web/entries/List_Update.html
	+++ b/web/entries/List_Update.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Analysis of List Update Algorithms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>nalysis

	of

	<font class="first">L</font>ist

	<font class="first">U</font>pdate

	<font class="first">A</font>lgorithms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Analysis of List Update Algorithms</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~haslbema/">Maximilian P.L. Haslbeck</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-02-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	These theories formalize the quantitative analysis of a number of classical algorithms for the list update problem: 2-competitiveness of move-to-front, the lower bound of 2 for the competitiveness of deterministic list update algorithms and 1.6-competitiveness of the randomized COMB algorithm, the best randomized list update algorithm known to date.
	The material is based on the first two chapters of <i>Online Computation
	and Competitive Analysis</i> by Borodin and El-Yaniv.
	</p>
	<p>
	For an informal description see the FSTTCS 2016 publication
	<a href="http://www21.in.tum.de/~nipkow/pubs/fsttcs16.html">Verified Analysis of List Update Algorithms</a>
	by Haslbeck and Nipkow.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{List_Update-AFP,
	author = {Maximilian P.L. Haslbeck and Tobias Nipkow},
	title = {Analysis of List Update Algorithms},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/List_Update.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="List-Index.html">List-Index</a>, <a href="Regular-Sets.html">Regular-Sets</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List_Update/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/List_Update/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/List_Update/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-List_Update-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-List_Update-2018-08-16.tar.gz">
	+ afp-List_Update-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-List_Update-2017-10-10.tar.gz">
	afp-List_Update-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-List_Update-2016-12-17.tar.gz">
	afp-List_Update-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-List_Update-2016-10-15.tar.gz">
	afp-List_Update-2016-10-15.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-List_Update-2016-02-23.tar.gz">
	afp-List_Update-2016-02-23.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-List_Update-2016-02-22.tar.gz">
	afp-List_Update-2016-02-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/LocalLexing.html b/web/entries/LocalLexing.html
	--- a/web/entries/LocalLexing.html
	+++ b/web/entries/LocalLexing.html
	@@ -1,186 +1,191 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Local Lexing - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ocal

	<font class="first">L</font>exing

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Local Lexing</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Steven Obua (steven /at/ recursivemind /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-04-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This formalisation accompanies the paper <a
	href="https://arxiv.org/abs/1702.03277">Local
	Lexing</a> which introduces a novel parsing concept of the same
	name. The paper also gives a high-level algorithm for local lexing as
	an extension of Earley's algorithm. This formalisation proves the
	algorithm to be correct with respect to its local lexing semantics. As
	a special case, this formalisation thus also contains a proof of the
	correctness of Earley's algorithm. The paper contains a short
	outline of how this formalisation is organised.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{LocalLexing-AFP,
	author = {Steven Obua},
	title = {Local Lexing},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/LocalLexing.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LocalLexing/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/LocalLexing/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/LocalLexing/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-LocalLexing-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-LocalLexing-2018-08-16.tar.gz">
	+ afp-LocalLexing-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-LocalLexing-2017-10-10.tar.gz">
	afp-LocalLexing-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-LocalLexing-2017-04-28.tar.gz">
	afp-LocalLexing-2017-04-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Localization_Ring.html b/web/entries/Localization_Ring.html
	--- a/web/entries/Localization_Ring.html
	+++ b/web/entries/Localization_Ring.html
	@@ -1,185 +1,190 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Localization of a Commutative Ring - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">L</font>ocalization

	of

	a

	<font class="first">C</font>ommutative

	<font class="first">R</font>ing

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Localization of a Commutative Ring</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://sites.google.com/site/anthonybordg/">Anthony Bordg</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-06-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize the localization of a commutative ring R with respect to
	a multiplicative subset (i.e. a submonoid of R seen as a
	multiplicative monoid). This localization is itself a commutative ring
	and we build the natural homomorphism of rings from R to its
	localization.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Localization_Ring-AFP,
	author = {Anthony Bordg},
	title = {The Localization of a Commutative Ring},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Localization_Ring.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Localization_Ring/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Localization_Ring/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Localization_Ring/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Localization_Ring-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Localization_Ring-2018-08-16.tar.gz">
	+ afp-Localization_Ring-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Localization_Ring-2018-06-17.tar.gz">
	afp-Localization_Ring-2018-06-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Locally-Nameless-Sigma.html b/web/entries/Locally-Nameless-Sigma.html
	--- a/web/entries/Locally-Nameless-Sigma.html
	+++ b/web/entries/Locally-Nameless-Sigma.html
	@@ -1,241 +1,246 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Locally Nameless Sigma Calculus - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ocally

	<font class="first">N</font>ameless

	<font class="first">S</font>igma

	<font class="first">C</font>alculus

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Locally Nameless Sigma Calculus</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Ludovic Henrio (Ludovic /dot/ Henrio /at/ sophia /dot/ inria /dot/ fr),
	Florian Kammüller (flokam /at/ cs /dot/ tu-berlin /dot/ de),
	Bianca Lutz (sowilo /at/ cs /dot/ tu-berlin /dot/ de) and
	Henry Sudhof (hsudhof /at/ cs /dot/ tu-berlin /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-04-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We present a Theory of Objects based on the original functional sigma-calculus by Abadi and Cardelli but with an additional parameter to methods. We prove confluence of the operational semantics following the outline of Nipkow's proof of confluence for the lambda-calculus reusing his theory Commutation, a generic diamond lemma reduction. We furthermore formalize a simple type system for our sigma-calculus including a proof of type safety. The entire development uses the concept of Locally Nameless representation for binders. We reuse an earlier proof of confluence for a simpler sigma-calculus based on de Bruijn indices and lists to represent objects.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Locally-Nameless-Sigma-AFP,
	author = {Ludovic Henrio and Florian Kammüller and Bianca Lutz and Henry Sudhof},
	title = {Locally Nameless Sigma Calculus},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Locally-Nameless-Sigma.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Applicative_Lifting.html">Applicative_Lifting</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Locally-Nameless-Sigma/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Locally-Nameless-Sigma/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Locally-Nameless-Sigma/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Locally-Nameless-Sigma-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Locally-Nameless-Sigma-2018-08-16.tar.gz">
	+ afp-Locally-Nameless-Sigma-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Locally-Nameless-Sigma-2017-10-10.tar.gz">
	afp-Locally-Nameless-Sigma-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Locally-Nameless-Sigma-2016-12-17.tar.gz">
	afp-Locally-Nameless-Sigma-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Locally-Nameless-Sigma-2016-02-22.tar.gz">
	afp-Locally-Nameless-Sigma-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Locally-Nameless-Sigma-2015-05-27.tar.gz">
	afp-Locally-Nameless-Sigma-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Locally-Nameless-Sigma-2014-08-28.tar.gz">
	afp-Locally-Nameless-Sigma-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Locally-Nameless-Sigma-2013-12-11.tar.gz">
	afp-Locally-Nameless-Sigma-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Locally-Nameless-Sigma-2013-11-17.tar.gz">
	afp-Locally-Nameless-Sigma-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Locally-Nameless-Sigma-2013-02-16.tar.gz">
	afp-Locally-Nameless-Sigma-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Locally-Nameless-Sigma-2012-05-24.tar.gz">
	afp-Locally-Nameless-Sigma-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Locally-Nameless-Sigma-2011-10-11.tar.gz">
	afp-Locally-Nameless-Sigma-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Locally-Nameless-Sigma-2011-02-11.tar.gz">
	afp-Locally-Nameless-Sigma-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Locally-Nameless-Sigma-2010-07-01.tar.gz">
	afp-Locally-Nameless-Sigma-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Locally-Nameless-Sigma-2010-05-03.tar.gz">
	afp-Locally-Nameless-Sigma-2010-05-03.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lowe_Ontological_Argument.html b/web/entries/Lowe_Ontological_Argument.html
	--- a/web/entries/Lowe_Ontological_Argument.html
	+++ b/web/entries/Lowe_Ontological_Argument.html
	@@ -1,199 +1,204 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Computer-assisted Reconstruction and Assessment of E. J. Lowe's Modal Ontological Argument - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>omputer-assisted

	<font class="first">R</font>econstruction

	and

	<font class="first">A</font>ssessment

	of

	<font class="first">E</font>.

	<font class="first">J</font>.

	<font class="first">L</font>owe's

	<font class="first">M</font>odal

	<font class="first">O</font>ntological

	<font class="first">A</font>rgument

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Computer-assisted Reconstruction and Assessment of E. J. Lowe's Modal Ontological Argument</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	David Fuenmayor (davfuenmayor /at/ gmail /dot/ com) and
	<a href="http://christoph-benzmueller.de">Christoph Benzmüller</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-09-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Computers may help us to understand --not just verify-- philosophical
	arguments. By utilizing modern proof assistants in an iterative
	interpretive process, we can reconstruct and assess an argument by
	fully formal means. Through the mechanization of a variant of St.
	Anselm's ontological argument by E. J. Lowe, which is a
	paradigmatic example of a natural-language argument with strong ties
	to metaphysics and religion, we offer an ideal showcase for our
	computer-assisted interpretive method.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lowe_Ontological_Argument-AFP,
	author = {David Fuenmayor and Christoph Benzmüller},
	title = {Computer-assisted Reconstruction and Assessment of E. J. Lowe's Modal Ontological Argument},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Lowe_Ontological_Argument.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lowe_Ontological_Argument/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lowe_Ontological_Argument/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lowe_Ontological_Argument/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lowe_Ontological_Argument-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lowe_Ontological_Argument-2018-08-16.tar.gz">
	+ afp-Lowe_Ontological_Argument-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lowe_Ontological_Argument-2017-10-16.tar.gz">
	afp-Lowe_Ontological_Argument-2017-10-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lower_Semicontinuous.html b/web/entries/Lower_Semicontinuous.html
	--- a/web/entries/Lower_Semicontinuous.html
	+++ b/web/entries/Lower_Semicontinuous.html
	@@ -1,224 +1,229 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Lower Semicontinuous Functions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ower

	<font class="first">S</font>emicontinuous

	<font class="first">F</font>unctions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Lower Semicontinuous Functions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Bogdan Grechuk (grechukbogdan /at/ yandex /dot/ ru)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-01-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We define the notions of lower and upper semicontinuity for functions from a metric space to the extended real line. We prove that a function is both lower and upper semicontinuous if and only if it is continuous. We also give several equivalent characterizations of lower semicontinuity. In particular, we prove that a function is lower semicontinuous if and only if its epigraph is a closed set. Also, we introduce the notion of the lower semicontinuous hull of an arbitrary function and prove its basic properties.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lower_Semicontinuous-AFP,
	author = {Bogdan Grechuk},
	title = {Lower Semicontinuous Functions},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/Lower_Semicontinuous.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lower_Semicontinuous/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lower_Semicontinuous/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lower_Semicontinuous/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lower_Semicontinuous-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lower_Semicontinuous-2018-08-16.tar.gz">
	+ afp-Lower_Semicontinuous-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lower_Semicontinuous-2017-10-10.tar.gz">
	afp-Lower_Semicontinuous-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Lower_Semicontinuous-2016-12-17.tar.gz">
	afp-Lower_Semicontinuous-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Lower_Semicontinuous-2016-02-22.tar.gz">
	afp-Lower_Semicontinuous-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Lower_Semicontinuous-2015-05-27.tar.gz">
	afp-Lower_Semicontinuous-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Lower_Semicontinuous-2014-08-28.tar.gz">
	afp-Lower_Semicontinuous-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Lower_Semicontinuous-2013-12-11.tar.gz">
	afp-Lower_Semicontinuous-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Lower_Semicontinuous-2013-11-17.tar.gz">
	afp-Lower_Semicontinuous-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Lower_Semicontinuous-2013-02-16.tar.gz">
	afp-Lower_Semicontinuous-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Lower_Semicontinuous-2012-05-24.tar.gz">
	afp-Lower_Semicontinuous-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Lower_Semicontinuous-2011-10-11.tar.gz">
	afp-Lower_Semicontinuous-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Lower_Semicontinuous-2011-02-11.tar.gz">
	afp-Lower_Semicontinuous-2011-02-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Lp.html b/web/entries/Lp.html
	--- a/web/entries/Lp.html
	+++ b/web/entries/Lp.html
	@@ -1,180 +1,185 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Lp spaces - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>p

	spaces

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Lp spaces</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Sebastien Gouezel
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-10-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Lp is the space of functions whose p-th power is integrable. It is one of the most fundamental Banach spaces that is used in analysis and probability. We develop a framework for function spaces, and then implement the Lp spaces in this framework using the existing integration theory in Isabelle/HOL. Our development contains most fundamental properties of Lp spaces, notably the Hölder and Minkowski inequalities, completeness of Lp, duality, stability under almost sure convergence, multiplication of functions in Lp and Lq, stability under conditional expectation.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Lp-AFP,
	author = {Sebastien Gouezel},
	title = {Lp spaces},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Lp.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Ergodic_Theory.html">Ergodic_Theory</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lp/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Lp/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Lp/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Lp-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Lp-2018-08-16.tar.gz">
	+ afp-Lp-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Lp-2017-10-10.tar.gz">
	afp-Lp-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Lp-2016-12-17.tar.gz">
	afp-Lp-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/MFMC_Countable.html b/web/entries/MFMC_Countable.html
	--- a/web/entries/MFMC_Countable.html
	+++ b/web/entries/MFMC_Countable.html
	@@ -1,226 +1,231 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Formal Proof of the Max-Flow Min-Cut Theorem for Countable Networks - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">F</font>ormal

	<font class="first">P</font>roof

	of

	the

	<font class="first">M</font>ax-Flow

	<font class="first">M</font>in-Cut

	<font class="first">T</font>heorem

	for

	<font class="first">C</font>ountable

	<font class="first">N</font>etworks

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Formal Proof of the Max-Flow Min-Cut Theorem for Countable Networks</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This article formalises a proof of the maximum-flow minimal-cut
	theorem for networks with countably many edges. A network is a
	directed graph with non-negative real-valued edge labels and two
	dedicated vertices, the source and the sink. A flow in a network
	assigns non-negative real numbers to the edges such that for all
	vertices except for the source and the sink, the sum of values on
	incoming edges equals the sum of values on outgoing edges. A cut is a
	subset of the vertices which contains the source, but not the sink.
	Our theorem states that in every network, there is a flow and a cut
	such that the flow saturates all the edges going out of the cut and is
	zero on all the incoming edges. The proof is based on the paper
	<emph>The Max-Flow Min-Cut theorem for countable networks</emph> by
	Aharoni et al. Additionally, we prove a characterisation of the
	lifting operation for relations on discrete probability distributions,
	which leads to a concise proof of its distributivity over relation
	composition.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2017-09-06]:
	derive characterisation for the lifting operations on discrete distributions from finite version of the max-flow min-cut theorem
	(revision a7a198f5bab0)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{MFMC_Countable-AFP,
	author = {Andreas Lochbihler},
	title = {A Formal Proof of the Max-Flow Min-Cut Theorem for Countable Networks},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/MFMC_Countable.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="EdmondsKarp_Maxflow.html">EdmondsKarp_Maxflow</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Probabilistic_While.html">Probabilistic_While</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MFMC_Countable/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/MFMC_Countable/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MFMC_Countable/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-MFMC_Countable-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-MFMC_Countable-2018-08-16.tar.gz">
	+ afp-MFMC_Countable-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-MFMC_Countable-2017-10-10.tar.gz">
	afp-MFMC_Countable-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-MFMC_Countable-2016-12-17.tar.gz">
	afp-MFMC_Countable-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-MFMC_Countable-2016-05-09.tar.gz">
	afp-MFMC_Countable-2016-05-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/MSO_Regex_Equivalence.html b/web/entries/MSO_Regex_Equivalence.html
	--- a/web/entries/MSO_Regex_Equivalence.html
	+++ b/web/entries/MSO_Regex_Equivalence.html
	@@ -1,237 +1,242 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Decision Procedures for MSO on Words Based on Derivatives of Regular Expressions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>ecision

	<font class="first">P</font>rocedures

	for

	<font class="first">M</font>SO

	on

	<font class="first">W</font>ords

	<font class="first">B</font>ased

	on

	<font class="first">D</font>erivatives

	of

	<font class="first">R</font>egular

	<font class="first">E</font>xpressions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Decision Procedures for MSO on Words Based on Derivatives of Regular Expressions</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-06-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Monadic second-order logic on finite words (MSO) is a decidable yet
	expressive logic into which many decision problems can be encoded. Since MSO
	formulas correspond to regular languages, equivalence of MSO formulas can be
	reduced to the equivalence of some regular structures (e.g. automata). We
	verify an executable decision procedure for MSO formulas that is not based
	on automata but on regular expressions.
	<p>
	Decision procedures for regular expression equivalence have been formalized
	before, usually based on Brzozowski derivatives. Yet, for a straightforward
	embedding of MSO formulas into regular expressions an extension of regular
	expressions with a projection operation is required. We prove total
	correctness and completeness of an equivalence checker for regular
	expressions extended in that way. We also define a language-preserving
	translation of formulas into regular expressions with respect to two
	different semantics of MSO.
	<p>
	The formalization is described in this <a href="http://www21.in.tum.de/~nipkow/pubs/icfp13.html">ICFP 2013 functional pearl</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{MSO_Regex_Equivalence-AFP,
	author = {Dmitriy Traytel and Tobias Nipkow},
	title = {Decision Procedures for MSO on Words Based on Derivatives of Regular Expressions},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/MSO_Regex_Equivalence.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Deriving.html">Deriving</a>, <a href="List-Index.html">List-Index</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MSO_Regex_Equivalence/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/MSO_Regex_Equivalence/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MSO_Regex_Equivalence/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-MSO_Regex_Equivalence-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-MSO_Regex_Equivalence-2018-08-16.tar.gz">
	+ afp-MSO_Regex_Equivalence-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-MSO_Regex_Equivalence-2017-10-10.tar.gz">
	afp-MSO_Regex_Equivalence-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-MSO_Regex_Equivalence-2016-12-17.tar.gz">
	afp-MSO_Regex_Equivalence-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-MSO_Regex_Equivalence-2016-02-22.tar.gz">
	afp-MSO_Regex_Equivalence-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-MSO_Regex_Equivalence-2015-05-27.tar.gz">
	afp-MSO_Regex_Equivalence-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-MSO_Regex_Equivalence-2014-08-28.tar.gz">
	afp-MSO_Regex_Equivalence-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-MSO_Regex_Equivalence-2014-06-12.tar.gz">
	afp-MSO_Regex_Equivalence-2014-06-12.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Markov_Models.html b/web/entries/Markov_Models.html
	--- a/web/entries/Markov_Models.html
	+++ b/web/entries/Markov_Models.html
	@@ -1,235 +1,240 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Markov Models - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>arkov

	<font class="first">M</font>odels

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Markov Models</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-01-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This is a formalization of Markov models in Isabelle/HOL. It
	builds on Isabelle's probability theory. The available models are
	currently Discrete-Time Markov Chains and a extensions of them with
	rewards.
	<p>
	As application of these models we formalize probabilistic model
	checking of pCTL formulas, analysis of IPv4 address allocation in
	ZeroConf and an analysis of the anonymity of the Crowds protocol.
	<a href="http://arxiv.org/abs/1212.3870">See here for the corresponding paper.</a></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Markov_Models-AFP,
	author = {Johannes Hölzl and Tobias Nipkow},
	title = {Markov Models},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Markov_Models.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a>, <a href="Gauss-Jordan-Elim-Fun.html">Gauss-Jordan-Elim-Fun</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Hidden_Markov_Models.html">Hidden_Markov_Models</a>, <a href="Probabilistic_Noninterference.html">Probabilistic_Noninterference</a>, <a href="Probabilistic_Timed_Automata.html">Probabilistic_Timed_Automata</a>, <a href="Stochastic_Matrices.html">Stochastic_Matrices</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Markov_Models/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Markov_Models/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Markov_Models/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Markov_Models-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Markov_Models-2018-08-16.tar.gz">
	+ afp-Markov_Models-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Markov_Models-2017-10-10.tar.gz">
	afp-Markov_Models-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Markov_Models-2016-12-17.tar.gz">
	afp-Markov_Models-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Markov_Models-2016-02-22.tar.gz">
	afp-Markov_Models-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Markov_Models-2015-05-27.tar.gz">
	afp-Markov_Models-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Markov_Models-2014-08-28.tar.gz">
	afp-Markov_Models-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Markov_Models-2013-12-11.tar.gz">
	afp-Markov_Models-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Markov_Models-2013-11-17.tar.gz">
	afp-Markov_Models-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Markov_Models-2013-02-16.tar.gz">
	afp-Markov_Models-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Markov_Models-2012-05-24.tar.gz">
	afp-Markov_Models-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Markov_Models-2012-01-08.tar.gz">
	afp-Markov_Models-2012-01-08.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Markov_Models-2012-01-05.tar.gz">
	afp-Markov_Models-2012-01-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Marriage.html b/web/entries/Marriage.html
	--- a/web/entries/Marriage.html
	+++ b/web/entries/Marriage.html
	@@ -1,236 +1,241 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Hall's Marriage Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>all's

	<font class="first">M</font>arriage

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Hall's Marriage Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Dongchen Jiang (dongchenjiang /at/ googlemail /dot/ com) and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-12-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Two proofs of Hall's Marriage Theorem: one due to Halmos and Vaughan, one due to Rado.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2011-09-09]: Added Rado's proof</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Marriage-AFP,
	author = {Dongchen Jiang and Tobias Nipkow},
	title = {Hall's Marriage Theorem},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Marriage.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Latin_Square.html">Latin_Square</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Marriage/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Marriage/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Marriage/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Marriage-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Marriage-2018-08-16.tar.gz">
	+ afp-Marriage-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Marriage-2017-10-10.tar.gz">
	afp-Marriage-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Marriage-2016-12-17.tar.gz">
	afp-Marriage-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Marriage-2016-02-22.tar.gz">
	afp-Marriage-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Marriage-2015-05-27.tar.gz">
	afp-Marriage-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Marriage-2014-08-28.tar.gz">
	afp-Marriage-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Marriage-2013-12-11.tar.gz">
	afp-Marriage-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Marriage-2013-11-17.tar.gz">
	afp-Marriage-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Marriage-2013-02-16.tar.gz">
	afp-Marriage-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Marriage-2012-05-24.tar.gz">
	afp-Marriage-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Marriage-2011-10-11.tar.gz">
	afp-Marriage-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Marriage-2011-02-11.tar.gz">
	afp-Marriage-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Marriage-2010-12-17.tar.gz">
	afp-Marriage-2010-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Mason_Stothers.html b/web/entries/Mason_Stothers.html
	--- a/web/entries/Mason_Stothers.html
	+++ b/web/entries/Mason_Stothers.html
	@@ -1,196 +1,201 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Mason–Stothers Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">M</font>ason–Stothers

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Mason–Stothers Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-12-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This article provides a formalisation of Snyder’s simple and
	elegant proof of the Mason–Stothers theorem, which is the
	polynomial analogue of the famous abc Conjecture for integers.
	Remarkably, Snyder found this very elegant proof when he was still a
	high-school student.</p> <p>In short, the statement of the
	theorem is that three non-zero coprime polynomials
	<em>A</em>, <em>B</em>, <em>C</em>
	over a field which sum to 0 and do not all have vanishing derivatives
	fulfil max{deg(<em>A</em>), deg(<em>B</em>),
	deg(<em>C</em>)} < deg(rad(<em>ABC</em>))
	where the rad(<em>P</em>) denotes the
	<em>radical</em> of <em>P</em>,
	i. e. the product of all unique irreducible factors of
	<em>P</em>.</p> <p>This theorem also implies a
	kind of polynomial analogue of Fermat’s Last Theorem for polynomials:
	except for trivial cases,
	<em>A<sup>n</sup></em> +
	<em>B<sup>n</sup></em> +
	<em>C<sup>n</sup></em> = 0 implies
	n ≤ 2 for coprime polynomials
	<em>A</em>, <em>B</em>, <em>C</em>
	over a field.</em></p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Mason_Stothers-AFP,
	author = {Manuel Eberl},
	title = {The Mason–Stothers Theorem},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Mason_Stothers.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Mason_Stothers/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Mason_Stothers/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Mason_Stothers/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Mason_Stothers-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Mason_Stothers-2018-08-16.tar.gz">
	+ afp-Mason_Stothers-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Mason_Stothers-2017-12-22.tar.gz">
	afp-Mason_Stothers-2017-12-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Matrix.html b/web/entries/Matrix.html
	--- a/web/entries/Matrix.html
	+++ b/web/entries/Matrix.html
	@@ -1,265 +1,270 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Executable Matrix Operations on Matrices of Arbitrary Dimensions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>xecutable

	<font class="first">M</font>atrix

	<font class="first">O</font>perations

	on

	<font class="first">M</font>atrices

	of

	<font class="first">A</font>rbitrary

	<font class="first">D</font>imensions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Executable Matrix Operations on Matrices of Arbitrary Dimensions</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-06-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We provide the operations of matrix addition, multiplication,
	transposition, and matrix comparisons as executable functions over
	ordered semirings. Moreover, it is proven that strongly normalizing
	(monotone) orders can be lifted to strongly normalizing (monotone) orders
	over matrices. We further show that the standard semirings over the
	naturals, integers, and rationals, as well as the arctic semirings
	satisfy the axioms that are required by our matrix theory. Our
	formalization is part of the <a
	href="http://cl-informatik.uibk.ac.at/software/ceta">CeTA</a> system
	which contains several termination techniques. The provided theories have
	been essential to formalize matrix-interpretations and arctic
	interpretations.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2010-09-17]: Moved theory on arbitrary (ordered) semirings to Abstract Rewriting.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Matrix-AFP,
	author = {Christian Sternagel and René Thiemann},
	title = {Executable Matrix Operations on Matrices of Arbitrary Dimensions},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Matrix.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Matrix_Tensor.html">Matrix_Tensor</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a>, <a href="Polynomials.html">Polynomials</a>, <a href="Transitive-Closure.html">Transitive-Closure</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Matrix/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Matrix/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Matrix/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Matrix-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Matrix-2018-08-16.tar.gz">
	+ afp-Matrix-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Matrix-2017-10-10.tar.gz">
	afp-Matrix-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Matrix-2016-12-17.tar.gz">
	afp-Matrix-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Matrix-2016-02-22.tar.gz">
	afp-Matrix-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Matrix-2015-05-27.tar.gz">
	afp-Matrix-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Matrix-2014-08-28.tar.gz">
	afp-Matrix-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Matrix-2013-12-11.tar.gz">
	afp-Matrix-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Matrix-2013-11-17.tar.gz">
	afp-Matrix-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Matrix-2013-02-16.tar.gz">
	afp-Matrix-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Matrix-2012-05-24.tar.gz">
	afp-Matrix-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Matrix-2011-10-11.tar.gz">
	afp-Matrix-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Matrix-2011-02-11.tar.gz">
	afp-Matrix-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Matrix-2010-07-01.tar.gz">
	afp-Matrix-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Matrix-2010-06-17.tar.gz">
	afp-Matrix-2010-06-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Matrix_Tensor.html b/web/entries/Matrix_Tensor.html
	--- a/web/entries/Matrix_Tensor.html
	+++ b/web/entries/Matrix_Tensor.html
	@@ -1,204 +1,209 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Tensor Product of Matrices - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>ensor

	<font class="first">P</font>roduct

	of

	<font class="first">M</font>atrices

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Tensor Product of Matrices</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	T.V.H. Prathamesh (prathamesh /at/ imsc /dot/ res /dot/ in)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-01-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	In this work, the Kronecker tensor product of matrices and the proofs of
	some of its properties are formalized. Properties which have been formalized
	include associativity of the tensor product and the mixed-product
	property.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Matrix_Tensor-AFP,
	author = {T.V.H. Prathamesh},
	title = {Tensor Product of Matrices},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Matrix_Tensor.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Matrix.html">Matrix</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Knot_Theory.html">Knot_Theory</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Matrix_Tensor/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Matrix_Tensor/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Matrix_Tensor/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Matrix_Tensor-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Matrix_Tensor-2018-08-16.tar.gz">
	+ afp-Matrix_Tensor-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Matrix_Tensor-2017-10-10.tar.gz">
	afp-Matrix_Tensor-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Matrix_Tensor-2016-12-17.tar.gz">
	afp-Matrix_Tensor-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Matrix_Tensor-2016-02-22.tar.gz">
	afp-Matrix_Tensor-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Matrix_Tensor-2016-01-19.tar.gz">
	afp-Matrix_Tensor-2016-01-19.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Matrix_Tensor-2016-01-18.tar.gz">
	afp-Matrix_Tensor-2016-01-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Matroids.html b/web/entries/Matroids.html
	--- a/web/entries/Matroids.html
	+++ b/web/entries/Matroids.html
	@@ -1,174 +1,180 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Matroids - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>atroids

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Matroids</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Jonas Keinholz
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-11-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This article defines the combinatorial structures known as
	<em>Independence Systems</em> and
	<em>Matroids</em> and provides basic concepts and theorems
	related to them. These structures play an important role in
	combinatorial optimisation, e. g. greedy algorithms such as
	Kruskal's algorithm. The development is based on Oxley's
	<a href="http://www.math.lsu.edu/~oxley/survey4.pdf">`What
	is a Matroid?'</a>.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Matroids-AFP,
	author = {Jonas Keinholz},
	title = {Matroids},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Matroids.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Kruskal.html">Kruskal</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Matroids/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Matroids/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Matroids/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Matroids-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Matroids-2018-11-20.tar.gz">
	+ afp-Matroids-2018-11-20.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Max-Card-Matching.html b/web/entries/Max-Card-Matching.html
	--- a/web/entries/Max-Card-Matching.html
	+++ b/web/entries/Max-Card-Matching.html
	@@ -1,246 +1,251 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Maximum Cardinality Matching - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>aximum

	<font class="first">C</font>ardinality

	<font class="first">M</font>atching

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Maximum Cardinality Matching</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Christine Rizkallah
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-07-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	A <em>matching</em> in a graph <i>G</i> is a subset <i>M</i> of the
	edges of <i>G</i> such that no two share an endpoint. A matching has maximum
	cardinality if its cardinality is at least as large as that of any other
	matching. An <em>odd-set cover</em> <i>OSC</i> of a graph <i>G</i> is a
	labeling of the nodes of <i>G</i> with integers such that every edge of
	<i>G</i> is either incident to a node labeled 1 or connects two nodes
	labeled with the same number <i>i ≥ 2</i>.
	</p><p>
	This article proves Edmonds theorem:<br>
	Let <i>M</i> be a matching in a graph <i>G</i> and let <i>OSC</i> be an
	odd-set cover of <i>G</i>.
	For any <i>i ≥ 0</i>, let <var>n(i)</var> be the number of nodes
	labeled <i>i</i>. If <i>\|M\| = n(1) +
	∑<sub>i ≥ 2</sub>(n(i) div 2)</i>,
	then <i>M</i> is a maximum cardinality matching.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Max-Card-Matching-AFP,
	author = {Christine Rizkallah},
	title = {Maximum Cardinality Matching},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/Max-Card-Matching.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Max-Card-Matching/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Max-Card-Matching/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Max-Card-Matching/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Max-Card-Matching-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Max-Card-Matching-2018-08-16.tar.gz">
	+ afp-Max-Card-Matching-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Max-Card-Matching-2017-10-10.tar.gz">
	afp-Max-Card-Matching-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Max-Card-Matching-2016-12-17.tar.gz">
	afp-Max-Card-Matching-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Max-Card-Matching-2016-02-22.tar.gz">
	afp-Max-Card-Matching-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Max-Card-Matching-2015-05-27.tar.gz">
	afp-Max-Card-Matching-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Max-Card-Matching-2014-08-28.tar.gz">
	afp-Max-Card-Matching-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Max-Card-Matching-2013-12-11.tar.gz">
	afp-Max-Card-Matching-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Max-Card-Matching-2013-11-17.tar.gz">
	afp-Max-Card-Matching-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Max-Card-Matching-2013-02-16.tar.gz">
	afp-Max-Card-Matching-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Max-Card-Matching-2012-05-24.tar.gz">
	afp-Max-Card-Matching-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Max-Card-Matching-2011-10-11.tar.gz">
	afp-Max-Card-Matching-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Max-Card-Matching-2011-08-19.tar.gz">
	afp-Max-Card-Matching-2011-08-19.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Max-Card-Matching-2011-08-15.tar.gz">
	afp-Max-Card-Matching-2011-08-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Median_Of_Medians_Selection.html b/web/entries/Median_Of_Medians_Selection.html
	--- a/web/entries/Median_Of_Medians_Selection.html
	+++ b/web/entries/Median_Of_Medians_Selection.html
	@@ -1,184 +1,189 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Median-of-Medians Selection Algorithm - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">M</font>edian-of-Medians

	<font class="first">S</font>election

	<font class="first">A</font>lgorithm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Median-of-Medians Selection Algorithm</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-12-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This entry provides an executable functional implementation
	of the Median-of-Medians algorithm for selecting the
	<em>k</em>-th smallest element of an unsorted list
	deterministically in linear time. The size bounds for the recursive
	call that lead to the linear upper bound on the run-time of the
	algorithm are also proven. </p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Median_Of_Medians_Selection-AFP,
	author = {Manuel Eberl},
	title = {The Median-of-Medians Selection Algorithm},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Median_Of_Medians_Selection.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="KD_Tree.html">KD_Tree</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Median_Of_Medians_Selection/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Median_Of_Medians_Selection/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Median_Of_Medians_Selection/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Median_Of_Medians_Selection-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Median_Of_Medians_Selection-2018-08-16.tar.gz">
	+ afp-Median_Of_Medians_Selection-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Median_Of_Medians_Selection-2017-12-22.tar.gz">
	afp-Median_Of_Medians_Selection-2017-12-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Menger.html b/web/entries/Menger.html
	--- a/web/entries/Menger.html
	+++ b/web/entries/Menger.html
	@@ -1,184 +1,189 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Menger's Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>enger's

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Menger's Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://logic.las.tu-berlin.de/Members/Dittmann/">Christoph Dittmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-02-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formalization of Menger's Theorem for directed and
	undirected graphs in Isabelle/HOL. This well-known result shows that
	if two non-adjacent distinct vertices u, v in a directed graph have no
	separator smaller than n, then there exist n internally
	vertex-disjoint paths from u to v. The version for undirected graphs
	follows immediately because undirected graphs are a special case of
	directed graphs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Menger-AFP,
	author = {Christoph Dittmann},
	title = {Menger's Theorem},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Menger.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Menger/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Menger/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Menger/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Menger-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Menger-2018-08-16.tar.gz">
	+ afp-Menger-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Menger-2017-10-10.tar.gz">
	afp-Menger-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Menger-2017-02-27.tar.gz">
	afp-Menger-2017-02-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/MiniML.html b/web/entries/MiniML.html
	--- a/web/entries/MiniML.html
	+++ b/web/entries/MiniML.html
	@@ -1,273 +1,283 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Mini ML - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>ini

	<font class="first">M</font>L

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Mini ML</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Wolfgang Naraschewski and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-03-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This theory defines the type inference rules and the type inference algorithm <i>W</i> for MiniML (simply-typed lambda terms with <tt>let</tt>) due to Milner. It proves the soundness and completeness of <i>W</i> w.r.t. the rules.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{MiniML-AFP,
	author = {Wolfgang Naraschewski and Tobias Nipkow},
	title = {Mini ML},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/MiniML.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MiniML/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/MiniML/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MiniML/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-MiniML-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-MiniML-2019-04-18.tar.gz">
	+ afp-MiniML-2019-04-18.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-MiniML-2018-08-16.tar.gz">
	+ afp-MiniML-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-MiniML-2017-10-10.tar.gz">
	afp-MiniML-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-MiniML-2016-12-17.tar.gz">
	afp-MiniML-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-MiniML-2016-02-22.tar.gz">
	afp-MiniML-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-MiniML-2015-05-27.tar.gz">
	afp-MiniML-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-MiniML-2014-08-28.tar.gz">
	afp-MiniML-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-MiniML-2013-12-11.tar.gz">
	afp-MiniML-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-MiniML-2013-11-17.tar.gz">
	afp-MiniML-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-MiniML-2013-03-02.tar.gz">
	afp-MiniML-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-MiniML-2013-02-16.tar.gz">
	afp-MiniML-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-MiniML-2012-05-24.tar.gz">
	afp-MiniML-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-MiniML-2011-10-11.tar.gz">
	afp-MiniML-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-MiniML-2011-02-11.tar.gz">
	afp-MiniML-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-MiniML-2010-07-01.tar.gz">
	afp-MiniML-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-MiniML-2009-12-12.tar.gz">
	afp-MiniML-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-MiniML-2009-04-29.tar.gz">
	afp-MiniML-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-MiniML-2008-06-10.tar.gz">
	afp-MiniML-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-MiniML-2007-11-27.tar.gz">
	afp-MiniML-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-MiniML-2005-10-14.tar.gz">
	afp-MiniML-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-MiniML-2004-05-21.tar.gz">
	afp-MiniML-2004-05-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-MiniML-2004-04-20.tar.gz">
	afp-MiniML-2004-04-20.tar.gz
	</a>
	</li>
	<li>Isabelle 2003:
	<a href="../release/afp-MiniML-2004-03-23.tar.gz">
	afp-MiniML-2004-03-23.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Minimal_SSA.html b/web/entries/Minimal_SSA.html
	--- a/web/entries/Minimal_SSA.html
	+++ b/web/entries/Minimal_SSA.html
	@@ -1,203 +1,208 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Minimal Static Single Assignment Form - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>inimal

	<font class="first">S</font>tatic

	<font class="first">S</font>ingle

	<font class="first">A</font>ssignment

	<font class="first">F</font>orm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Minimal Static Single Assignment Form</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Max Wagner (max /at/ trollbu /dot/ de) and
	<a href="http://pp.ipd.kit.edu/person.php?id=88">Denis Lohner</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-01-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This formalization is an extension to <a
	href="https://www.isa-afp.org/entries/Formal_SSA.html">"Verified
	Construction of Static Single Assignment Form"</a>. In
	their work, the authors have shown that <a
	href="https://doi.org/10.1007/978-3-642-37051-9_6">Braun
	et al.'s static single assignment (SSA) construction
	algorithm</a> produces minimal SSA form for input programs with
	a reducible control flow graph (CFG). However Braun et al. also
	proposed an extension to their algorithm that they claim produces
	minimal SSA form even for irreducible CFGs.<br> In this
	formalization we support that claim by giving a mechanized proof.
	</p>
	<p>As the extension of Braun et al.'s algorithm
	aims for removing so-called redundant strongly connected components of
	phi functions, we show that this suffices to guarantee minimality
	according to <a href="https://doi.org/10.1145/115372.115320">Cytron et
	al.</a>.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Minimal_SSA-AFP,
	author = {Max Wagner and Denis Lohner},
	title = {Minimal Static Single Assignment Form},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Minimal_SSA.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Formal_SSA.html">Formal_SSA</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Minimal_SSA/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Minimal_SSA/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Minimal_SSA/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Minimal_SSA-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Minimal_SSA-2018-08-16.tar.gz">
	+ afp-Minimal_SSA-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Minimal_SSA-2017-10-10.tar.gz">
	afp-Minimal_SSA-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Minimal_SSA-2017-01-19.tar.gz">
	afp-Minimal_SSA-2017-01-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Minkowskis_Theorem.html b/web/entries/Minkowskis_Theorem.html
	--- a/web/entries/Minkowskis_Theorem.html
	+++ b/web/entries/Minkowskis_Theorem.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Minkowski's Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>inkowski's

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Minkowski's Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-07-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>Minkowski's theorem relates a subset of
	ℝ<sup>n</sup>, the Lebesgue measure, and the
	integer lattice ℤ<sup>n</sup>: It states that
	any convex subset of ℝ<sup>n</sup> with volume
	greater than 2<sup>n</sup> contains at least one lattice
	point from ℤ<sup>n</sup>\{0}, i. e. a
	non-zero point with integer coefficients.</p> <p>A
	related theorem which directly implies this is Blichfeldt's
	theorem, which states that any subset of
	ℝ<sup>n</sup> with a volume greater than 1
	contains two different points whose difference vector has integer
	components.</p> <p>The entry contains a proof of both
	theorems.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Minkowskis_Theorem-AFP,
	author = {Manuel Eberl},
	title = {Minkowski's Theorem},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Minkowskis_Theorem.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Minkowskis_Theorem/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Minkowskis_Theorem/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Minkowskis_Theorem/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Minkowskis_Theorem-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Minkowskis_Theorem-2018-08-16.tar.gz">
	+ afp-Minkowskis_Theorem-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Minkowskis_Theorem-2017-10-10.tar.gz">
	afp-Minkowskis_Theorem-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Minkowskis_Theorem-2017-07-15.tar.gz">
	afp-Minkowskis_Theorem-2017-07-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Minsky_Machines.html b/web/entries/Minsky_Machines.html
	--- a/web/entries/Minsky_Machines.html
	+++ b/web/entries/Minsky_Machines.html
	@@ -1,188 +1,193 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Minsky Machines - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>insky

	<font class="first">M</font>achines

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Minsky Machines</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Bertram Felgenhauer
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-08-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p> We formalize undecidablity results for Minsky machines. To
	this end, we also formalize recursive inseparability.
	</p><p> We start by proving that Minsky machines can
	compute arbitrary primitive recursive and recursive functions. We then
	show that there is a deterministic Minsky machine with one argument
	and two final states such that the set of inputs that are accepted in
	one state is recursively inseparable from the set of inputs that are
	accepted in the other state. </p><p> As a corollary, the
	set of Minsky configurations that reach the first state but not the
	second recursively inseparable from the set of Minsky configurations
	that reach the second state but not the first. In particular both
	these sets are undecidable. </p><p> We do
	<em>not</em> prove that recursive functions can simulate
	Minsky machines. </p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Minsky_Machines-AFP,
	author = {Bertram Felgenhauer},
	title = {Minsky Machines},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Minsky_Machines.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a>, <a href="Recursion-Theory-I.html">Recursion-Theory-I</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Minsky_Machines/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Minsky_Machines/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Minsky_Machines/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Minsky_Machines-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Minsky_Machines-2018-08-16.tar.gz">
	+ afp-Minsky_Machines-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Minsky_Machines-2018-08-14.tar.gz">
	afp-Minsky_Machines-2018-08-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Modal_Logics_for_NTS.html b/web/entries/Modal_Logics_for_NTS.html
	--- a/web/entries/Modal_Logics_for_NTS.html
	+++ b/web/entries/Modal_Logics_for_NTS.html
	@@ -1,216 +1,221 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Modal Logics for Nominal Transition Systems - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>odal

	<font class="first">L</font>ogics

	for

	<font class="first">N</font>ominal

	<font class="first">T</font>ransition

	<font class="first">S</font>ystems

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Modal Logics for Nominal Transition Systems</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Tjark Weber (tjark /dot/ weber /at/ it /dot/ uu /dot/ se),
	Lars-Henrik Eriksson (lhe /at/ it /dot/ uu /dot/ se),
	Joachim Parrow (joachim /dot/ parrow /at/ it /dot/ uu /dot/ se),
	Johannes Borgström (johannes /dot/ borgstrom /at/ it /dot/ uu /dot/ se) and
	Ramunas Gutkovas (ramunas /dot/ gutkovas /at/ it /dot/ uu /dot/ se)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-10-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize a uniform semantic substrate for a wide variety of
	process calculi where states and action labels can be from arbitrary
	nominal sets. A Hennessy-Milner logic for these systems is defined,
	and proved adequate for bisimulation equivalence. A main novelty is
	the construction of an infinitary nominal data type to model formulas
	with (finitely supported) infinite conjunctions and actions that may
	contain binding names. The logic is generalized to treat different
	bisimulation variants such as early, late and open in a systematic
	way.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2017-01-29]:
	Formalization of weak bisimilarity added
	(revision c87cc2057d9c)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Modal_Logics_for_NTS-AFP,
	author = {Tjark Weber and Lars-Henrik Eriksson and Joachim Parrow and Johannes Borgström and Ramunas Gutkovas},
	title = {Modal Logics for Nominal Transition Systems},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Modal_Logics_for_NTS.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Nominal2.html">Nominal2</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Modal_Logics_for_NTS/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Modal_Logics_for_NTS/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Modal_Logics_for_NTS/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Modal_Logics_for_NTS-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Modal_Logics_for_NTS-2018-08-16.tar.gz">
	+ afp-Modal_Logics_for_NTS-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Modal_Logics_for_NTS-2017-10-10.tar.gz">
	afp-Modal_Logics_for_NTS-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Modal_Logics_for_NTS-2016-12-17.tar.gz">
	afp-Modal_Logics_for_NTS-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Modal_Logics_for_NTS-2016-10-27.tar.gz">
	afp-Modal_Logics_for_NTS-2016-10-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Modal_Logics_for_NTS-2016-10-25.tar.gz">
	afp-Modal_Logics_for_NTS-2016-10-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Modular_Assembly_Kit_Security.html b/web/entries/Modular_Assembly_Kit_Security.html
	--- a/web/entries/Modular_Assembly_Kit_Security.html
	+++ b/web/entries/Modular_Assembly_Kit_Security.html
	@@ -1,202 +1,207 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>An Isabelle/HOL Formalization of the Modular Assembly Kit for Security Properties - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>n

	<font class="first">I</font>sabelle/HOL

	<font class="first">F</font>ormalization

	of

	the

	<font class="first">M</font>odular

	<font class="first">A</font>ssembly

	<font class="first">K</font>it

	for

	<font class="first">S</font>ecurity

	<font class="first">P</font>roperties

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">An Isabelle/HOL Formalization of the Modular Assembly Kit for Security Properties</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Oliver Bračevac (bracevac /at/ st /dot/ informatik /dot/ tu-darmstadt /dot/ de),
	Richard Gay (gay /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de),
	Sylvia Grewe (grewe /at/ st /dot/ informatik /dot/ tu-darmstadt /dot/ de),
	Heiko Mantel (mantel /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de),
	Henning Sudbrock (sudbrock /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de) and
	Markus Tasch (tasch /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-05-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The "Modular Assembly Kit for Security Properties" (MAKS) is
	a framework for both the definition and verification of possibilistic
	information-flow security properties at the specification-level. MAKS
	supports the uniform representation of a wide range of possibilistic
	information-flow properties and provides support for the verification
	of such properties via unwinding results and compositionality results.
	We provide a formalization of this framework in Isabelle/HOL.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Modular_Assembly_Kit_Security-AFP,
	author = {Oliver Bračevac and Richard Gay and Sylvia Grewe and Heiko Mantel and Henning Sudbrock and Markus Tasch},
	title = {An Isabelle/HOL Formalization of the Modular Assembly Kit for Security Properties},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Modular_Assembly_Kit_Security.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Modular_Assembly_Kit_Security/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Modular_Assembly_Kit_Security/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Modular_Assembly_Kit_Security/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Modular_Assembly_Kit_Security-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Modular_Assembly_Kit_Security-2018-08-16.tar.gz">
	+ afp-Modular_Assembly_Kit_Security-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Modular_Assembly_Kit_Security-2018-05-09.tar.gz">
	afp-Modular_Assembly_Kit_Security-2018-05-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Monad_Memo_DP.html b/web/entries/Monad_Memo_DP.html
	--- a/web/entries/Monad_Memo_DP.html
	+++ b/web/entries/Monad_Memo_DP.html
	@@ -1,194 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Monadification, Memoization and Dynamic Programming - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>onadification,

	<font class="first">M</font>emoization

	and

	<font class="first">D</font>ynamic

	<font class="first">P</font>rogramming

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Monadification, Memoization and Dynamic Programming</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>,
	Shuwei Hu (shuwei /dot/ hu /at/ tum /dot/ de) and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-05-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a lightweight framework for the automatic verified
	(functional or imperative) memoization of recursive functions. Our
	tool can turn a pure Isabelle/HOL function definition into a
	monadified version in a state monad or the Imperative HOL heap monad,
	and prove a correspondence theorem. We provide a variety of memory
	implementations for the two types of monads. A number of simple
	techniques allow us to achieve bottom-up computation and
	space-efficient memoization. The framework’s utility is demonstrated
	on a number of representative dynamic programming problems. A detailed
	description of our work can be found in the accompanying paper [2].</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Monad_Memo_DP-AFP,
	author = {Simon Wimmer and Shuwei Hu and Tobias Nipkow},
	title = {Monadification, Memoization and Dynamic Programming},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Monad_Memo_DP.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Show.html">Show</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Hidden_Markov_Models.html">Hidden_Markov_Models</a>, <a href="Optimal_BST.html">Optimal_BST</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Monad_Memo_DP/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Monad_Memo_DP/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Monad_Memo_DP/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Monad_Memo_DP-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Monad_Memo_DP-2018-08-16.tar.gz">
	+ afp-Monad_Memo_DP-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Monad_Memo_DP-2018-05-23.tar.gz">
	afp-Monad_Memo_DP-2018-05-23.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Monad_Normalisation.html b/web/entries/Monad_Normalisation.html
	--- a/web/entries/Monad_Normalisation.html
	+++ b/web/entries/Monad_Normalisation.html
	@@ -1,189 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Monad normalisation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>onad

	normalisation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Monad normalisation</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Joshua Schneider (joshua /dot/ schneider /at/ inf /dot/ ethz /dot/ ch),
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a> and
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The usual monad laws can directly be used as rewrite rules for Isabelle’s
	simplifier to normalise monadic HOL terms and decide equivalences.
	In a commutative monad, however, the commutativity law is a
	higher-order permutative rewrite rule that makes the simplifier loop.
	This AFP entry implements a simproc that normalises monadic
	expressions in commutative monads using ordered rewriting. The
	simproc can also permute computations across control operators like if
	and case.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Monad_Normalisation-AFP,
	author = {Joshua Schneider and Manuel Eberl and Andreas Lochbihler},
	title = {Monad normalisation},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Monad_Normalisation.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CryptHOL.html">CryptHOL</a>, <a href="Randomised_BSTs.html">Randomised_BSTs</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Monad_Normalisation/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Monad_Normalisation/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Monad_Normalisation/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Monad_Normalisation-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Monad_Normalisation-2018-08-16.tar.gz">
	+ afp-Monad_Normalisation-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Monad_Normalisation-2017-10-10.tar.gz">
	afp-Monad_Normalisation-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Monad_Normalisation-2017-05-11.tar.gz">
	afp-Monad_Normalisation-2017-05-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/MonoBoolTranAlgebra.html b/web/entries/MonoBoolTranAlgebra.html
	--- a/web/entries/MonoBoolTranAlgebra.html
	+++ b/web/entries/MonoBoolTranAlgebra.html
	@@ -1,230 +1,235 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Algebra of Monotonic Boolean Transformers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>lgebra

	of

	<font class="first">M</font>onotonic

	<font class="first">B</font>oolean

	<font class="first">T</font>ransformers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Algebra of Monotonic Boolean Transformers</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Viorel Preoteasa (viorel /dot/ preoteasa /at/ aalto /dot/ fi)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-09-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Algebras of imperative programming languages have been successful in reasoning about programs. In general an algebra of programs is an algebraic structure with programs as elements and with program compositions (sequential composition, choice, skip) as algebra operations. Various versions of these algebras were introduced to model partial correctness, total correctness, refinement, demonic choice, and other aspects. We formalize here an algebra which can be used to model total correctness, refinement, demonic and angelic choice. The basic model of this algebra are monotonic Boolean transformers (monotonic functions from a Boolean algebra to itself).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{MonoBoolTranAlgebra-AFP,
	author = {Viorel Preoteasa},
	title = {Algebra of Monotonic Boolean Transformers},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/MonoBoolTranAlgebra.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="LatticeProperties.html">LatticeProperties</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MonoBoolTranAlgebra/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/MonoBoolTranAlgebra/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MonoBoolTranAlgebra/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-MonoBoolTranAlgebra-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-MonoBoolTranAlgebra-2018-08-16.tar.gz">
	+ afp-MonoBoolTranAlgebra-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-MonoBoolTranAlgebra-2017-10-10.tar.gz">
	afp-MonoBoolTranAlgebra-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-MonoBoolTranAlgebra-2016-12-17.tar.gz">
	afp-MonoBoolTranAlgebra-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-MonoBoolTranAlgebra-2016-02-22.tar.gz">
	afp-MonoBoolTranAlgebra-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-MonoBoolTranAlgebra-2015-05-27.tar.gz">
	afp-MonoBoolTranAlgebra-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-MonoBoolTranAlgebra-2014-08-28.tar.gz">
	afp-MonoBoolTranAlgebra-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-MonoBoolTranAlgebra-2013-12-11.tar.gz">
	afp-MonoBoolTranAlgebra-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-MonoBoolTranAlgebra-2013-11-17.tar.gz">
	afp-MonoBoolTranAlgebra-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-MonoBoolTranAlgebra-2013-02-16.tar.gz">
	afp-MonoBoolTranAlgebra-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-MonoBoolTranAlgebra-2012-05-24.tar.gz">
	afp-MonoBoolTranAlgebra-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-MonoBoolTranAlgebra-2011-10-11.tar.gz">
	afp-MonoBoolTranAlgebra-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-MonoBoolTranAlgebra-2011-09-27.tar.gz">
	afp-MonoBoolTranAlgebra-2011-09-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/MonoidalCategory.html b/web/entries/MonoidalCategory.html
	--- a/web/entries/MonoidalCategory.html
	+++ b/web/entries/MonoidalCategory.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Monoidal Categories - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>onoidal

	<font class="first">C</font>ategories

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Monoidal Categories</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Eugene W. Stark (stark /at/ cs /dot/ stonybrook /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-04</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Building on the formalization of basic category theory set out in the
	author's previous AFP article, the present article formalizes
	some basic aspects of the theory of monoidal categories. Among the
	notions defined here are monoidal category, monoidal functor, and
	equivalence of monoidal categories. The main theorems formalized are
	MacLane's coherence theorem and the constructions of the free
	monoidal category and free strict monoidal category generated by a
	given category. The coherence theorem is proved syntactically, using
	a structurally recursive approach to reduction of terms that might
	have some novel aspects. We also give proofs of some results given by
	Etingof et al, which may prove useful in a formal setting. In
	particular, we show that the left and right unitors need not be taken
	as given data in the definition of monoidal category, nor does the
	definition of monoidal functor need to take as given a specific
	isomorphism expressing the preservation of the unit object. Our
	definitions of monoidal category and monoidal functor are stated so as
	to take advantage of the economy afforded by these facts.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2017-05-18]:
	Integrated material from MonoidalCategory/Category3Adapter into Category3/ and deleted adapter.
	(revision 015543cdd069)<br>
	[2018-05-29]:
	Modifications required due to 'Category3' changes. Introduced notation for "in hom".
	(revision 8318366d4575)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{MonoidalCategory-AFP,
	author = {Eugene W. Stark},
	title = {Monoidal Categories},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/MonoidalCategory.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Category3.html">Category3</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MonoidalCategory/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/MonoidalCategory/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MonoidalCategory/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-MonoidalCategory-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-MonoidalCategory-2018-08-16.tar.gz">
	+ afp-MonoidalCategory-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-MonoidalCategory-2017-10-10.tar.gz">
	afp-MonoidalCategory-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-MonoidalCategory-2017-05-05.tar.gz">
	afp-MonoidalCategory-2017-05-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Monomorphic_Monad.html b/web/entries/Monomorphic_Monad.html
	--- a/web/entries/Monomorphic_Monad.html
	+++ b/web/entries/Monomorphic_Monad.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Effect polymorphism in higher-order logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>ffect

	polymorphism

	in

	higher-order

	logic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Effect polymorphism in higher-order logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The notion of a monad cannot be expressed within higher-order logic
	(HOL) due to type system restrictions. We show that if a monad is used
	with values of only one type, this notion can be formalised in HOL.
	Based on this idea, we develop a library of effect specifications and
	implementations of monads and monad transformers. Hence, we can
	abstract over the concrete monad in HOL definitions and thus use the
	same definition for different (combinations of) effects. We illustrate
	the usefulness of effect polymorphism with a monadic interpreter for a
	simple language.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-02-15]:
	added further specifications and implementations of non-determinism;
	more examples
	(revision bc5399eea78e)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Monomorphic_Monad-AFP,
	author = {Andreas Lochbihler},
	title = {Effect polymorphism in higher-order logic},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Monomorphic_Monad.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CryptHOL.html">CryptHOL</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Monomorphic_Monad/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Monomorphic_Monad/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Monomorphic_Monad/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Monomorphic_Monad-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Monomorphic_Monad-2018-08-16.tar.gz">
	+ afp-Monomorphic_Monad-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Monomorphic_Monad-2017-10-10.tar.gz">
	afp-Monomorphic_Monad-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Monomorphic_Monad-2017-05-11.tar.gz">
	afp-Monomorphic_Monad-2017-05-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/MuchAdoAboutTwo.html b/web/entries/MuchAdoAboutTwo.html
	--- a/web/entries/MuchAdoAboutTwo.html
	+++ b/web/entries/MuchAdoAboutTwo.html
	@@ -1,256 +1,261 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Much Ado About Two - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>uch

	<font class="first">A</font>do

	<font class="first">A</font>bout

	<font class="first">T</font>wo

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Much Ado About Two</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~boehmes/">Sascha Böhme</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2007-11-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This article is an Isabelle formalisation of a paper with the same title. In a similar way as Knuth's 0-1-principle for sorting algorithms, that paper develops a 0-1-2-principle for parallel prefix computations.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{MuchAdoAboutTwo-AFP,
	author = {Sascha Böhme},
	title = {Much Ado About Two},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2007,
	note = {\url{http://isa-afp.org/entries/MuchAdoAboutTwo.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MuchAdoAboutTwo/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/MuchAdoAboutTwo/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/MuchAdoAboutTwo/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-MuchAdoAboutTwo-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-MuchAdoAboutTwo-2018-08-16.tar.gz">
	+ afp-MuchAdoAboutTwo-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-MuchAdoAboutTwo-2017-10-10.tar.gz">
	afp-MuchAdoAboutTwo-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-MuchAdoAboutTwo-2016-12-17.tar.gz">
	afp-MuchAdoAboutTwo-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-MuchAdoAboutTwo-2016-02-22.tar.gz">
	afp-MuchAdoAboutTwo-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-MuchAdoAboutTwo-2015-05-27.tar.gz">
	afp-MuchAdoAboutTwo-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-MuchAdoAboutTwo-2014-08-28.tar.gz">
	afp-MuchAdoAboutTwo-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-MuchAdoAboutTwo-2013-12-11.tar.gz">
	afp-MuchAdoAboutTwo-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-MuchAdoAboutTwo-2013-11-17.tar.gz">
	afp-MuchAdoAboutTwo-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-MuchAdoAboutTwo-2013-03-02.tar.gz">
	afp-MuchAdoAboutTwo-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-MuchAdoAboutTwo-2013-02-16.tar.gz">
	afp-MuchAdoAboutTwo-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-MuchAdoAboutTwo-2012-05-24.tar.gz">
	afp-MuchAdoAboutTwo-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-MuchAdoAboutTwo-2011-10-11.tar.gz">
	afp-MuchAdoAboutTwo-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-MuchAdoAboutTwo-2011-02-11.tar.gz">
	afp-MuchAdoAboutTwo-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-MuchAdoAboutTwo-2010-07-01.tar.gz">
	afp-MuchAdoAboutTwo-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-MuchAdoAboutTwo-2009-12-12.tar.gz">
	afp-MuchAdoAboutTwo-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-MuchAdoAboutTwo-2009-04-29.tar.gz">
	afp-MuchAdoAboutTwo-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-MuchAdoAboutTwo-2008-06-10.tar.gz">
	afp-MuchAdoAboutTwo-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-MuchAdoAboutTwo-2007-11-27.tar.gz">
	afp-MuchAdoAboutTwo-2007-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Multi_Party_Computation.html b/web/entries/Multi_Party_Computation.html
	--- a/web/entries/Multi_Party_Computation.html
	+++ b/web/entries/Multi_Party_Computation.html
	@@ -1,181 +1,187 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Multi-Party Computation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>ulti-Party

	<font class="first">C</font>omputation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Multi-Party Computation</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://homepages.inf.ed.ac.uk/da/">David Aspinall</a> and
	David Butler (dbutler /at/ turing /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-05-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We use CryptHOL to consider Multi-Party Computation (MPC) protocols.
	MPC was first considered by Yao in 1983 and recent advances in
	efficiency and an increased demand mean it is now deployed in the real
	world. Security is considered using the real/ideal world paradigm. We
	first define security in the semi-honest security setting where
	parties are assumed not to deviate from the protocol transcript. In
	this setting we prove multiple Oblivious Transfer (OT) protocols
	secure and then show security for the gates of the GMW protocol. We
	then define malicious security, this is a stronger notion of security
	where parties are assumed to be fully corrupted by an adversary. In
	this setting we again consider OT, as it is a fundamental building
	block of almost all MPC protocols.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Multi_Party_Computation-AFP,
	author = {David Aspinall and David Butler},
	title = {Multi-Party Computation},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Multi_Party_Computation.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Game_Based_Crypto.html">Game_Based_Crypto</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Multi_Party_Computation/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Multi_Party_Computation/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Multi_Party_Computation/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Multi_Party_Computation-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Multi_Party_Computation-2019-05-10.tar.gz">
	+ afp-Multi_Party_Computation-2019-05-10.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Multirelations.html b/web/entries/Multirelations.html
	--- a/web/entries/Multirelations.html
	+++ b/web/entries/Multirelations.html
	@@ -1,197 +1,202 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Binary Multirelations - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>inary

	<font class="first">M</font>ultirelations

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Binary Multirelations</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.sci.kagoshima-u.ac.jp/~furusawa/">Hitoshi Furusawa</a> and
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-06-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Binary multirelations associate elements of a set with its subsets; hence
	they are binary relations from a set to its power set. Applications include
	alternating automata, models and logics for games, program semantics with
	dual demonic and angelic nondeterministic choices and concurrent dynamic
	logics. This proof document supports an arXiv article that formalises the
	basic algebra of multirelations and proposes axiom systems for them,
	ranging from weak bi-monoids to weak bi-quantales.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Multirelations-AFP,
	author = {Hitoshi Furusawa and Georg Struth},
	title = {Binary Multirelations},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Multirelations.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Kleene_Algebra.html">Kleene_Algebra</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Multirelations/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Multirelations/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Multirelations/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Multirelations-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Multirelations-2018-08-16.tar.gz">
	+ afp-Multirelations-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Multirelations-2017-10-10.tar.gz">
	afp-Multirelations-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Multirelations-2016-12-17.tar.gz">
	afp-Multirelations-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Multirelations-2016-02-22.tar.gz">
	afp-Multirelations-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Multirelations-2015-06-13.tar.gz">
	afp-Multirelations-2015-06-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Myhill-Nerode.html b/web/entries/Myhill-Nerode.html
	--- a/web/entries/Myhill-Nerode.html
	+++ b/web/entries/Myhill-Nerode.html
	@@ -1,244 +1,249 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Myhill-Nerode Theorem Based on Regular Expressions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">M</font>yhill-Nerode

	<font class="first">T</font>heorem

	<font class="first">B</font>ased

	on

	<font class="first">R</font>egular

	<font class="first">E</font>xpressions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Myhill-Nerode Theorem Based on Regular Expressions</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Chunhan Wu,
	Xingyuan Zhang and
	<a href="http://www.inf.kcl.ac.uk/staff/urbanc/">Christian Urban</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-08-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Myhill-Nerode.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a>, <a href="Open_Induction.html">Open_Induction</a>, <a href="Regular-Sets.html">Regular-Sets</a>, <a href="Well_Quasi_Orders.html">Well_Quasi_Orders</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Myhill-Nerode/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Myhill-Nerode/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Myhill-Nerode/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Myhill-Nerode-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Myhill-Nerode-2018-08-16.tar.gz">
	+ afp-Myhill-Nerode-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Myhill-Nerode-2017-10-10.tar.gz">
	afp-Myhill-Nerode-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Myhill-Nerode-2016-12-17.tar.gz">
	afp-Myhill-Nerode-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Myhill-Nerode-2016-02-22.tar.gz">
	afp-Myhill-Nerode-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Myhill-Nerode-2015-05-27.tar.gz">
	afp-Myhill-Nerode-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Myhill-Nerode-2014-08-28.tar.gz">
	afp-Myhill-Nerode-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Myhill-Nerode-2013-12-11.tar.gz">
	afp-Myhill-Nerode-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Myhill-Nerode-2013-11-17.tar.gz">
	afp-Myhill-Nerode-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Myhill-Nerode-2013-03-02.tar.gz">
	afp-Myhill-Nerode-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Myhill-Nerode-2013-02-16.tar.gz">
	afp-Myhill-Nerode-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Myhill-Nerode-2012-05-24.tar.gz">
	afp-Myhill-Nerode-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Myhill-Nerode-2011-10-11.tar.gz">
	afp-Myhill-Nerode-2011-10-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Name_Carrying_Type_Inference.html b/web/entries/Name_Carrying_Type_Inference.html
	--- a/web/entries/Name_Carrying_Type_Inference.html
	+++ b/web/entries/Name_Carrying_Type_Inference.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Verified Metatheory and Type Inference for a Name-Carrying Simply-Typed Lambda Calculus - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erified

	<font class="first">M</font>etatheory

	and

	<font class="first">T</font>ype

	<font class="first">I</font>nference

	for

	a

	<font class="first">N</font>ame-Carrying

	<font class="first">S</font>imply-Typed

	<font class="first">L</font>ambda

	<font class="first">C</font>alculus

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Verified Metatheory and Type Inference for a Name-Carrying Simply-Typed Lambda Calculus</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Michael Rawson (michaelrawson76 /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-07-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	I formalise a Church-style simply-typed
	$\lambda$-calculus, extended with pairs, a unit value, and
	projection functions, and show some metatheory of the calculus, such
	as the subject reduction property. Particular attention is paid to the
	treatment of names in the calculus. A nominal style of binding is
	used, but I use a manual approach over Nominal Isabelle in order to
	extract an executable type inference algorithm. More information can
	be found in my <a
	href="http://www.openthesis.org/documents/Verified-Metatheory-Type-Inference-Simply-603182.html">undergraduate
	dissertation</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Name_Carrying_Type_Inference-AFP,
	author = {Michael Rawson},
	title = {Verified Metatheory and Type Inference for a Name-Carrying Simply-Typed Lambda Calculus},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Name_Carrying_Type_Inference.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Name_Carrying_Type_Inference/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Name_Carrying_Type_Inference/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Name_Carrying_Type_Inference/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Name_Carrying_Type_Inference-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Name_Carrying_Type_Inference-2018-08-16.tar.gz">
	+ afp-Name_Carrying_Type_Inference-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Name_Carrying_Type_Inference-2017-10-10.tar.gz">
	afp-Name_Carrying_Type_Inference-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Name_Carrying_Type_Inference-2017-07-15.tar.gz">
	afp-Name_Carrying_Type_Inference-2017-07-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Nat-Interval-Logic.html b/web/entries/Nat-Interval-Logic.html
	--- a/web/entries/Nat-Interval-Logic.html
	+++ b/web/entries/Nat-Interval-Logic.html
	@@ -1,234 +1,239 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Interval Temporal Logic on Natural Numbers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>nterval

	<font class="first">T</font>emporal

	<font class="first">L</font>ogic

	on

	<font class="first">N</font>atural

	<font class="first">N</font>umbers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Interval Temporal Logic on Natural Numbers</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	David Trachtenherz
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-02-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We introduce a theory of temporal logic operators using sets of natural numbers as time domain, formalized in a shallow embedding manner. The theory comprises special natural intervals (theory IL_Interval: open and closed intervals, continuous and modulo intervals, interval traversing results), operators for shifting intervals to left/right on the number axis as well as expanding/contracting intervals by constant factors (theory IL_IntervalOperators.thy), and ultimately definitions and results for unary and binary temporal operators on arbitrary natural sets (theory IL_TemporalOperators).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Nat-Interval-Logic-AFP,
	author = {David Trachtenherz},
	title = {Interval Temporal Logic on Natural Numbers},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/Nat-Interval-Logic.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="List-Infinite.html">List-Infinite</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="AutoFocus-Stream.html">AutoFocus-Stream</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Nat-Interval-Logic/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Nat-Interval-Logic/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Nat-Interval-Logic/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Nat-Interval-Logic-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Nat-Interval-Logic-2018-08-16.tar.gz">
	+ afp-Nat-Interval-Logic-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Nat-Interval-Logic-2017-10-10.tar.gz">
	afp-Nat-Interval-Logic-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Nat-Interval-Logic-2016-12-17.tar.gz">
	afp-Nat-Interval-Logic-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Nat-Interval-Logic-2016-02-22.tar.gz">
	afp-Nat-Interval-Logic-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Nat-Interval-Logic-2015-05-27.tar.gz">
	afp-Nat-Interval-Logic-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Nat-Interval-Logic-2014-08-28.tar.gz">
	afp-Nat-Interval-Logic-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Nat-Interval-Logic-2013-12-11.tar.gz">
	afp-Nat-Interval-Logic-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Nat-Interval-Logic-2013-11-17.tar.gz">
	afp-Nat-Interval-Logic-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Nat-Interval-Logic-2013-02-16.tar.gz">
	afp-Nat-Interval-Logic-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Nat-Interval-Logic-2012-05-24.tar.gz">
	afp-Nat-Interval-Logic-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Nat-Interval-Logic-2011-10-11.tar.gz">
	afp-Nat-Interval-Logic-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Nat-Interval-Logic-2011-02-24.tar.gz">
	afp-Nat-Interval-Logic-2011-02-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Native_Word.html b/web/entries/Native_Word.html
	--- a/web/entries/Native_Word.html
	+++ b/web/entries/Native_Word.html
	@@ -1,228 +1,233 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Native Word - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">N</font>ative

	<font class="first">W</font>ord

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Native Word</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-09-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This entry makes machine words and machine arithmetic available for code generation from Isabelle/HOL. It provides a common abstraction that hides the differences between the different target languages. The code generator maps these operations to the APIs of the target languages. Apart from that, we extend the available bit operations on types int and integer, and map them to the operations in the target languages.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2013-11-06]:
	added conversion function between native words and characters
	(revision fd23d9a7fe3a)<br>
	[2014-03-31]:
	added words of default size in the target language (by Peter Lammich)
	(revision 25caf5065833)<br>
	[2014-10-06]:
	proper test setup with compilation and execution of tests in all target languages
	(revision 5d7a1c9ae047)<br>
	[2017-09-02]:
	added 64-bit words (revision c89f86244e3c)<br>
	[2018-07-15]:
	added cast operators for default-size words (revision fc1f1fb8dd30)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Native_Word-AFP,
	author = {Andreas Lochbihler},
	title = {Native Word},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Native_Word.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	- <td class="data"><a href="Collections.html">Collections</a>, <a href="Datatype_Order_Generator.html">Datatype_Order_Generator</a>, <a href="Deriving.html">Deriving</a>, <a href="Iptables_Semantics.html">Iptables_Semantics</a>, <a href="JinjaThreads.html">JinjaThreads</a>, <a href="ROBDD.html">ROBDD</a>, <a href="Separation_Logic_Imperative_HOL.html">Separation_Logic_Imperative_HOL</a>, <a href="WebAssembly.html">WebAssembly</a> </td></tr>
	+ <td class="data"><a href="Collections.html">Collections</a>, <a href="Datatype_Order_Generator.html">Datatype_Order_Generator</a>, <a href="Iptables_Semantics.html">Iptables_Semantics</a>, <a href="JinjaThreads.html">JinjaThreads</a>, <a href="ROBDD.html">ROBDD</a>, <a href="Separation_Logic_Imperative_HOL.html">Separation_Logic_Imperative_HOL</a>, <a href="WebAssembly.html">WebAssembly</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Native_Word/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Native_Word/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Native_Word/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Native_Word-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Native_Word-2018-08-16.tar.gz">
	+ afp-Native_Word-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Native_Word-2017-10-10.tar.gz">
	afp-Native_Word-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Native_Word-2016-12-17.tar.gz">
	afp-Native_Word-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Native_Word-2016-02-22.tar.gz">
	afp-Native_Word-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Native_Word-2015-05-27.tar.gz">
	afp-Native_Word-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Native_Word-2014-08-28.tar.gz">
	afp-Native_Word-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Native_Word-2013-12-11.tar.gz">
	afp-Native_Word-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Native_Word-2013-11-17.tar.gz">
	afp-Native_Word-2013-11-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Nested_Multisets_Ordinals.html b/web/entries/Nested_Multisets_Ordinals.html
	--- a/web/entries/Nested_Multisets_Ordinals.html
	+++ b/web/entries/Nested_Multisets_Ordinals.html
	@@ -1,197 +1,202 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of Nested Multisets, Hereditary Multisets, and Syntactic Ordinals - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	<font class="first">N</font>ested

	<font class="first">M</font>ultisets,

	<font class="first">H</font>ereditary

	<font class="first">M</font>ultisets,

	and

	<font class="first">S</font>yntactic

	<font class="first">O</font>rdinals

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of Nested Multisets, Hereditary Multisets, and Syntactic Ordinals</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl),
	Mathias Fleury (fleury /at/ mpi-inf /dot/ mpg /dot/ de) and
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-11-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This Isabelle/HOL formalization introduces a nested multiset datatype and defines Dershowitz and Manna's nested multiset order. The order is proved well founded and linear. By removing one constructor, we transform the nested multisets into hereditary multisets. These are isomorphic to the syntactic ordinals—the ordinals can be recursively expressed in Cantor normal form. Addition, subtraction, multiplication, and linear orders are provided on this type.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Nested_Multisets_Ordinals-AFP,
	author = {Jasmin Christian Blanchette and Mathias Fleury and Dmitriy Traytel},
	title = {Formalization of Nested Multisets, Hereditary Multisets, and Syntactic Ordinals},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Nested_Multisets_Ordinals.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="List-Index.html">List-Index</a>, <a href="Ordinal.html">Ordinal</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Functional_Ordered_Resolution_Prover.html">Functional_Ordered_Resolution_Prover</a>, <a href="Lambda_Free_KBOs.html">Lambda_Free_KBOs</a>, <a href="Ordered_Resolution_Prover.html">Ordered_Resolution_Prover</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Nested_Multisets_Ordinals/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Nested_Multisets_Ordinals/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Nested_Multisets_Ordinals/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Nested_Multisets_Ordinals-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Nested_Multisets_Ordinals-2018-08-16.tar.gz">
	+ afp-Nested_Multisets_Ordinals-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Nested_Multisets_Ordinals-2017-10-10.tar.gz">
	afp-Nested_Multisets_Ordinals-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Nested_Multisets_Ordinals-2016-12-17.tar.gz">
	afp-Nested_Multisets_Ordinals-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Network_Security_Policy_Verification.html b/web/entries/Network_Security_Policy_Verification.html
	--- a/web/entries/Network_Security_Policy_Verification.html
	+++ b/web/entries/Network_Security_Policy_Verification.html
	@@ -1,243 +1,248 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Network Security Policy Verification - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">N</font>etwork

	<font class="first">S</font>ecurity

	<font class="first">P</font>olicy

	<font class="first">V</font>erification

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Network Security Policy Verification</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-07-04</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	<ul>
	<li>Secure auto-completion of scenario-specific knowledge, which eases usability.</li>
	<li>Security violations can be repaired by tightening the policy iff the
	security invariants hold for the deny-all policy.</li>
	<li>An algorithm to compute a security policy.</li>
	<li>A formalization of stateful connection semantics in network security mechanisms.</li>
	<li>An algorithm to compute a secure stateful implementation of a policy.</li>
	<li>An executable implementation of all the theory.</li>
	<li>Examples, ranging from an aircraft cabin data network to the analysis
	of a large real-world firewall.</li>
	<li>More examples: A fully automated translation of high-level security goals to both
	firewall and SDN configurations (see Examples/Distributed_WebApp.thy).</li>
	</ul>
	For a detailed description, see
	<ul>
	<li>C. Diekmann, A. Korsten, and G. Carle.
	<a href="http://www.net.in.tum.de/fileadmin/bibtex/publications/papers/diekmann2015mansdnnfv.pdf">Demonstrating
	topoS: Theorem-prover-based synthesis of secure network configurations.</a>
	In 2nd International Workshop on Management of SDN and NFV Systems, manSDN/NFV, Barcelona, Spain, November 2015.</li>
	<li>C. Diekmann, S.-A. Posselt, H. Niedermayer, H. Kinkelin, O. Hanka, and G. Carle.
	<a href="http://www.net.in.tum.de/pub/diekmann/forte14.pdf">Verifying Security Policies using Host Attributes.</a>
	In FORTE, 34th IFIP International Conference on Formal Techniques for Distributed Objects,
	Components and Systems, Berlin, Germany, June 2014.</li>
	<li>C. Diekmann, L. Hupel, and G. Carle. Directed Security Policies:
	<a href="http://rvg.web.cse.unsw.edu.au/eptcs/paper.cgi?ESSS2014.3">A Stateful Network Implementation.</a>
	In J. Pang and Y. Liu, editors, Engineering Safety and Security Systems,
	volume 150 of Electronic Proceedings in Theoretical Computer Science,
	pages 20-34, Singapore, May 2014. Open Publishing Association.</li>
	</ul></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-04-14]:
	Added Distributed WebApp example and improved graphviz visualization
	(revision 4dde08ca2ab8)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Network_Security_Policy_Verification.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Automatic_Refinement.html">Automatic_Refinement</a>, <a href="Transitive-Closure.html">Transitive-Closure</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Network_Security_Policy_Verification/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Network_Security_Policy_Verification/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Network_Security_Policy_Verification/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Network_Security_Policy_Verification-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Network_Security_Policy_Verification-2018-08-16.tar.gz">
	+ afp-Network_Security_Policy_Verification-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Network_Security_Policy_Verification-2017-10-10.tar.gz">
	afp-Network_Security_Policy_Verification-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Network_Security_Policy_Verification-2016-12-17.tar.gz">
	afp-Network_Security_Policy_Verification-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Network_Security_Policy_Verification-2016-02-22.tar.gz">
	afp-Network_Security_Policy_Verification-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Network_Security_Policy_Verification-2015-05-27.tar.gz">
	afp-Network_Security_Policy_Verification-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Network_Security_Policy_Verification-2014-08-28.tar.gz">
	afp-Network_Security_Policy_Verification-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Network_Security_Policy_Verification-2014-07-09.tar.gz">
	afp-Network_Security_Policy_Verification-2014-07-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Neumann_Morgenstern_Utility.html b/web/entries/Neumann_Morgenstern_Utility.html
	--- a/web/entries/Neumann_Morgenstern_Utility.html
	+++ b/web/entries/Neumann_Morgenstern_Utility.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Von-Neumann-Morgenstern Utility Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>on-Neumann-Morgenstern

	<font class="first">U</font>tility

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Von-Neumann-Morgenstern Utility Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Julian Parsert (julian /dot/ parsert /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/users/cek/">Cezary Kaliszyk</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-07-04</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Utility functions form an essential part of game theory and economics.
	In order to guarantee the existence of utility functions most of the
	time sufficient properties are assumed in an axiomatic manner. One
	famous and very common set of such assumptions is that of expected
	utility theory. Here, the rationality, continuity, and independence of
	preferences is assumed. The von-Neumann-Morgenstern Utility theorem
	shows that these assumptions are necessary and sufficient for an
	expected utility function to exists. This theorem was proven by
	Neumann and Morgenstern in ``Theory of Games and Economic
	Behavior'' which is regarded as one of the most influential
	works in game theory. The formalization includes formal definitions of
	the underlying concepts including continuity and independence of
	preferences.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Neumann_Morgenstern_Utility-AFP,
	author = {Julian Parsert and Cezary Kaliszyk},
	title = {Von-Neumann-Morgenstern Utility Theorem},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Neumann_Morgenstern_Utility.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="First_Welfare_Theorem.html">First_Welfare_Theorem</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Neumann_Morgenstern_Utility/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Neumann_Morgenstern_Utility/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Neumann_Morgenstern_Utility/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Neumann_Morgenstern_Utility-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Neumann_Morgenstern_Utility-2018-08-16.tar.gz">
	+ afp-Neumann_Morgenstern_Utility-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Neumann_Morgenstern_Utility-2018-07-04.tar.gz">
	afp-Neumann_Morgenstern_Utility-2018-07-04.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/No_FTL_observers.html b/web/entries/No_FTL_observers.html
	--- a/web/entries/No_FTL_observers.html
	+++ b/web/entries/No_FTL_observers.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>No Faster-Than-Light Observers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">N</font>o

	<font class="first">F</font>aster-Than-Light

	<font class="first">O</font>bservers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">No Faster-Than-Light Observers</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Mike Stannett (m /dot/ stannett /at/ sheffield /dot/ ac /dot/ uk) and
	<a href="http://www.renyi.hu/~nemeti/">István Németi</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-04-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We provide a formal proof within First Order Relativity Theory that no
	observer can travel faster than the speed of light. Originally
	reported in Stannett & Németi (2014) "Using Isabelle/HOL to verify
	first-order relativity theory", Journal of Automated Reasoning 52(4),
	pp. 361-378.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{No_FTL_observers-AFP,
	author = {Mike Stannett and István Németi},
	title = {No Faster-Than-Light Observers},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/No_FTL_observers.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/No_FTL_observers/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/No_FTL_observers/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/No_FTL_observers/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-No_FTL_observers-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-No_FTL_observers-2018-08-16.tar.gz">
	+ afp-No_FTL_observers-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-No_FTL_observers-2017-10-10.tar.gz">
	afp-No_FTL_observers-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-No_FTL_observers-2016-12-17.tar.gz">
	afp-No_FTL_observers-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-No_FTL_observers-2016-04-28.tar.gz">
	afp-No_FTL_observers-2016-04-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Nominal2.html b/web/entries/Nominal2.html
	--- a/web/entries/Nominal2.html
	+++ b/web/entries/Nominal2.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Nominal 2 - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">N</font>ominal

	<font class="first">2</font>

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Nominal 2</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.inf.kcl.ac.uk/staff/urbanc/">Christian Urban</a>,
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a> and
	<a href="http://cl-informatik.uibk.ac.at/users/cek/">Cezary Kaliszyk</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-02-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>Dealing with binders, renaming of bound variables, capture-avoiding
	substitution, etc., is very often a major problem in formal
	proofs, especially in proofs by structural and rule
	induction. Nominal Isabelle is designed to make such proofs easy to
	formalise: it provides an infrastructure for declaring nominal
	datatypes (that is alpha-equivalence classes) and for defining
	functions over them by structural recursion. It also provides
	induction principles that have Barendregt’s variable convention
	already built in.
	</p><p>
	This entry can be used as a more advanced replacement for
	HOL/Nominal in the Isabelle distribution.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Nominal2-AFP,
	author = {Christian Urban and Stefan Berghofer and Cezary Kaliszyk},
	title = {Nominal 2},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Nominal2.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="FinFun.html">FinFun</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Incompleteness.html">Incompleteness</a>, <a href="LambdaAuth.html">LambdaAuth</a>, <a href="Launchbury.html">Launchbury</a>, <a href="Modal_Logics_for_NTS.html">Modal_Logics_for_NTS</a>, <a href="Rewriting_Z.html">Rewriting_Z</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Nominal2/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Nominal2/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Nominal2/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Nominal2-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Nominal2-2018-08-16.tar.gz">
	+ afp-Nominal2-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Nominal2-2017-10-10.tar.gz">
	afp-Nominal2-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Nominal2-2016-12-17.tar.gz">
	afp-Nominal2-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Nominal2-2016-04-24.tar.gz">
	afp-Nominal2-2016-04-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Nominal2-2013-11-17.tar.gz">
	afp-Nominal2-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Nominal2-2013-02-24.tar.gz">
	afp-Nominal2-2013-02-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Noninterference_CSP.html b/web/entries/Noninterference_CSP.html
	--- a/web/entries/Noninterference_CSP.html
	+++ b/web/entries/Noninterference_CSP.html
	@@ -1,235 +1,240 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Noninterference Security in Communicating Sequential Processes - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">N</font>oninterference

	<font class="first">S</font>ecurity

	in

	<font class="first">C</font>ommunicating

	<font class="first">S</font>equential

	<font class="first">P</font>rocesses

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Noninterference Security in Communicating Sequential Processes</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-05-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	An extension of classical noninterference security for deterministic
	state machines, as introduced by Goguen and Meseguer and elegantly
	formalized by Rushby, to nondeterministic systems should satisfy two
	fundamental requirements: it should be based on a mathematically precise
	theory of nondeterminism, and should be equivalent to (or at least not
	weaker than) the classical notion in the degenerate deterministic case.
	</p>
	<p>
	This paper proposes a definition of noninterference security applying
	to Hoare's Communicating Sequential Processes (CSP) in the general case of
	a possibly intransitive noninterference policy, and proves the
	equivalence of this security property to classical noninterference
	security for processes representing deterministic state machines.
	</p>
	<p>
	Furthermore, McCullough's generalized noninterference security is shown
	to be weaker than both the proposed notion of CSP noninterference security
	for a generic process, and classical noninterference security for processes
	representing deterministic state machines. This renders CSP noninterference
	security preferable as an extension of classical noninterference security
	to nondeterministic systems.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Noninterference_CSP-AFP,
	author = {Pasquale Noce},
	title = {Noninterference Security in Communicating Sequential Processes},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Noninterference_CSP.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Noninterference_Ipurge_Unwinding.html">Noninterference_Ipurge_Unwinding</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_CSP/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Noninterference_CSP/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_CSP/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Noninterference_CSP-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Noninterference_CSP-2018-08-16.tar.gz">
	+ afp-Noninterference_CSP-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Noninterference_CSP-2017-10-10.tar.gz">
	afp-Noninterference_CSP-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Noninterference_CSP-2016-12-17.tar.gz">
	afp-Noninterference_CSP-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Noninterference_CSP-2016-02-22.tar.gz">
	afp-Noninterference_CSP-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Noninterference_CSP-2015-06-13.tar.gz">
	afp-Noninterference_CSP-2015-06-13.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Noninterference_CSP-2015-05-27.tar.gz">
	afp-Noninterference_CSP-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Noninterference_CSP-2014-08-28.tar.gz">
	afp-Noninterference_CSP-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Noninterference_CSP-2014-05-24.tar.gz">
	afp-Noninterference_CSP-2014-05-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Noninterference_Concurrent_Composition.html b/web/entries/Noninterference_Concurrent_Composition.html
	--- a/web/entries/Noninterference_Concurrent_Composition.html
	+++ b/web/entries/Noninterference_Concurrent_Composition.html
	@@ -1,213 +1,218 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Conservation of CSP Noninterference Security under Concurrent Composition - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>onservation

	of

	<font class="first">C</font>SP

	<font class="first">N</font>oninterference

	<font class="first">S</font>ecurity

	under

	<font class="first">C</font>oncurrent

	<font class="first">C</font>omposition

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Conservation of CSP Noninterference Security under Concurrent Composition</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>In his outstanding work on Communicating Sequential Processes,
	Hoare has defined two fundamental binary operations allowing to
	compose the input processes into another, typically more complex,
	process: sequential composition and concurrent composition.
	Particularly, the output of the latter operation is a process in which
	any event not shared by both operands can occur whenever the operand
	that admits the event can engage in it, whereas any event shared by
	both operands can occur just in case both can engage in it.</p>
	<p>This paper formalizes Hoare's definition of concurrent composition
	and proves, in the general case of a possibly intransitive policy,
	that CSP noninterference security is conserved under this operation.
	This result, along with the previous analogous one concerning
	sequential composition, enables the construction of more and more
	complex processes enforcing noninterference security by composing,
	sequentially or concurrently, simpler secure processes, whose security
	can in turn be proven using either the definition of security, or
	unwinding theorems.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Noninterference_Concurrent_Composition-AFP,
	author = {Pasquale Noce},
	title = {Conservation of CSP Noninterference Security under Concurrent Composition},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Noninterference_Concurrent_Composition.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Noninterference_Sequential_Composition.html">Noninterference_Sequential_Composition</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Concurrent_Composition/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Noninterference_Concurrent_Composition/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Concurrent_Composition/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Noninterference_Concurrent_Composition-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Noninterference_Concurrent_Composition-2018-08-16.tar.gz">
	+ afp-Noninterference_Concurrent_Composition-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Noninterference_Concurrent_Composition-2017-10-10.tar.gz">
	afp-Noninterference_Concurrent_Composition-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Noninterference_Concurrent_Composition-2016-12-17.tar.gz">
	afp-Noninterference_Concurrent_Composition-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Noninterference_Concurrent_Composition-2016-06-13.tar.gz">
	afp-Noninterference_Concurrent_Composition-2016-06-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Noninterference_Generic_Unwinding.html b/web/entries/Noninterference_Generic_Unwinding.html
	--- a/web/entries/Noninterference_Generic_Unwinding.html
	+++ b/web/entries/Noninterference_Generic_Unwinding.html
	@@ -1,233 +1,238 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Generic Unwinding Theorem for CSP Noninterference Security - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">G</font>eneric

	<font class="first">U</font>nwinding

	<font class="first">T</font>heorem

	for

	<font class="first">C</font>SP

	<font class="first">N</font>oninterference

	<font class="first">S</font>ecurity

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Generic Unwinding Theorem for CSP Noninterference Security</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-06-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	The classical definition of noninterference security for a deterministic state
	machine with outputs requires to consider the outputs produced by machine
	actions after any trace, i.e. any indefinitely long sequence of actions, of the
	machine. In order to render the verification of the security of such a machine
	more straightforward, there is a need of some sufficient condition for security
	such that just individual actions, rather than unbounded sequences of actions,
	have to be considered.
	</p><p>
	By extending previous results applying to transitive noninterference policies,
	Rushby has proven an unwinding theorem that provides a sufficient condition of
	this kind in the general case of a possibly intransitive policy. This condition
	has to be satisfied by a generic function mapping security domains into
	equivalence relations over machine states.
	</p><p>
	An analogous problem arises for CSP noninterference security, whose definition
	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.
	</p><p>
	This paper provides a 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 one for classical noninterference security, and has
	to be satisfied by a generic function mapping security domains into equivalence
	relations over process traces; hence its name, Generic Unwinding Theorem.
	Variants of this theorem applying to deterministic processes and trace set
	processes are also proven. Finally, the sufficient condition for security
	expressed by the theorem is shown not to be a necessary condition as well, viz.
	there exists a secure process such that no domain-relation map satisfying the
	condition exists.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Noninterference_Generic_Unwinding-AFP,
	author = {Pasquale Noce},
	title = {The Generic Unwinding Theorem for CSP Noninterference Security},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Noninterference_Generic_Unwinding.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Noninterference_Ipurge_Unwinding.html">Noninterference_Ipurge_Unwinding</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Generic_Unwinding/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Noninterference_Generic_Unwinding/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Generic_Unwinding/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Noninterference_Generic_Unwinding-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Noninterference_Generic_Unwinding-2018-08-16.tar.gz">
	+ afp-Noninterference_Generic_Unwinding-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Noninterference_Generic_Unwinding-2017-10-10.tar.gz">
	afp-Noninterference_Generic_Unwinding-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Noninterference_Generic_Unwinding-2016-12-17.tar.gz">
	afp-Noninterference_Generic_Unwinding-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Noninterference_Generic_Unwinding-2016-02-22.tar.gz">
	afp-Noninterference_Generic_Unwinding-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Noninterference_Generic_Unwinding-2015-06-13.tar.gz">
	afp-Noninterference_Generic_Unwinding-2015-06-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Noninterference_Inductive_Unwinding.html b/web/entries/Noninterference_Inductive_Unwinding.html
	--- a/web/entries/Noninterference_Inductive_Unwinding.html
	+++ b/web/entries/Noninterference_Inductive_Unwinding.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Inductive Unwinding Theorem for CSP Noninterference Security - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">I</font>nductive

	<font class="first">U</font>nwinding

	<font class="first">T</font>heorem

	for

	<font class="first">C</font>SP

	<font class="first">N</font>oninterference

	<font class="first">S</font>ecurity

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Inductive Unwinding Theorem for CSP Noninterference Security</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-08-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	The necessary and sufficient condition for CSP noninterference security stated by the Ipurge Unwinding Theorem is expressed in terms of a pair of event lists varying over the set of process traces. This does not render it suitable for the subsequent application of rule induction in the case of a process defined inductively, since rule induction may rather be applied to a single variable ranging over an inductively defined set.
	</p><p>
	Starting from the Ipurge Unwinding Theorem, this paper derives a necessary and sufficient condition for CSP noninterference security that involves a single event list varying over the set of process traces, and is thus suitable for rule induction; hence its name, Inductive Unwinding Theorem. Similarly to the Ipurge Unwinding Theorem, the new theorem only requires to consider individual accepted and refused events for each process trace, and applies to the general case of a possibly intransitive noninterference policy. Specific variants of this theorem are additionally proven for deterministic processes and trace set processes.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Noninterference_Inductive_Unwinding-AFP,
	author = {Pasquale Noce},
	title = {The Inductive Unwinding Theorem for CSP Noninterference Security},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Noninterference_Inductive_Unwinding.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Noninterference_Ipurge_Unwinding.html">Noninterference_Ipurge_Unwinding</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Inductive_Unwinding/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Noninterference_Inductive_Unwinding/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Inductive_Unwinding/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Noninterference_Inductive_Unwinding-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Noninterference_Inductive_Unwinding-2018-08-16.tar.gz">
	+ afp-Noninterference_Inductive_Unwinding-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Noninterference_Inductive_Unwinding-2017-10-10.tar.gz">
	afp-Noninterference_Inductive_Unwinding-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Noninterference_Inductive_Unwinding-2016-12-17.tar.gz">
	afp-Noninterference_Inductive_Unwinding-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Noninterference_Inductive_Unwinding-2016-02-22.tar.gz">
	afp-Noninterference_Inductive_Unwinding-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Noninterference_Inductive_Unwinding-2015-08-19.tar.gz">
	afp-Noninterference_Inductive_Unwinding-2015-08-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Noninterference_Ipurge_Unwinding.html b/web/entries/Noninterference_Ipurge_Unwinding.html
	--- a/web/entries/Noninterference_Ipurge_Unwinding.html
	+++ b/web/entries/Noninterference_Ipurge_Unwinding.html
	@@ -1,234 +1,239 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Ipurge Unwinding Theorem for CSP Noninterference Security - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">I</font>purge

	<font class="first">U</font>nwinding

	<font class="first">T</font>heorem

	for

	<font class="first">C</font>SP

	<font class="first">N</font>oninterference

	<font class="first">S</font>ecurity

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Ipurge Unwinding Theorem for CSP Noninterference Security</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-06-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	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.
	</p><p>
	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.
	</p><p>
	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.
	</p><p>
	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.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Noninterference_Ipurge_Unwinding.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="List_Interleaving.html">List_Interleaving</a>, <a href="Noninterference_CSP.html">Noninterference_CSP</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Noninterference_Generic_Unwinding.html">Noninterference_Generic_Unwinding</a>, <a href="Noninterference_Inductive_Unwinding.html">Noninterference_Inductive_Unwinding</a>, <a href="Noninterference_Sequential_Composition.html">Noninterference_Sequential_Composition</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Ipurge_Unwinding/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Noninterference_Ipurge_Unwinding/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Ipurge_Unwinding/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Noninterference_Ipurge_Unwinding-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Noninterference_Ipurge_Unwinding-2018-08-16.tar.gz">
	+ afp-Noninterference_Ipurge_Unwinding-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Noninterference_Ipurge_Unwinding-2017-10-10.tar.gz">
	afp-Noninterference_Ipurge_Unwinding-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Noninterference_Ipurge_Unwinding-2016-12-17.tar.gz">
	afp-Noninterference_Ipurge_Unwinding-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Noninterference_Ipurge_Unwinding-2016-02-22.tar.gz">
	afp-Noninterference_Ipurge_Unwinding-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Noninterference_Ipurge_Unwinding-2015-06-13.tar.gz">
	afp-Noninterference_Ipurge_Unwinding-2015-06-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Noninterference_Sequential_Composition.html b/web/entries/Noninterference_Sequential_Composition.html
	--- a/web/entries/Noninterference_Sequential_Composition.html
	+++ b/web/entries/Noninterference_Sequential_Composition.html
	@@ -1,214 +1,219 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Conservation of CSP Noninterference Security under Sequential Composition - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>onservation

	of

	<font class="first">C</font>SP

	<font class="first">N</font>oninterference

	<font class="first">S</font>ecurity

	under

	<font class="first">S</font>equential

	<font class="first">C</font>omposition

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Conservation of CSP Noninterference Security under Sequential Composition</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-04-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>In his outstanding work on Communicating Sequential Processes, Hoare
	has defined two fundamental binary operations allowing to compose the
	input processes into another, typically more complex, process:
	sequential composition and concurrent composition. Particularly, the
	output of the former operation is a process that initially behaves
	like the first operand, and then like the second operand once the
	execution of the first one has terminated successfully, as long as it
	does.</p>
	<p>This paper formalizes Hoare's definition of sequential
	composition and proves, in the general case of a possibly intransitive
	policy, that CSP noninterference security is conserved under this
	operation, provided that successful termination cannot be affected by
	confidential events and cannot occur as an alternative to other events
	in the traces of the first operand. Both of these assumptions are
	shown, by means of counterexamples, to be necessary for the theorem to
	hold.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Noninterference_Sequential_Composition-AFP,
	author = {Pasquale Noce},
	title = {Conservation of CSP Noninterference Security under Sequential Composition},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Noninterference_Sequential_Composition.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Noninterference_Ipurge_Unwinding.html">Noninterference_Ipurge_Unwinding</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Noninterference_Concurrent_Composition.html">Noninterference_Concurrent_Composition</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Sequential_Composition/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Noninterference_Sequential_Composition/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Noninterference_Sequential_Composition/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Noninterference_Sequential_Composition-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Noninterference_Sequential_Composition-2018-08-16.tar.gz">
	+ afp-Noninterference_Sequential_Composition-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Noninterference_Sequential_Composition-2017-10-10.tar.gz">
	afp-Noninterference_Sequential_Composition-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Noninterference_Sequential_Composition-2016-12-17.tar.gz">
	afp-Noninterference_Sequential_Composition-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Noninterference_Sequential_Composition-2016-04-26.tar.gz">
	afp-Noninterference_Sequential_Composition-2016-04-26.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/NormByEval.html b/web/entries/NormByEval.html
	--- a/web/entries/NormByEval.html
	+++ b/web/entries/NormByEval.html
	@@ -1,255 +1,260 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Normalization by Evaluation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">N</font>ormalization

	by

	<font class="first">E</font>valuation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Normalization by Evaluation</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.linta.de/~aehlig/">Klaus Aehlig</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-02-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This article formalizes normalization by evaluation as implemented in Isabelle. Lambda calculus plus term rewriting is compiled into a functional program with pattern matching. It is proved that the result of a successful evaluation is a) correct, i.e. equivalent to the input, and b) in normal form.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{NormByEval-AFP,
	author = {Klaus Aehlig and Tobias Nipkow},
	title = {Normalization by Evaluation},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/NormByEval.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/NormByEval/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/NormByEval/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/NormByEval/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-NormByEval-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-NormByEval-2018-08-16.tar.gz">
	+ afp-NormByEval-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-NormByEval-2017-10-10.tar.gz">
	afp-NormByEval-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-NormByEval-2016-12-17.tar.gz">
	afp-NormByEval-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-NormByEval-2016-02-22.tar.gz">
	afp-NormByEval-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-NormByEval-2015-05-27.tar.gz">
	afp-NormByEval-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-NormByEval-2014-08-28.tar.gz">
	afp-NormByEval-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-NormByEval-2013-12-11.tar.gz">
	afp-NormByEval-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-NormByEval-2013-11-17.tar.gz">
	afp-NormByEval-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-NormByEval-2013-02-16.tar.gz">
	afp-NormByEval-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-NormByEval-2012-05-24.tar.gz">
	afp-NormByEval-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-NormByEval-2011-10-11.tar.gz">
	afp-NormByEval-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-NormByEval-2011-02-11.tar.gz">
	afp-NormByEval-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-NormByEval-2010-07-01.tar.gz">
	afp-NormByEval-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-NormByEval-2009-12-12.tar.gz">
	afp-NormByEval-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-NormByEval-2009-04-29.tar.gz">
	afp-NormByEval-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-NormByEval-2008-06-10.tar.gz">
	afp-NormByEval-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-NormByEval-2008-02-22.tar.gz">
	afp-NormByEval-2008-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-NormByEval-2008-02-18.tar.gz">
	afp-NormByEval-2008-02-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Nullstellensatz.html b/web/entries/Nullstellensatz.html
	new file mode 100644
	--- /dev/null
	+++ b/web/entries/Nullstellensatz.html
	@@ -0,0 +1,180 @@
	+<!DOCTYPE html>
	+<html lang="en">
	+<head>
	+<meta charset="utf-8">
	+<title>Hilbert's Nullstellensatz - Archive of Formal Proofs
	+</title>
	+<link rel="stylesheet" type="text/css" href="../front.css">
	+<link rel="icon" href="../images/favicon.ico" type="image/icon">
	+<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	+</head>
	+
	+<body>
	+
	+<table width="100%">
	+<tbody>
	+<tr>
	+
	+<!-- Navigation -->
	+<td width="20%" align="center" valign="top">
	+ <p> </p>
	+ <a href="http://isabelle.in.tum.de">
	+ <img src="../images/isabelle.png" width="100" height="86" border=0>
	+ </a>
	+ <p> </p>
	+ <p> </p>
	+ <table class="nav" width="80%">
	+ <tr>
	+ <td class="nav" width="100%"><a href="../index.html">Home</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../about.html">About</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../submitting.html">Submission</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../updating.html">Updating Entries</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../using.html">Using Entries</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../search.html">Search</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../statistics.html">Statistics</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../topics.html">Index</a></td>
	+ </tr>
	+ <tr>
	+ <td class="nav"><a href="../download.html">Download</a></td>
	+ </tr>
	+ </table>
	+ <p> </p>
	+ <p> </p>
	+</td>
	+
	+
	+<!-- Content -->
	+<td width="80%" valign="top">
	+<div align="center">
	+ <p> </p>
	+ <h1> <font class="first">H</font>ilbert's
	+
	+ <font class="first">N</font>ullstellensatz
	+
	+</h1>
	+ <p> </p>
	+
	+<table width="80%" class="data">
	+<tbody>
	+<tr>
	+ <td class="datahead" width="20%">Title:</td>
	+ <td class="data" width="80%">Hilbert's Nullstellensatz</td>
	+</tr>
	+
	+<tr>
	+ <td class="datahead">
	+ Author:
	+ </td>
	+ <td class="data">
	+ <a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>
	+ </td>
	+</tr>
	+
	+
	+
	+<tr>
	+ <td class="datahead">Submission date:</td>
	+ <td class="data">2019-06-16</td>
	+</tr>
	+
	+<tr>
	+ <td class="datahead" valign="top">Abstract:</td>
	+ <td class="abstract">
	+This entry formalizes Hilbert's Nullstellensatz, an important
	+theorem in algebraic geometry that can be viewed as the generalization
	+of the Fundamental Theorem of Algebra to multivariate polynomials: If
	+a set of (multivariate) polynomials over an algebraically closed field
	+has no common zero, then the ideal it generates is the entire
	+polynomial ring. The formalization proves several equivalent versions
	+of this celebrated theorem: the weak Nullstellensatz, the strong
	+Nullstellensatz (connecting algebraic varieties and radical ideals),
	+and the field-theoretic Nullstellensatz. The formalization follows
	+Chapter 4.1. of <a
	+href="https://link.springer.com/book/10.1007/978-0-387-35651-8">Ideals,
	+Varieties, and Algorithms</a> by Cox, Little and O'Shea.</td>
	+</tr>
	+
	+
	+<tr>
	+ <td class="datahead" valign="top">BibTeX:</td>
	+ <td class="formatted">
	+ <pre>@article{Nullstellensatz-AFP,
	+ author = {Alexander Maletzky},
	+ title = {Hilbert's Nullstellensatz},
	+ journal = {Archive of Formal Proofs},
	+ month = jun,
	+ year = 2019,
	+ note = {\url{http://isa-afp.org/entries/Nullstellensatz.html},
	+ Formal proof development},
	+ ISSN = {2150-914x},
	+}</pre>
	+ </td>
	+</tr>
	+
	+ <tr><td class="datahead">License:</td>
	+ <td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>
	+
	+
	+ <tr><td class="datahead">Depends on:</td>
	+ <td class="data"><a href="Groebner_Bases.html">Groebner_Bases</a> </td></tr>
	+
	+
	+
	+
	+ </tbody>
	+</table>
	+
	+<p></p>
	+
	+<table class="links">
	+ <tbody>
	+ <tr>
	+ <td class="links">
	+ <a href="../browser_info/current/AFP/Nullstellensatz/outline.pdf">Proof outline</a><br>
	+ <a href="../browser_info/current/AFP/Nullstellensatz/document.pdf">Proof document</a>
	+ </td>
	+ </tr>
	+ <tr>
	+ <td class="links">
	+ <a href="../browser_info/current/AFP/Nullstellensatz/index.html">Browse theories</a>
	+ </td></tr>
	+ <tr>
	+ <td class="links">
	+ <a href="../release/afp-Nullstellensatz-current.tar.gz">Download this entry</a>
	+ </td>
	+ </tr>
	+
	+
	+ <tr><td class="links">Older releases:
	+ None
	+ </td></tr>
	+
	+ </tbody>
	+</table>
	+
	+</div>
	+</td>
	+
	+</tr>
	+</tbody>
	+</table>
	+
	+<script src="../jquery.min.js"></script>
	+<script src="../script.js"></script>
	+
	+</body>
	+</html>
	\ No newline at end of file
	diff --git a/web/entries/Octonions.html b/web/entries/Octonions.html
	--- a/web/entries/Octonions.html
	+++ b/web/entries/Octonions.html
	@@ -1,172 +1,178 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Octonions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">O</font>ctonions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Octonions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~ak2110/">Angeliki Koutsoukou-Argyraki</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-09-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We develop the basic theory of Octonions, including various identities
	and properties of the octonions and of the octonionic product, a
	description of 7D isometries and representations of orthogonal
	transformations. To this end we first develop the theory of the vector
	cross product in 7 dimensions. The development of the theory of
	Octonions is inspired by that of the theory of Quaternions by Lawrence
	Paulson. However, we do not work within the type class real_algebra_1
	because the octonionic product is not associative.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Octonions-AFP,
	author = {Angeliki Koutsoukou-Argyraki},
	title = {Octonions},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Octonions.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Octonions/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Octonions/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Octonions/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Octonions-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Octonions-2018-09-16.tar.gz">
	+ afp-Octonions-2018-09-16.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/OpSets.html b/web/entries/OpSets.html
	--- a/web/entries/OpSets.html
	+++ b/web/entries/OpSets.html
	@@ -1,198 +1,203 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>OpSets: Sequential Specifications for Replicated Datatypes - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">O</font>pSets:

	<font class="first">S</font>equential

	<font class="first">S</font>pecifications

	for

	<font class="first">R</font>eplicated

	<font class="first">D</font>atatypes

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">OpSets: Sequential Specifications for Replicated Datatypes</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Martin Kleppmann (mk428 /at/ cl /dot/ cam /dot/ ac /dot/ uk),
	Victor B. F. Gomes (vb358 /at/ cl /dot/ cam /dot/ ac /dot/ uk),
	Dominic P. Mulligan (Dominic /dot/ Mulligan /at/ arm /dot/ com) and
	Alastair R. Beresford (arb33 /at/ cl /dot/ cam /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-05-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We introduce OpSets, an executable framework for specifying and
	reasoning about the semantics of replicated datatypes that provide
	eventual consistency in a distributed system, and for mechanically
	verifying algorithms that implement these datatypes. Our approach is
	simple but expressive, allowing us to succinctly specify a variety of
	abstract datatypes, including maps, sets, lists, text, graphs, trees,
	and registers. Our datatypes are also composable, enabling the
	construction of complex data structures. To demonstrate the utility of
	OpSets for analysing replication algorithms, we highlight an important
	correctness property for collaborative text editing that has
	traditionally been overlooked; algorithms that do not satisfy this
	property can exhibit awkward interleaving of text. We use OpSets to
	specify this correctness property and prove that although one existing
	replication algorithm satisfies this property, several other published
	algorithms do not.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{OpSets-AFP,
	author = {Martin Kleppmann and Victor B. F. Gomes and Dominic P. Mulligan and Alastair R. Beresford},
	title = {OpSets: Sequential Specifications for Replicated Datatypes},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/OpSets.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/OpSets/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/OpSets/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/OpSets/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-OpSets-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-OpSets-2018-08-16.tar.gz">
	+ afp-OpSets-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-OpSets-2018-05-25.tar.gz">
	afp-OpSets-2018-05-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Open_Induction.html b/web/entries/Open_Induction.html
	--- a/web/entries/Open_Induction.html
	+++ b/web/entries/Open_Induction.html
	@@ -1,217 +1,222 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Open Induction - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">O</font>pen

	<font class="first">I</font>nduction

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Open Induction</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Mizuhito Ogawa and
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-11-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	A proof of the open induction schema based on J.-C. Raoult, Proving open properties by induction, <i>Information Processing Letters</i> 29, 1988, pp.19-23.
	<p>This research was supported by the Austrian Science Fund (FWF): J3202.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Open_Induction-AFP,
	author = {Mizuhito Ogawa and Christian Sternagel},
	title = {Open Induction},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Open_Induction.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Decreasing-Diagrams-II.html">Decreasing-Diagrams-II</a>, <a href="Functional_Ordered_Resolution_Prover.html">Functional_Ordered_Resolution_Prover</a>, <a href="Myhill-Nerode.html">Myhill-Nerode</a>, <a href="Well_Quasi_Orders.html">Well_Quasi_Orders</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Open_Induction/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Open_Induction/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Open_Induction/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Open_Induction-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Open_Induction-2018-08-16.tar.gz">
	+ afp-Open_Induction-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Open_Induction-2017-10-10.tar.gz">
	afp-Open_Induction-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Open_Induction-2016-12-17.tar.gz">
	afp-Open_Induction-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Open_Induction-2016-02-22.tar.gz">
	afp-Open_Induction-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Open_Induction-2015-05-27.tar.gz">
	afp-Open_Induction-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Open_Induction-2014-08-28.tar.gz">
	afp-Open_Induction-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Open_Induction-2013-12-11.tar.gz">
	afp-Open_Induction-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Open_Induction-2013-11-17.tar.gz">
	afp-Open_Induction-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Open_Induction-2013-03-02.tar.gz">
	afp-Open_Induction-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Open_Induction-2013-02-16.tar.gz">
	afp-Open_Induction-2013-02-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Optics.html b/web/entries/Optics.html
	--- a/web/entries/Optics.html
	+++ b/web/entries/Optics.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Optics - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">O</font>ptics

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Optics</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www-users.cs.york.ac.uk/~simonf/">Simon Foster</a> and
	Frank Zeyda
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Lenses provide an abstract interface for manipulating data types
	through spatially-separated views. They are defined abstractly in
	terms of two functions, <em>get</em>, the return a value
	from the source type, and <em>put</em> that updates the
	value. We mechanise the underlying theory of lenses, in terms of an
	algebraic hierarchy of lenses, including well-behaved and very
	well-behaved lenses, each lens class being characterised by a set of
	lens laws. We also mechanise a lens algebra in Isabelle that enables
	their composition and comparison, so as to allow construction of
	complex lenses. This is accompanied by a large library of algebraic
	laws. Moreover we also show how the lens classes can be applied by
	instantiating them with a number of Isabelle data types.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Optics-AFP,
	author = {Simon Foster and Frank Zeyda},
	title = {Optics},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Optics.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="UTP.html">UTP</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Optics/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Optics/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Optics/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Optics-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Optics-2018-08-16.tar.gz">
	+ afp-Optics-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Optics-2017-10-10.tar.gz">
	afp-Optics-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Optics-2017-06-01.tar.gz">
	afp-Optics-2017-06-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Optimal_BST.html b/web/entries/Optimal_BST.html
	--- a/web/entries/Optimal_BST.html
	+++ b/web/entries/Optimal_BST.html
	@@ -1,185 +1,190 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Optimal Binary Search Trees - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">O</font>ptimal

	<font class="first">B</font>inary

	<font class="first">S</font>earch

	<font class="first">T</font>rees

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Optimal Binary Search Trees</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a> and
	Dániel Somogyi
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-05-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This article formalizes recursive algorithms for the construction
	of optimal binary search trees given fixed access frequencies.
	We follow Knuth (1971), Yao (1980) and Mehlhorn (1984).
	The algorithms are memoized with the help of the AFP article
	<a href="Monad_Memo_DP.html">Monadification, Memoization and Dynamic Programming</a>,
	thus yielding dynamic programming algorithms.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Optimal_BST-AFP,
	author = {Tobias Nipkow and Dániel Somogyi},
	title = {Optimal Binary Search Trees},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Optimal_BST.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Monad_Memo_DP.html">Monad_Memo_DP</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Optimal_BST/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Optimal_BST/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Optimal_BST/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Optimal_BST-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Optimal_BST-2018-08-16.tar.gz">
	+ afp-Optimal_BST-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Optimal_BST-2018-05-29.tar.gz">
	afp-Optimal_BST-2018-05-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Orbit_Stabiliser.html b/web/entries/Orbit_Stabiliser.html
	--- a/web/entries/Orbit_Stabiliser.html
	+++ b/web/entries/Orbit_Stabiliser.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Orbit-Stabiliser Theorem with Application to Rotational Symmetries - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">O</font>rbit-Stabiliser

	<font class="first">T</font>heorem

	with

	<font class="first">A</font>pplication

	to

	<font class="first">R</font>otational

	<font class="first">S</font>ymmetries

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Orbit-Stabiliser Theorem with Application to Rotational Symmetries</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Jonas Rädle (jonas /dot/ raedle /at/ tum /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-08-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The Orbit-Stabiliser theorem is a basic result in the algebra of
	groups that factors the order of a group into the sizes of its orbits
	and stabilisers. We formalize the notion of a group action and the
	related concepts of orbits and stabilisers. This allows us to prove
	the orbit-stabiliser theorem. In the second part of this work, we
	formalize the tetrahedral group and use the orbit-stabiliser theorem
	to prove that there are twelve (orientation-preserving) rotations of
	the tetrahedron.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Orbit_Stabiliser-AFP,
	author = {Jonas Rädle},
	title = {Orbit-Stabiliser Theorem with Application to Rotational Symmetries},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Orbit_Stabiliser.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Orbit_Stabiliser/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Orbit_Stabiliser/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Orbit_Stabiliser/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Orbit_Stabiliser-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Orbit_Stabiliser-2018-08-16.tar.gz">
	+ afp-Orbit_Stabiliser-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Orbit_Stabiliser-2017-10-10.tar.gz">
	afp-Orbit_Stabiliser-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Orbit_Stabiliser-2017-08-23.tar.gz">
	afp-Orbit_Stabiliser-2017-08-23.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Order_Lattice_Props.html b/web/entries/Order_Lattice_Props.html
	--- a/web/entries/Order_Lattice_Props.html
	+++ b/web/entries/Order_Lattice_Props.html
	@@ -1,182 +1,188 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Properties of Orderings and Lattices - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>roperties

	of

	<font class="first">O</font>rderings

	and

	<font class="first">L</font>attices

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Properties of Orderings and Lattices</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-12-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	These components add further fundamental order and lattice-theoretic
	concepts and properties to Isabelle's libraries. They follow by
	and large the introductory sections of the Compendium of Continuous
	Lattices, covering directed and filtered sets, down-closed and
	up-closed sets, ideals and filters, Galois connections, closure and
	co-closure operators. Some emphasis is on duality and morphisms
	between structures, as in the Compendium. To this end, three ad-hoc
	approaches to duality are compared.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Order_Lattice_Props-AFP,
	author = {Georg Struth},
	title = {Properties of Orderings and Lattices},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Order_Lattice_Props.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Quantales.html">Quantales</a>, <a href="Transformer_Semantics.html">Transformer_Semantics</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Order_Lattice_Props/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Order_Lattice_Props/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Order_Lattice_Props/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Order_Lattice_Props-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Order_Lattice_Props-2018-12-19.tar.gz">
	+ afp-Order_Lattice_Props-2018-12-19.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Ordered_Resolution_Prover.html b/web/entries/Ordered_Resolution_Prover.html
	--- a/web/entries/Ordered_Resolution_Prover.html
	+++ b/web/entries/Ordered_Resolution_Prover.html
	@@ -1,198 +1,203 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of Bachmair and Ganzinger's Ordered Resolution Prover - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	<font class="first">B</font>achmair

	and

	<font class="first">G</font>anzinger's

	<font class="first">O</font>rdered

	<font class="first">R</font>esolution

	<font class="first">P</font>rover

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of Bachmair and Ganzinger's Ordered Resolution Prover</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Anders Schlichtkrull (andschl /at/ dtu /dot/ dk),
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl),
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a> and
	Uwe Waldmann (uwe /at/ mpi-inf /dot/ mpg /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-01-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This Isabelle/HOL formalization covers Sections 2 to 4 of Bachmair and
	Ganzinger's "Resolution Theorem Proving" chapter in the
	<em>Handbook of Automated Reasoning</em>. This includes
	soundness and completeness of unordered and ordered variants of ground
	resolution with and without literal selection, the standard redundancy
	criterion, a general framework for refutational theorem proving, and
	soundness and completeness of an abstract first-order prover.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Ordered_Resolution_Prover-AFP,
	author = {Anders Schlichtkrull and Jasmin Christian Blanchette and Dmitriy Traytel and Uwe Waldmann},
	title = {Formalization of Bachmair and Ganzinger's Ordered Resolution Prover},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Ordered_Resolution_Prover.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a>, <a href="Nested_Multisets_Ordinals.html">Nested_Multisets_Ordinals</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Functional_Ordered_Resolution_Prover.html">Functional_Ordered_Resolution_Prover</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ordered_Resolution_Prover/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Ordered_Resolution_Prover/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ordered_Resolution_Prover/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Ordered_Resolution_Prover-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Ordered_Resolution_Prover-2018-08-16.tar.gz">
	+ afp-Ordered_Resolution_Prover-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Ordered_Resolution_Prover-2018-01-22.tar.gz">
	afp-Ordered_Resolution_Prover-2018-01-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Ordinal.html b/web/entries/Ordinal.html
	--- a/web/entries/Ordinal.html
	+++ b/web/entries/Ordinal.html
	@@ -1,254 +1,259 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Countable Ordinals - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>ountable

	<font class="first">O</font>rdinals

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Countable Ordinals</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Brian Huffman
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2005-11-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This development defines a well-ordered type of countable ordinals. It includes notions of continuous and normal functions, recursively defined functions over ordinals, least fixed-points, and derivatives. Much of ordinal arithmetic is formalized, including exponentials and logarithms. The development concludes with formalizations of Cantor Normal Form and Veblen hierarchies over normal functions.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Ordinal-AFP,
	author = {Brian Huffman},
	title = {Countable Ordinals},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2005,
	note = {\url{http://isa-afp.org/entries/Ordinal.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Nested_Multisets_Ordinals.html">Nested_Multisets_Ordinals</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ordinal/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Ordinal/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ordinal/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Ordinal-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Ordinal-2018-08-16.tar.gz">
	+ afp-Ordinal-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Ordinal-2017-10-10.tar.gz">
	afp-Ordinal-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Ordinal-2016-12-17.tar.gz">
	afp-Ordinal-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Ordinal-2016-02-22.tar.gz">
	afp-Ordinal-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Ordinal-2015-05-27.tar.gz">
	afp-Ordinal-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Ordinal-2014-08-28.tar.gz">
	afp-Ordinal-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Ordinal-2013-12-11.tar.gz">
	afp-Ordinal-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Ordinal-2013-11-17.tar.gz">
	afp-Ordinal-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Ordinal-2013-02-16.tar.gz">
	afp-Ordinal-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Ordinal-2012-05-24.tar.gz">
	afp-Ordinal-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Ordinal-2011-10-11.tar.gz">
	afp-Ordinal-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Ordinal-2011-02-11.tar.gz">
	afp-Ordinal-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Ordinal-2010-07-01.tar.gz">
	afp-Ordinal-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Ordinal-2009-12-12.tar.gz">
	afp-Ordinal-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Ordinal-2009-04-29.tar.gz">
	afp-Ordinal-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Ordinal-2008-06-10.tar.gz">
	afp-Ordinal-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Ordinal-2007-11-27.tar.gz">
	afp-Ordinal-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Ordinal-2005-11-16.tar.gz">
	afp-Ordinal-2005-11-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Ordinals_and_Cardinals.html b/web/entries/Ordinals_and_Cardinals.html
	--- a/web/entries/Ordinals_and_Cardinals.html
	+++ b/web/entries/Ordinals_and_Cardinals.html
	@@ -1,248 +1,253 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Ordinals and Cardinals - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">O</font>rdinals

	and

	<font class="first">C</font>ardinals

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Ordinals and Cardinals</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-09-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We develop a basic theory of ordinals and cardinals in Isabelle/HOL, up to the point where some cardinality facts relevant for the ``working mathematician" become available. Unlike in set theory, here we do not have at hand canonical notions of ordinal and cardinal. Therefore, here an ordinal is merely a well-order relation and a cardinal is an ordinal minim w.r.t. order embedding on its field.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2012-09-25]: This entry has been discontinued because it is now part of the Isabelle distribution.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Ordinals_and_Cardinals-AFP,
	author = {Andrei Popescu},
	title = {Ordinals and Cardinals},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/Ordinals_and_Cardinals.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ordinals_and_Cardinals/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Ordinals_and_Cardinals/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ordinals_and_Cardinals/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Ordinals_and_Cardinals-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Ordinals_and_Cardinals-2018-08-16.tar.gz">
	+ afp-Ordinals_and_Cardinals-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Ordinals_and_Cardinals-2017-10-10.tar.gz">
	afp-Ordinals_and_Cardinals-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Ordinals_and_Cardinals-2016-12-17.tar.gz">
	afp-Ordinals_and_Cardinals-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Ordinals_and_Cardinals-2016-02-22.tar.gz">
	afp-Ordinals_and_Cardinals-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Ordinals_and_Cardinals-2015-05-27.tar.gz">
	afp-Ordinals_and_Cardinals-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Ordinals_and_Cardinals-2014-08-28.tar.gz">
	afp-Ordinals_and_Cardinals-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Ordinals_and_Cardinals-2013-12-11.tar.gz">
	afp-Ordinals_and_Cardinals-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Ordinals_and_Cardinals-2013-11-17.tar.gz">
	afp-Ordinals_and_Cardinals-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Ordinals_and_Cardinals-2013-02-16.tar.gz">
	afp-Ordinals_and_Cardinals-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Ordinals_and_Cardinals-2012-05-24.tar.gz">
	afp-Ordinals_and_Cardinals-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Ordinals_and_Cardinals-2011-10-11.tar.gz">
	afp-Ordinals_and_Cardinals-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Ordinals_and_Cardinals-2011-02-11.tar.gz">
	afp-Ordinals_and_Cardinals-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Ordinals_and_Cardinals-2010-07-01.tar.gz">
	afp-Ordinals_and_Cardinals-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Ordinals_and_Cardinals-2009-12-12.tar.gz">
	afp-Ordinals_and_Cardinals-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Ordinals_and_Cardinals-2009-09-09.tar.gz">
	afp-Ordinals_and_Cardinals-2009-09-09.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Ordinals_and_Cardinals-2009-09-07.tar.gz">
	afp-Ordinals_and_Cardinals-2009-09-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Ordinary_Differential_Equations.html b/web/entries/Ordinary_Differential_Equations.html
	--- a/web/entries/Ordinary_Differential_Equations.html
	+++ b/web/entries/Ordinary_Differential_Equations.html
	@@ -1,245 +1,250 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Ordinary Differential Equations - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">O</font>rdinary

	<font class="first">D</font>ifferential

	<font class="first">E</font>quations

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Ordinary Differential Equations</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a> and
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-04-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>Session Ordinary-Differential-Equations formalizes ordinary differential equations (ODEs) and initial value
	problems. This work comprises proofs for local and global existence of unique solutions
	(Picard-Lindelöf theorem). Moreover, it contains a formalization of the (continuous or even
	differentiable) dependency of the flow on initial conditions as the <i>flow</i> of ODEs.</p>
	<p>
	Not in the generated document are the following sessions:
	<ul>
	<li> HOL-ODE-Numerics:
	Rigorous numerical algorithms for computing enclosures of solutions based on Runge-Kutta methods
	and affine arithmetic. Reachability analysis with splitting and reduction at hyperplanes.</li>
	<li> HOL-ODE-Examples:
	Applications of the numerical algorithms to concrete systems of ODEs.</li>
	<li> Lorenz_C0, Lorenz_C1:
	Verified algorithms for checking C1-information according to Tucker's proof,
	computation of C0-information.</li>
	</ul>
	</p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2014-02-13]: added an implementation of the Euler method based on affine arithmetic<br>
	[2016-04-14]: added flow and variational equation<br>
	[2016-08-03]: numerical algorithms for reachability analysis (using second-order Runge-Kutta methods, splitting, and reduction) implemented using Lammich's framework for automatic refinement<br>
	[2017-09-20]: added Poincare map and propagation of variational equation in
	reachability analysis, verified algorithms for C1-information and computations
	for C0-information of the Lorenz attractor.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Ordinary_Differential_Equations-AFP,
	author = {Fabian Immler and Johannes Hölzl},
	title = {Ordinary Differential Equations},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Ordinary_Differential_Equations.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Affine_Arithmetic.html">Affine_Arithmetic</a>, <a href="Collections.html">Collections</a>, <a href="Deriving.html">Deriving</a>, <a href="List-Index.html">List-Index</a>, <a href="Show.html">Show</a>, <a href="Triangle.html">Triangle</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Differential_Dynamic_Logic.html">Differential_Dynamic_Logic</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ordinary_Differential_Equations/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Ordinary_Differential_Equations/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ordinary_Differential_Equations/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Ordinary_Differential_Equations-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Ordinary_Differential_Equations-2018-08-16.tar.gz">
	+ afp-Ordinary_Differential_Equations-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Ordinary_Differential_Equations-2017-10-10.tar.gz">
	afp-Ordinary_Differential_Equations-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Ordinary_Differential_Equations-2016-12-17.tar.gz">
	afp-Ordinary_Differential_Equations-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Ordinary_Differential_Equations-2016-02-22.tar.gz">
	afp-Ordinary_Differential_Equations-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Ordinary_Differential_Equations-2015-05-27.tar.gz">
	afp-Ordinary_Differential_Equations-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Ordinary_Differential_Equations-2014-08-28.tar.gz">
	afp-Ordinary_Differential_Equations-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Ordinary_Differential_Equations-2013-12-11.tar.gz">
	afp-Ordinary_Differential_Equations-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Ordinary_Differential_Equations-2013-11-17.tar.gz">
	afp-Ordinary_Differential_Equations-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Ordinary_Differential_Equations-2013-02-16.tar.gz">
	afp-Ordinary_Differential_Equations-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Ordinary_Differential_Equations-2012-05-24.tar.gz">
	afp-Ordinary_Differential_Equations-2012-05-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/PCF.html b/web/entries/PCF.html
	--- a/web/entries/PCF.html
	+++ b/web/entries/PCF.html
	@@ -1,225 +1,230 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Logical Relations for PCF - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">L</font>ogical

	<font class="first">R</font>elations

	for

	<font class="first">P</font>CF

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Logical Relations for PCF</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-07-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We apply Andy Pitts's methods of defining relations over domains to
	several classical results in the literature. We show that the Y
	combinator coincides with the domain-theoretic fixpoint operator,
	that parallel-or and the Plotkin existential are not definable in
	PCF, that the continuation semantics for PCF coincides with the
	direct semantics, and that our domain-theoretic semantics for PCF is
	adequate for reasoning about contextual equivalence in an
	operational semantics. Our version of PCF is untyped and has both
	strict and non-strict function abstractions. The development is
	carried out in HOLCF.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{PCF-AFP,
	author = {Peter Gammie},
	title = {Logical Relations for PCF},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/PCF.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PCF/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/PCF/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PCF/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-PCF-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-PCF-2018-08-16.tar.gz">
	+ afp-PCF-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-PCF-2017-10-10.tar.gz">
	afp-PCF-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-PCF-2016-12-17.tar.gz">
	afp-PCF-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-PCF-2016-02-22.tar.gz">
	afp-PCF-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-PCF-2015-05-27.tar.gz">
	afp-PCF-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-PCF-2014-08-28.tar.gz">
	afp-PCF-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-PCF-2013-12-11.tar.gz">
	afp-PCF-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-PCF-2013-11-17.tar.gz">
	afp-PCF-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-PCF-2013-02-16.tar.gz">
	afp-PCF-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-PCF-2012-07-03.tar.gz">
	afp-PCF-2012-07-03.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/PLM.html b/web/entries/PLM.html
	--- a/web/entries/PLM.html
	+++ b/web/entries/PLM.html
	@@ -1,230 +1,235 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Representation and Partial Automation of the Principia Logico-Metaphysica in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>epresentation

	and

	<font class="first">P</font>artial

	<font class="first">A</font>utomation

	of

	the

	<font class="first">P</font>rincipia

	<font class="first">L</font>ogico-Metaphysica

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Representation and Partial Automation of the Principia Logico-Metaphysica in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Daniel Kirchner (daniel /at/ ekpyron /dot/ org)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-09-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p> We present an embedding of the second-order fragment of the
	Theory of Abstract Objects as described in Edward Zalta's
	upcoming work <a
	href="https://mally.stanford.edu/principia.pdf">Principia
	Logico-Metaphysica (PLM)</a> in the automated reasoning
	framework Isabelle/HOL. The Theory of Abstract Objects is a
	metaphysical theory that reifies property patterns, as they for
	example occur in the abstract reasoning of mathematics, as
	<b>abstract objects</b> and provides an axiomatic
	framework that allows to reason about these objects. It thereby serves
	as a fundamental metaphysical theory that can be used to axiomatize
	and describe a wide range of philosophical objects, such as Platonic
	forms or Leibniz' concepts, and has the ambition to function as a
	foundational theory of mathematics. The target theory of our embedding
	as described in chapters 7-9 of PLM employs a modal relational type
	theory as logical foundation for which a representation in functional
	type theory is <a
	href="https://mally.stanford.edu/Papers/rtt.pdf">known to
	be challenging</a>. </p> <p> Nevertheless we arrive
	at a functioning representation of the theory in the functional logic
	of Isabelle/HOL based on a semantical representation of an Aczel-model
	of the theory. Based on this representation we construct an
	implementation of the deductive system of PLM which allows to
	automatically and interactively find and verify theorems of PLM.
	</p> <p> Our work thereby supports the concept of shallow
	semantical embeddings of logical systems in HOL as a universal tool
	for logical reasoning <a
	href="http://www.mi.fu-berlin.de/inf/groups/ag-ki/publications/Universal-Reasoning/1703_09620_pd.pdf">as
	promoted by Christoph Benzmüller</a>. </p>
	<p> The most notable result of the presented work is the
	discovery of a previously unknown paradox in the formulation of the
	Theory of Abstract Objects. The embedding of the theory in
	Isabelle/HOL played a vital part in this discovery. Furthermore it was
	possible to immediately offer several options to modify the theory to
	guarantee its consistency. Thereby our work could provide a
	significant contribution to the development of a proper grounding for
	object theory. </p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{PLM-AFP,
	author = {Daniel Kirchner},
	title = {Representation and Partial Automation of the Principia Logico-Metaphysica in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/PLM.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PLM/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/PLM/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PLM/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-PLM-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-PLM-2018-08-16.tar.gz">
	+ afp-PLM-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-PLM-2017-10-10.tar.gz">
	afp-PLM-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-PLM-2017-09-19.tar.gz">
	afp-PLM-2017-09-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/POPLmark-deBruijn.html b/web/entries/POPLmark-deBruijn.html
	--- a/web/entries/POPLmark-deBruijn.html
	+++ b/web/entries/POPLmark-deBruijn.html
	@@ -1,260 +1,265 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>POPLmark Challenge Via de Bruijn Indices - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>OPLmark

	<font class="first">C</font>hallenge

	<font class="first">V</font>ia

	de

	<font class="first">B</font>ruijn

	<font class="first">I</font>ndices

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">POPLmark Challenge Via de Bruijn Indices</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2007-08-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We present a solution to the POPLmark challenge designed by Aydemir et al., which has as a goal the formalization of the meta-theory of System F<sub><:</sub>. The formalization is carried out in the theorem prover Isabelle/HOL using an encoding based on de Bruijn indices. We start with a relatively simple formalization covering only the basic features of System F<sub><:</sub>, and explain how it can be extended to also cover records and more advanced binding constructs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{POPLmark-deBruijn-AFP,
	author = {Stefan Berghofer},
	title = {POPLmark Challenge Via de Bruijn Indices},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2007,
	note = {\url{http://isa-afp.org/entries/POPLmark-deBruijn.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/POPLmark-deBruijn/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/POPLmark-deBruijn/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/POPLmark-deBruijn/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-POPLmark-deBruijn-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-POPLmark-deBruijn-2018-08-16.tar.gz">
	+ afp-POPLmark-deBruijn-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-POPLmark-deBruijn-2017-10-10.tar.gz">
	afp-POPLmark-deBruijn-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-POPLmark-deBruijn-2016-12-17.tar.gz">
	afp-POPLmark-deBruijn-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-POPLmark-deBruijn-2016-02-22.tar.gz">
	afp-POPLmark-deBruijn-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-POPLmark-deBruijn-2015-05-27.tar.gz">
	afp-POPLmark-deBruijn-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-POPLmark-deBruijn-2014-08-28.tar.gz">
	afp-POPLmark-deBruijn-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-POPLmark-deBruijn-2013-12-11.tar.gz">
	afp-POPLmark-deBruijn-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-POPLmark-deBruijn-2013-11-17.tar.gz">
	afp-POPLmark-deBruijn-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-POPLmark-deBruijn-2013-03-02.tar.gz">
	afp-POPLmark-deBruijn-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-POPLmark-deBruijn-2013-02-16.tar.gz">
	afp-POPLmark-deBruijn-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-POPLmark-deBruijn-2012-05-24.tar.gz">
	afp-POPLmark-deBruijn-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-POPLmark-deBruijn-2011-10-11.tar.gz">
	afp-POPLmark-deBruijn-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-POPLmark-deBruijn-2011-02-11.tar.gz">
	afp-POPLmark-deBruijn-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-POPLmark-deBruijn-2010-07-01.tar.gz">
	afp-POPLmark-deBruijn-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-POPLmark-deBruijn-2009-12-12.tar.gz">
	afp-POPLmark-deBruijn-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-POPLmark-deBruijn-2009-04-29.tar.gz">
	afp-POPLmark-deBruijn-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-POPLmark-deBruijn-2008-06-10.tar.gz">
	afp-POPLmark-deBruijn-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-POPLmark-deBruijn-2007-11-27.tar.gz">
	afp-POPLmark-deBruijn-2007-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/PSemigroupsConvolution.html b/web/entries/PSemigroupsConvolution.html
	--- a/web/entries/PSemigroupsConvolution.html
	+++ b/web/entries/PSemigroupsConvolution.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Partial Semigroups and Convolution Algebras - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>artial

	<font class="first">S</font>emigroups

	and

	<font class="first">C</font>onvolution

	<font class="first">A</font>lgebras

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Partial Semigroups and Convolution Algebras</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Brijesh Dongol (brijesh /dot/ dongol /at/ brunel /dot/ ac /dot/ uk),
	Victor B. F. Gomes (vb358 /at/ cl /dot/ cam /dot/ ac /dot/ uk),
	Ian J. Hayes (ian /dot/ hayes /at/ itee /dot/ uq /dot/ edu /dot/ au) and
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-06-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Partial Semigroups are relevant to the foundations of quantum
	mechanics and combinatorics as well as to interval and separation
	logics. Convolution algebras can be understood either as algebras of
	generalised binary modalities over ternary Kripke frames, in
	particular over partial semigroups, or as algebras of quantale-valued
	functions which are equipped with a convolution-style operation of
	multiplication that is parametrised by a ternary relation. Convolution
	algebras provide algebraic semantics for various substructural logics,
	including categorial, relevance and linear logics, for separation
	logic and for interval logics; they cover quantitative and qualitative
	applications. These mathematical components for partial semigroups and
	convolution algebras provide uniform foundations from which models of
	computation based on relations, program traces or pomsets, and
	verification components for separation or interval temporal logics can
	be built with little effort.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{PSemigroupsConvolution-AFP,
	author = {Brijesh Dongol and Victor B. F. Gomes and Ian J. Hayes and Georg Struth},
	title = {Partial Semigroups and Convolution Algebras},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/PSemigroupsConvolution.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PSemigroupsConvolution/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/PSemigroupsConvolution/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PSemigroupsConvolution/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-PSemigroupsConvolution-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-PSemigroupsConvolution-2018-08-16.tar.gz">
	+ afp-PSemigroupsConvolution-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-PSemigroupsConvolution-2017-10-10.tar.gz">
	afp-PSemigroupsConvolution-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-PSemigroupsConvolution-2017-06-13.tar.gz">
	afp-PSemigroupsConvolution-2017-06-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Pairing_Heap.html b/web/entries/Pairing_Heap.html
	--- a/web/entries/Pairing_Heap.html
	+++ b/web/entries/Pairing_Heap.html
	@@ -1,191 +1,196 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Pairing Heap - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>airing

	<font class="first">H</font>eap

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Pairing Heap</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Hauke Brinkop (hauke /dot/ brinkop /at/ googlemail /dot/ com) and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-07-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This library defines three different versions of pairing heaps: a
	functional version of the original design based on binary
	trees [Fredman et al. 1986], the version by Okasaki [1998] and
	a modified version of the latter that is free of structural invariants.
	<p>
	The amortized complexity of pairing heaps is analyzed in the AFP article
	<a href="http://isa-afp.org/entries/Amortized_Complexity.html">Amortized Complexity</a>.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Origin:</td>
	<td class="abstract">This library was extracted from Amortized Complexity and extended.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Pairing_Heap-AFP,
	author = {Hauke Brinkop and Tobias Nipkow},
	title = {Pairing Heap},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Pairing_Heap.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Amortized_Complexity.html">Amortized_Complexity</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pairing_Heap/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Pairing_Heap/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pairing_Heap/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Pairing_Heap-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Pairing_Heap-2018-08-16.tar.gz">
	+ afp-Pairing_Heap-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Pairing_Heap-2017-10-10.tar.gz">
	afp-Pairing_Heap-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Pairing_Heap-2016-12-17.tar.gz">
	afp-Pairing_Heap-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Paraconsistency.html b/web/entries/Paraconsistency.html
	--- a/web/entries/Paraconsistency.html
	+++ b/web/entries/Paraconsistency.html
	@@ -1,196 +1,201 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Paraconsistency - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>araconsistency

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Paraconsistency</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Anders Schlichtkrull (andschl /at/ dtu /dot/ dk) and
	<a href="https://people.compute.dtu.dk/jovi/">Jørgen Villadsen</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-12-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Paraconsistency is about handling inconsistency in a coherent way. In
	classical and intuitionistic logic everything follows from an
	inconsistent theory. A paraconsistent logic avoids the explosion.
	Quite a few applications in computer science and engineering are
	discussed in the Intelligent Systems Reference Library Volume 110:
	Towards Paraconsistent Engineering (Springer 2016). We formalize a
	paraconsistent many-valued logic that we motivated and described in a
	special issue on logical approaches to paraconsistency (Journal of
	Applied Non-Classical Logics 2005). We limit ourselves to the
	propositional fragment of the higher-order logic. The logic is based
	on so-called key equalities and has a countably infinite number of
	truth values. We prove theorems in the logic using the definition of
	validity. We verify truth tables and also counterexamples for
	non-theorems. We prove meta-theorems about the logic and finally we
	investigate a case study.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Paraconsistency-AFP,
	author = {Anders Schlichtkrull and Jørgen Villadsen},
	title = {Paraconsistency},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Paraconsistency.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Paraconsistency/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Paraconsistency/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Paraconsistency/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Paraconsistency-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Paraconsistency-2018-08-16.tar.gz">
	+ afp-Paraconsistency-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Paraconsistency-2017-10-10.tar.gz">
	afp-Paraconsistency-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Paraconsistency-2016-12-17.tar.gz">
	afp-Paraconsistency-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Paraconsistency-2016-12-08.tar.gz">
	afp-Paraconsistency-2016-12-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Parity_Game.html b/web/entries/Parity_Game.html
	--- a/web/entries/Parity_Game.html
	+++ b/web/entries/Parity_Game.html
	@@ -1,198 +1,203 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Positional Determinacy of Parity Games - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>ositional

	<font class="first">D</font>eterminacy

	of

	<font class="first">P</font>arity

	<font class="first">G</font>ames

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Positional Determinacy of Parity Games</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://logic.las.tu-berlin.de/Members/Dittmann/">Christoph Dittmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-11-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formalization of parity games (a two-player game on
	directed graphs) and a proof of their positional determinacy in
	Isabelle/HOL. This proof works for both finite and infinite games.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Parity_Game-AFP,
	author = {Christoph Dittmann},
	title = {Positional Determinacy of Parity Games},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Parity_Game.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a>, <a href="Graph_Theory.html">Graph_Theory</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Parity_Game/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Parity_Game/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Parity_Game/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Parity_Game-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Parity_Game-2018-08-16.tar.gz">
	+ afp-Parity_Game-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Parity_Game-2017-10-10.tar.gz">
	afp-Parity_Game-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Parity_Game-2016-12-17.tar.gz">
	afp-Parity_Game-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Parity_Game-2016-02-22.tar.gz">
	afp-Parity_Game-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Parity_Game-2015-11-02.tar.gz">
	afp-Parity_Game-2015-11-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Partial_Function_MR.html b/web/entries/Partial_Function_MR.html
	--- a/web/entries/Partial_Function_MR.html
	+++ b/web/entries/Partial_Function_MR.html
	@@ -1,203 +1,208 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Mutually Recursive Partial Functions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">M</font>utually

	<font class="first">R</font>ecursive

	<font class="first">P</font>artial

	<font class="first">F</font>unctions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Mutually Recursive Partial Functions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-02-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We provide a wrapper around the partial-function command that supports mutual recursion.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Partial_Function_MR-AFP,
	author = {René Thiemann},
	title = {Mutually Recursive Partial Functions},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Partial_Function_MR.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Certification_Monads.html">Certification_Monads</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Partial_Function_MR/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Partial_Function_MR/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Partial_Function_MR/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Partial_Function_MR-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Partial_Function_MR-2018-08-16.tar.gz">
	+ afp-Partial_Function_MR-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Partial_Function_MR-2017-10-10.tar.gz">
	afp-Partial_Function_MR-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Partial_Function_MR-2016-12-17.tar.gz">
	afp-Partial_Function_MR-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Partial_Function_MR-2016-02-22.tar.gz">
	afp-Partial_Function_MR-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Partial_Function_MR-2015-05-27.tar.gz">
	afp-Partial_Function_MR-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Partial_Function_MR-2014-08-28.tar.gz">
	afp-Partial_Function_MR-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Partial_Function_MR-2014-02-19.tar.gz">
	afp-Partial_Function_MR-2014-02-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Partial_Order_Reduction.html b/web/entries/Partial_Order_Reduction.html
	--- a/web/entries/Partial_Order_Reduction.html
	+++ b/web/entries/Partial_Order_Reduction.html
	@@ -1,178 +1,184 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Partial Order Reduction - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>artial

	<font class="first">O</font>rder

	<font class="first">R</font>eduction

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Partial Order Reduction</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~brunnerj/">Julian Brunner</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-06-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides a formalization of the abstract theory of ample
	set partial order reduction. The formalization includes transition
	systems with actions, trace theory, as well as basics on finite,
	infinite, and lazy sequences. We also provide a basic framework for
	static analysis on concurrent systems with respect to the ample set
	condition.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Partial_Order_Reduction-AFP,
	author = {Julian Brunner},
	title = {Partial Order Reduction},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Partial_Order_Reduction.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a>, <a href="Stuttering_Equivalence.html">Stuttering_Equivalence</a>, <a href="Transition_Systems_and_Automata.html">Transition_Systems_and_Automata</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CAVA_LTL_Modelchecker.html">CAVA_LTL_Modelchecker</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Partial_Order_Reduction/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Partial_Order_Reduction/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Partial_Order_Reduction/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Partial_Order_Reduction-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Partial_Order_Reduction-2018-08-16.tar.gz">
	+ afp-Partial_Order_Reduction-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Password_Authentication_Protocol.html b/web/entries/Password_Authentication_Protocol.html
	--- a/web/entries/Password_Authentication_Protocol.html
	+++ b/web/entries/Password_Authentication_Protocol.html
	@@ -1,210 +1,215 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Verification of a Diffie-Hellman Password-based Authentication Protocol by Extending the Inductive Method - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erification

	of

	a

	<font class="first">D</font>iffie-Hellman

	<font class="first">P</font>assword-based

	<font class="first">A</font>uthentication

	<font class="first">P</font>rotocol

	by

	<font class="first">E</font>xtending

	the

	<font class="first">I</font>nductive

	<font class="first">M</font>ethod

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Verification of a Diffie-Hellman Password-based Authentication Protocol by Extending the Inductive Method</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-01-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This paper constructs a formal model of a Diffie-Hellman
	password-based authentication protocol between a user and a smart
	card, and proves its security. The protocol provides for the dispatch
	of the user's password to the smart card on a secure messaging
	channel established by means of Password Authenticated Connection
	Establishment (PACE), where the mapping method being used is Chip
	Authentication Mapping. By applying and suitably extending
	Paulson's Inductive Method, this paper proves that the protocol
	establishes trustworthy secure messaging channels, preserves the
	secrecy of users' passwords, and provides an effective mutual
	authentication service. What is more, these security properties turn
	out to hold independently of the secrecy of the PACE authentication
	key.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Password_Authentication_Protocol-AFP,
	author = {Pasquale Noce},
	title = {Verification of a Diffie-Hellman Password-based Authentication Protocol by Extending the Inductive Method},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Password_Authentication_Protocol.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Password_Authentication_Protocol/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Password_Authentication_Protocol/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Password_Authentication_Protocol/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Password_Authentication_Protocol-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Password_Authentication_Protocol-2018-08-16.tar.gz">
	+ afp-Password_Authentication_Protocol-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Password_Authentication_Protocol-2017-10-10.tar.gz">
	afp-Password_Authentication_Protocol-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Password_Authentication_Protocol-2017-01-06.tar.gz">
	afp-Password_Authentication_Protocol-2017-01-06.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Pell.html b/web/entries/Pell.html
	--- a/web/entries/Pell.html
	+++ b/web/entries/Pell.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Pell's Equation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>ell's

	<font class="first">E</font>quation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Pell's Equation</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-06-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p> This article gives the basic theory of Pell's equation
	<em>x</em><sup>2</sup> = 1 +
	<em>D</em> <em>y</em><sup>2</sup>,
	where
	<em>D</em> ∈ ℕ is
	a parameter and <em>x</em>, <em>y</em> are
	integer variables. </p> <p> The main result that is proven
	is the following: If <em>D</em> is not a perfect square,
	then there exists a <em>fundamental solution</em>
	(<em>x</em><sub>0</sub>,
	<em>y</em><sub>0</sub>) that is not the
	trivial solution (1, 0) and which generates all other solutions
	(<em>x</em>, <em>y</em>) in the sense that
	there exists some
	<em>n</em> ∈ ℕ
	such that \|<em>x</em>\| +
	\|<em>y</em>\| √<span
	style="text-decoration:
	overline"><em>D</em></span> =
	(<em>x</em><sub>0</sub> +
	<em>y</em><sub>0</sub> √<span
	style="text-decoration:
	overline"><em>D</em></span>)<sup><em>n</em></sup>.
	This also implies that the set of solutions is infinite, and it gives
	us an explicit and executable characterisation of all the solutions.
	</p> <p> Based on this, simple executable algorithms for
	computing the fundamental solution and the infinite sequence of all
	non-negative solutions are also provided. </p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Pell-AFP,
	author = {Manuel Eberl},
	title = {Pell's Equation},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Pell.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pell/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Pell/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pell/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Pell-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Pell-2018-08-16.tar.gz">
	+ afp-Pell-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Pell-2018-06-25.tar.gz">
	afp-Pell-2018-06-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Perfect-Number-Thm.html b/web/entries/Perfect-Number-Thm.html
	--- a/web/entries/Perfect-Number-Thm.html
	+++ b/web/entries/Perfect-Number-Thm.html
	@@ -1,239 +1,244 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Perfect Number Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>erfect

	<font class="first">N</font>umber

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Perfect Number Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Mark Ijbema (ijbema /at/ fmf /dot/ nl)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-11-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">These theories present the mechanised proof of the Perfect Number Theorem.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Perfect-Number-Thm-AFP,
	author = {Mark Ijbema},
	title = {Perfect Number Theorem},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/Perfect-Number-Thm.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Perfect-Number-Thm/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Perfect-Number-Thm/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Perfect-Number-Thm/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Perfect-Number-Thm-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Perfect-Number-Thm-2018-08-16.tar.gz">
	+ afp-Perfect-Number-Thm-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Perfect-Number-Thm-2017-10-10.tar.gz">
	afp-Perfect-Number-Thm-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Perfect-Number-Thm-2016-12-17.tar.gz">
	afp-Perfect-Number-Thm-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Perfect-Number-Thm-2016-02-22.tar.gz">
	afp-Perfect-Number-Thm-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Perfect-Number-Thm-2015-05-27.tar.gz">
	afp-Perfect-Number-Thm-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Perfect-Number-Thm-2014-08-28.tar.gz">
	afp-Perfect-Number-Thm-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Perfect-Number-Thm-2013-12-11.tar.gz">
	afp-Perfect-Number-Thm-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Perfect-Number-Thm-2013-11-17.tar.gz">
	afp-Perfect-Number-Thm-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Perfect-Number-Thm-2013-02-16.tar.gz">
	afp-Perfect-Number-Thm-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Perfect-Number-Thm-2012-05-24.tar.gz">
	afp-Perfect-Number-Thm-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Perfect-Number-Thm-2011-10-11.tar.gz">
	afp-Perfect-Number-Thm-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Perfect-Number-Thm-2011-02-11.tar.gz">
	afp-Perfect-Number-Thm-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Perfect-Number-Thm-2010-07-01.tar.gz">
	afp-Perfect-Number-Thm-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Perfect-Number-Thm-2009-12-12.tar.gz">
	afp-Perfect-Number-Thm-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Perfect-Number-Thm-2009-11-24.tar.gz">
	afp-Perfect-Number-Thm-2009-11-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Perron_Frobenius.html b/web/entries/Perron_Frobenius.html
	--- a/web/entries/Perron_Frobenius.html
	+++ b/web/entries/Perron_Frobenius.html
	@@ -1,229 +1,234 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Perron-Frobenius Theorem for Spectral Radius Analysis - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>erron-Frobenius

	<font class="first">T</font>heorem

	for

	<font class="first">S</font>pectral

	<font class="first">R</font>adius

	<font class="first">A</font>nalysis

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Perron-Frobenius Theorem for Spectral Radius Analysis</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
	<a href="http://www21.in.tum.de/~kuncar/">Ondřej Kunčar</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a> and
	Akihisa Yamada (ayamada /at/ trs /dot/ cm /dot/ is /dot/ nagoya-u /dot/ ac /dot/ jp)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>The spectral radius of a matrix A is the maximum norm of all
	eigenvalues of A. In previous work we already formalized that for a
	complex matrix A, the values in A<sup>n</sup> grow polynomially in n
	if and only if the spectral radius is at most one. One problem with
	the above characterization is the determination of all
	<em>complex</em> eigenvalues. In case A contains only non-negative
	real values, a simplification is possible with the help of the
	Perron–Frobenius theorem, which tells us that it suffices to consider only
	the <em>real</em> eigenvalues of A, i.e., applying Sturm's method can
	decide the polynomial growth of A<sup>n</sup>. </p><p> We formalize
	the Perron–Frobenius theorem based on a proof via Brouwer's fixpoint
	theorem, which is available in the HOL multivariate analysis (HMA)
	library. Since the results on the spectral radius is based on matrices
	in the Jordan normal form (JNF) library, we further develop a
	connection which allows us to easily transfer theorems between HMA and
	JNF. With this connection we derive the combined result: if A is a
	non-negative real matrix, and no real eigenvalue of A is strictly
	larger than one, then A<sup>n</sup> is polynomially bounded in n. </p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2017-10-18]:
	added Perron-Frobenius theorem for irreducible matrices with generalization
	(revision bda1f1ce8a1c)<br/>
	[2018-05-17]:
	prove conjecture of CPP'18 paper: Jordan blocks of spectral radius have maximum size
	(revision ffdb3794e5d5)</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Perron_Frobenius-AFP,
	author = {Jose Divasón and Ondřej Kunčar and René Thiemann and Akihisa Yamada},
	title = {Perron-Frobenius Theorem for Spectral Radius Analysis},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Perron_Frobenius.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a>, <a href="Rank_Nullity_Theorem.html">Rank_Nullity_Theorem</a>, <a href="Sturm_Sequences.html">Sturm_Sequences</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="LLL_Factorization.html">LLL_Factorization</a>, <a href="Stochastic_Matrices.html">Stochastic_Matrices</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Perron_Frobenius/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Perron_Frobenius/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Perron_Frobenius/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Perron_Frobenius-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Perron_Frobenius-2018-08-16.tar.gz">
	+ afp-Perron_Frobenius-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Perron_Frobenius-2017-10-18.tar.gz">
	afp-Perron_Frobenius-2017-10-18.tar.gz
	</a>
	</li>
	<li>Isabelle 2017:
	<a href="../release/afp-Perron_Frobenius-2017-10-10.tar.gz">
	afp-Perron_Frobenius-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Perron_Frobenius-2016-12-17.tar.gz">
	afp-Perron_Frobenius-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Perron_Frobenius-2016-05-20.tar.gz">
	afp-Perron_Frobenius-2016-05-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Pi_Calculus.html b/web/entries/Pi_Calculus.html
	--- a/web/entries/Pi_Calculus.html
	+++ b/web/entries/Pi_Calculus.html
	@@ -1,222 +1,227 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The pi-calculus in nominal logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	pi-calculus

	in

	nominal

	logic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The pi-calculus in nominal logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.itu.dk/people/jebe">Jesper Bengtson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-05-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalise the pi-calculus using the nominal datatype package, based on ideas from the nominal logic by Pitts et al., and demonstrate an implementation in Isabelle/HOL. The purpose is to derive powerful induction rules for the semantics in order to conduct machine checkable proofs, closely following the intuitive arguments found in manual proofs. In this way we have covered many of the standard theorems of bisimulation equivalence and congruence, both late and early, and both strong and weak in a uniform manner. We thus provide one of the most extensive formalisations of a the pi-calculus ever done inside a theorem prover.
	<p>
	A significant gain in our formulation is that agents are identified up to alpha-equivalence, thereby greatly reducing the arguments about bound names. This is a normal strategy for manual proofs about the pi-calculus, but that kind of hand waving has previously been difficult to incorporate smoothly in an interactive theorem prover. We show how the nominal logic formalism and its support in Isabelle accomplishes this and thus significantly reduces the tedium of conducting completely formal proofs. This improves on previous work using weak higher order abstract syntax since we do not need extra assumptions to filter out exotic terms and can keep all arguments within a familiar first-order logic.
	<p>
	This entry is described in detail in <a href="http://www.itu.dk/people/jebe/files/thesis.pdf">Bengtson's thesis</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Pi_Calculus-AFP,
	author = {Jesper Bengtson},
	title = {The pi-calculus in nominal logic},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Pi_Calculus.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pi_Calculus/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Pi_Calculus/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pi_Calculus/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Pi_Calculus-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Pi_Calculus-2018-08-16.tar.gz">
	+ afp-Pi_Calculus-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Pi_Calculus-2017-10-10.tar.gz">
	afp-Pi_Calculus-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Pi_Calculus-2016-12-17.tar.gz">
	afp-Pi_Calculus-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Pi_Calculus-2016-02-22.tar.gz">
	afp-Pi_Calculus-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Pi_Calculus-2015-05-27.tar.gz">
	afp-Pi_Calculus-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Pi_Calculus-2014-08-28.tar.gz">
	afp-Pi_Calculus-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Pi_Calculus-2013-12-11.tar.gz">
	afp-Pi_Calculus-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Pi_Calculus-2013-11-17.tar.gz">
	afp-Pi_Calculus-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Pi_Calculus-2013-02-16.tar.gz">
	afp-Pi_Calculus-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Pi_Calculus-2012-06-14.tar.gz">
	afp-Pi_Calculus-2012-06-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Pi_Transcendental.html b/web/entries/Pi_Transcendental.html
	--- a/web/entries/Pi_Transcendental.html
	+++ b/web/entries/Pi_Transcendental.html
	@@ -1,178 +1,184 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Transcendence of π - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">T</font>ranscendence

	of

	π

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Transcendence of π</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-09-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This entry shows the transcendence of π based on the
	classic proof using the fundamental theorem of symmetric polynomials
	first given by von Lindemann in 1882, but the formalisation mostly
	follows the version by Niven. The proof reuses much of the machinery
	developed in the AFP entry on the transcendence of
	<em>e</em>.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Pi_Transcendental-AFP,
	author = {Manuel Eberl},
	title = {The Transcendence of π},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Pi_Transcendental.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="E_Transcendental.html">E_Transcendental</a>, <a href="Symmetric_Polynomials.html">Symmetric_Polynomials</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pi_Transcendental/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Pi_Transcendental/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pi_Transcendental/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Pi_Transcendental-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Pi_Transcendental-2018-10-02.tar.gz">
	+ afp-Pi_Transcendental-2018-10-02.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Planarity_Certificates.html b/web/entries/Planarity_Certificates.html
	--- a/web/entries/Planarity_Certificates.html
	+++ b/web/entries/Planarity_Certificates.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Planarity Certificates - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>lanarity

	<font class="first">C</font>ertificates

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Planarity Certificates</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-11-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Planarity_Certificates-AFP,
	author = {Lars Noschinski},
	title = {Planarity Certificates},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Planarity_Certificates.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Case_Labeling.html">Case_Labeling</a>, <a href="Graph_Theory.html">Graph_Theory</a>, <a href="List-Index.html">List-Index</a>, <a href="Simpl.html">Simpl</a>, <a href="Transitive-Closure.html">Transitive-Closure</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Planarity_Certificates/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Planarity_Certificates/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Planarity_Certificates/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Planarity_Certificates-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Planarity_Certificates-2018-08-16.tar.gz">
	+ afp-Planarity_Certificates-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Planarity_Certificates-2017-10-10.tar.gz">
	afp-Planarity_Certificates-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Planarity_Certificates-2016-12-17.tar.gz">
	afp-Planarity_Certificates-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Planarity_Certificates-2016-02-22.tar.gz">
	afp-Planarity_Certificates-2016-02-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Polynomial_Factorization.html b/web/entries/Polynomial_Factorization.html
	--- a/web/entries/Polynomial_Factorization.html
	+++ b/web/entries/Polynomial_Factorization.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Polynomial Factorization - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>olynomial

	<font class="first">F</font>actorization

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Polynomial Factorization</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a> and
	Akihisa Yamada (ayamada /at/ trs /dot/ cm /dot/ is /dot/ nagoya-u /dot/ ac /dot/ jp)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-01-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	<p>
	As side products, we developed division algorithms for polynomials over integral domains,
	as well as primality-testing and prime-factorization algorithms for integers.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Polynomial_Factorization.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a>, <a href="Containers.html">Containers</a>, <a href="Gauss_Jordan.html">Gauss_Jordan</a>, <a href="Matrix.html">Matrix</a>, <a href="Partial_Function_MR.html">Partial_Function_MR</a>, <a href="Polynomial_Interpolation.html">Polynomial_Interpolation</a>, <a href="Show.html">Show</a>, <a href="Sqrt_Babylonian.html">Sqrt_Babylonian</a>, <a href="VectorSpace.html">VectorSpace</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a>, <a href="Dirichlet_Series.html">Dirichlet_Series</a>, <a href="Functional_Ordered_Resolution_Prover.html">Functional_Ordered_Resolution_Prover</a>, <a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a>, <a href="Linear_Recurrences.html">Linear_Recurrences</a>, <a href="Perron_Frobenius.html">Perron_Frobenius</a>, <a href="Subresultants.html">Subresultants</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Polynomial_Factorization/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Polynomial_Factorization/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Polynomial_Factorization/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Polynomial_Factorization-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Polynomial_Factorization-2018-08-16.tar.gz">
	+ afp-Polynomial_Factorization-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Polynomial_Factorization-2017-10-10.tar.gz">
	afp-Polynomial_Factorization-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Polynomial_Factorization-2016-12-17.tar.gz">
	afp-Polynomial_Factorization-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Polynomial_Factorization-2016-02-22.tar.gz">
	afp-Polynomial_Factorization-2016-02-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Polynomial_Interpolation.html b/web/entries/Polynomial_Interpolation.html
	--- a/web/entries/Polynomial_Interpolation.html
	+++ b/web/entries/Polynomial_Interpolation.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Polynomial Interpolation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>olynomial

	<font class="first">I</font>nterpolation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Polynomial Interpolation</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a> and
	Akihisa Yamada (ayamada /at/ trs /dot/ cm /dot/ is /dot/ nagoya-u /dot/ ac /dot/ jp)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-01-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalized three algorithms for polynomial interpolation over arbitrary
	fields: Lagrange's explicit expression, the recursive algorithm of Neville
	and Aitken, and the Newton interpolation in combination with an efficient
	implementation of divided differences. Variants of these algorithms for
	integer polynomials are also available, where sometimes the interpolation
	can fail; e.g., there is no linear integer polynomial <i>p</i> such that
	<i>p(0) = 0</i> and <i>p(2) = 1</i>. Moreover, for the Newton interpolation
	for integer polynomials, we proved that all intermediate results that are
	computed during the algorithm must be integers. This admits an early
	failure detection in the implementation. Finally, we proved the uniqueness
	of polynomial interpolation.
	<p>
	The development also contains improved code equations to speed up the
	division of integers in target languages.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Polynomial_Interpolation-AFP,
	author = {René Thiemann and Akihisa Yamada},
	title = {Polynomial Interpolation},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Polynomial_Interpolation.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Sqrt_Babylonian.html">Sqrt_Babylonian</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a>, <a href="Deep_Learning.html">Deep_Learning</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Polynomial_Interpolation/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Polynomial_Interpolation/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Polynomial_Interpolation/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Polynomial_Interpolation-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Polynomial_Interpolation-2018-08-16.tar.gz">
	+ afp-Polynomial_Interpolation-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Polynomial_Interpolation-2017-10-10.tar.gz">
	afp-Polynomial_Interpolation-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Polynomial_Interpolation-2016-12-17.tar.gz">
	afp-Polynomial_Interpolation-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Polynomial_Interpolation-2016-02-22.tar.gz">
	afp-Polynomial_Interpolation-2016-02-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Polynomials.html b/web/entries/Polynomials.html
	--- a/web/entries/Polynomials.html
	+++ b/web/entries/Polynomials.html
	@@ -1,268 +1,273 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Executable Multivariate Polynomials - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>xecutable

	<font class="first">M</font>ultivariate

	<font class="first">P</font>olynomials

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Executable Multivariate Polynomials</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com),
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>,
	<a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>,
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>,
	<a href="http://isabelle.in.tum.de/~haftmann">Florian Haftmann</a>,
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a> and
	Alexander Bentkamp (bentkamp /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-08-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We define multivariate polynomials over arbitrary (ordered) semirings in
	combination with (executable) operations like addition, multiplication,
	and substitution. We also define (weak) monotonicity of polynomials and
	comparison of polynomials where we provide standard estimations like
	absolute positiveness or the more recent approach of Neurauter, Zankl,
	and Middeldorp. Moreover, it is proven that strongly normalizing
	(monotone) orders can be lifted to strongly normalizing (monotone) orders
	over polynomials. Our formalization was performed as part of the <a
	href="http://cl-informatik.uibk.ac.at/software/ceta">IsaFoR/CeTA-system</a>
	which contains several termination techniques. The provided theories have
	been essential to formalize polynomial interpretations.
	<p>
	This formalization also contains an abstract representation as coefficient functions with finite
	support and a type of power-products. If this type is ordered by a linear (term) ordering, various
	additional notions, such as leading power-product, leading coefficient etc., are introduced as
	well. Furthermore, a lot of generic properties of, and functions on, multivariate polynomials are
	formalized, including the substitution and evaluation homomorphisms, embeddings of polynomial rings
	into larger rings (i.e. with one additional indeterminate), homogenization and dehomogenization of
	polynomials, and the canonical isomorphism between R[X,Y] and R[X][Y].</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2010-09-17]: Moved theories on arbitrary (ordered) semirings to Abstract Rewriting.<br>
	[2016-10-28]: Added abstract representation of polynomials and authors Maletzky/Immler.<br>
	[2018-01-23]: Added authors Haftmann, Lochbihler after incorporating
	their formalization of multivariate polynomials based on Polynomial mappings.
	Moved material from Bentkamp's entry "Deep Learning".<br>
	[2019-04-18]: Added material about polynomials whose power-products are represented themselves
	by polynomial mappings.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Polynomials-AFP,
	author = {Christian Sternagel and René Thiemann and Alexander Maletzky and Fabian Immler and Florian Haftmann and Andreas Lochbihler and Alexander Bentkamp},
	title = {Executable Multivariate Polynomials},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Polynomials.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a>, <a href="Matrix.html">Matrix</a>, <a href="Show.html">Show</a>, <a href="Well_Quasi_Orders.html">Well_Quasi_Orders</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Deep_Learning.html">Deep_Learning</a>, <a href="Groebner_Bases.html">Groebner_Bases</a>, <a href="Lambda_Free_KBOs.html">Lambda_Free_KBOs</a>, <a href="Symmetric_Polynomials.html">Symmetric_Polynomials</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Polynomials/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Polynomials/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Polynomials/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Polynomials-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Polynomials-2018-08-16.tar.gz">
	+ afp-Polynomials-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Polynomials-2017-10-10.tar.gz">
	afp-Polynomials-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Polynomials-2016-12-17.tar.gz">
	afp-Polynomials-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Polynomials-2016-02-22.tar.gz">
	afp-Polynomials-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Polynomials-2015-05-27.tar.gz">
	afp-Polynomials-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Polynomials-2014-08-28.tar.gz">
	afp-Polynomials-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Polynomials-2013-12-11.tar.gz">
	afp-Polynomials-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Polynomials-2013-11-17.tar.gz">
	afp-Polynomials-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Polynomials-2013-02-16.tar.gz">
	afp-Polynomials-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Polynomials-2012-05-24.tar.gz">
	afp-Polynomials-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Polynomials-2011-10-11.tar.gz">
	afp-Polynomials-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Polynomials-2011-02-11.tar.gz">
	afp-Polynomials-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Polynomials-2010-08-11.tar.gz">
	afp-Polynomials-2010-08-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Pop_Refinement.html b/web/entries/Pop_Refinement.html
	--- a/web/entries/Pop_Refinement.html
	+++ b/web/entries/Pop_Refinement.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Pop-Refinement - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>op-Refinement

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Pop-Refinement</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.kestrel.edu/~coglio">Alessandro Coglio</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-07-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Pop-refinement is an approach to stepwise refinement, carried out inside an interactive theorem prover by constructing a monotonically decreasing sequence of predicates over deeply embedded target programs. The sequence starts with a predicate that characterizes the possible implementations, and ends with a predicate that characterizes a unique program in explicit syntactic form. Pop-refinement enables more requirements (e.g. program-level and non-functional) to be captured in the initial specification and preserved through refinement. Security requirements expressed as hyperproperties (i.e. predicates over sets of traces) are always preserved by pop-refinement, unlike the popular notion of refinement as trace set inclusion. Two simple examples in Isabelle/HOL are presented, featuring program-level requirements, non-functional requirements, and hyperproperties.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Pop_Refinement-AFP,
	author = {Alessandro Coglio},
	title = {Pop-Refinement},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Pop_Refinement.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pop_Refinement/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Pop_Refinement/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pop_Refinement/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Pop_Refinement-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Pop_Refinement-2018-08-16.tar.gz">
	+ afp-Pop_Refinement-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Pop_Refinement-2017-10-10.tar.gz">
	afp-Pop_Refinement-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Pop_Refinement-2016-12-17.tar.gz">
	afp-Pop_Refinement-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Pop_Refinement-2016-02-22.tar.gz">
	afp-Pop_Refinement-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Pop_Refinement-2015-05-27.tar.gz">
	afp-Pop_Refinement-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Pop_Refinement-2014-08-28.tar.gz">
	afp-Pop_Refinement-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Pop_Refinement-2014-07-03.tar.gz">
	afp-Pop_Refinement-2014-07-03.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Posix-Lexing.html b/web/entries/Posix-Lexing.html
	--- a/web/entries/Posix-Lexing.html
	+++ b/web/entries/Posix-Lexing.html
	@@ -1,207 +1,212 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>POSIX Lexing with Derivatives of Regular Expressions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>OSIX

	<font class="first">L</font>exing

	with

	<font class="first">D</font>erivatives

	of

	<font class="first">R</font>egular

	<font class="first">E</font>xpressions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">POSIX Lexing with Derivatives of Regular Expressions</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://kcl.academia.edu/FahadAusaf">Fahad Ausaf</a>,
	<a href="https://rd.host.cs.st-andrews.ac.uk">Roy Dyckhoff</a> and
	<a href="http://www.inf.kcl.ac.uk/staff/urbanc/">Christian Urban</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Brzozowski introduced the notion of derivatives for regular
	expressions. They can be used for a very simple regular expression
	matching algorithm. Sulzmann and Lu cleverly extended this algorithm
	in order to deal with POSIX matching, which is the underlying
	disambiguation strategy for regular expressions needed in lexers. In
	this entry we give our inductive definition of what a POSIX value is
	and show (i) that such a value is unique (for given regular expression
	and string being matched) and (ii) that Sulzmann and Lu's algorithm
	always generates such a value (provided that the regular expression
	matches the string). We also prove the correctness of an optimised
	version of the POSIX matching algorithm.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Posix-Lexing-AFP,
	author = {Fahad Ausaf and Roy Dyckhoff and Christian Urban},
	title = {POSIX Lexing with Derivatives of Regular Expressions},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Posix-Lexing.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Regular-Sets.html">Regular-Sets</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Posix-Lexing/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Posix-Lexing/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Posix-Lexing/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Posix-Lexing-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Posix-Lexing-2018-08-16.tar.gz">
	+ afp-Posix-Lexing-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Posix-Lexing-2017-10-10.tar.gz">
	afp-Posix-Lexing-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Posix-Lexing-2016-12-17.tar.gz">
	afp-Posix-Lexing-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Posix-Lexing-2016-05-24.tar.gz">
	afp-Posix-Lexing-2016-05-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Possibilistic_Noninterference.html b/web/entries/Possibilistic_Noninterference.html
	--- a/web/entries/Possibilistic_Noninterference.html
	+++ b/web/entries/Possibilistic_Noninterference.html
	@@ -1,221 +1,226 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Possibilistic Noninterference - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>ossibilistic

	<font class="first">N</font>oninterference

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Possibilistic Noninterference</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk) and
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-09-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalize a wide variety of Volpano/Smith-style noninterference
	notions for a while language with parallel composition.
	We systematize and classify these notions according to
	compositionality w.r.t. the language constructs. Compositionality
	yields sound syntactic criteria (a.k.a. type systems) in a uniform way.
	<p>
	An <a href="http://www21.in.tum.de/~nipkow/pubs/cpp12.html">article</a>
	about these proofs is published in the proceedings
	of the conference Certified Programs and Proofs 2012.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Possibilistic_Noninterference-AFP,
	author = {Andrei Popescu and Johannes Hölzl},
	title = {Possibilistic Noninterference},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Possibilistic_Noninterference.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Possibilistic_Noninterference/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Possibilistic_Noninterference/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Possibilistic_Noninterference/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Possibilistic_Noninterference-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Possibilistic_Noninterference-2018-08-16.tar.gz">
	+ afp-Possibilistic_Noninterference-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Possibilistic_Noninterference-2017-10-10.tar.gz">
	afp-Possibilistic_Noninterference-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Possibilistic_Noninterference-2016-12-17.tar.gz">
	afp-Possibilistic_Noninterference-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Possibilistic_Noninterference-2016-02-22.tar.gz">
	afp-Possibilistic_Noninterference-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Possibilistic_Noninterference-2015-05-27.tar.gz">
	afp-Possibilistic_Noninterference-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Possibilistic_Noninterference-2014-08-28.tar.gz">
	afp-Possibilistic_Noninterference-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Possibilistic_Noninterference-2013-12-11.tar.gz">
	afp-Possibilistic_Noninterference-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Possibilistic_Noninterference-2013-11-17.tar.gz">
	afp-Possibilistic_Noninterference-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Possibilistic_Noninterference-2013-02-16.tar.gz">
	afp-Possibilistic_Noninterference-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Possibilistic_Noninterference-2012-09-10.tar.gz">
	afp-Possibilistic_Noninterference-2012-09-10.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Pratt_Certificate.html b/web/entries/Pratt_Certificate.html
	--- a/web/entries/Pratt_Certificate.html
	+++ b/web/entries/Pratt_Certificate.html
	@@ -1,214 +1,219 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Pratt's Primality Certificates - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>ratt's

	<font class="first">P</font>rimality

	<font class="first">C</font>ertificates

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Pratt's Primality Certificates</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a> and
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-07-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">In 1975, Pratt introduced a proof system for certifying primes. He showed that a number <i>p</i> is prime iff a primality certificate for <i>p</i> exists. By showing a logarithmic upper bound on the length of the certificates in size of the prime number, he concluded that the decision problem for prime numbers is in NP. This work formalizes soundness and completeness of Pratt's proof system as well as an upper bound for the size of the certificate.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Pratt_Certificate-AFP,
	author = {Simon Wimmer and Lars Noschinski},
	title = {Pratt's Primality Certificates},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Pratt_Certificate.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Lehmer.html">Lehmer</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Bertrands_Postulate.html">Bertrands_Postulate</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pratt_Certificate/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Pratt_Certificate/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Pratt_Certificate/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Pratt_Certificate-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Pratt_Certificate-2018-08-16.tar.gz">
	+ afp-Pratt_Certificate-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Pratt_Certificate-2017-10-10.tar.gz">
	afp-Pratt_Certificate-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Pratt_Certificate-2016-12-17.tar.gz">
	afp-Pratt_Certificate-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Pratt_Certificate-2016-02-22.tar.gz">
	afp-Pratt_Certificate-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Pratt_Certificate-2015-05-27.tar.gz">
	afp-Pratt_Certificate-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Pratt_Certificate-2014-08-28.tar.gz">
	afp-Pratt_Certificate-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Pratt_Certificate-2013-12-11.tar.gz">
	afp-Pratt_Certificate-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Pratt_Certificate-2013-11-17.tar.gz">
	afp-Pratt_Certificate-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Pratt_Certificate-2013-07-29.tar.gz">
	afp-Pratt_Certificate-2013-07-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Presburger-Automata.html b/web/entries/Presburger-Automata.html
	--- a/web/entries/Presburger-Automata.html
	+++ b/web/entries/Presburger-Automata.html
	@@ -1,242 +1,247 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalizing the Logic-Automaton Connection - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalizing

	the

	<font class="first">L</font>ogic-Automaton

	<font class="first">C</font>onnection

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalizing the Logic-Automaton Connection</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a> and
	Markus Reiter
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-12-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This work presents a formalization of a library for automata on bit strings. It forms the basis of a reflection-based decision procedure for Presburger arithmetic, which is efficiently executable thanks to Isabelle's code generator. With this work, we therefore provide a mechanized proof of a well-known connection between logic and automata theory. The formalization is also described in a publication [TPHOLs 2009].</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Presburger-Automata-AFP,
	author = {Stefan Berghofer and Markus Reiter},
	title = {Formalizing the Logic-Automaton Connection},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/Presburger-Automata.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Presburger-Automata/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Presburger-Automata/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Presburger-Automata/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Presburger-Automata-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Presburger-Automata-2018-08-16.tar.gz">
	+ afp-Presburger-Automata-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Presburger-Automata-2017-10-10.tar.gz">
	afp-Presburger-Automata-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Presburger-Automata-2016-12-17.tar.gz">
	afp-Presburger-Automata-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Presburger-Automata-2016-02-22.tar.gz">
	afp-Presburger-Automata-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Presburger-Automata-2015-05-27.tar.gz">
	afp-Presburger-Automata-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Presburger-Automata-2014-08-28.tar.gz">
	afp-Presburger-Automata-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Presburger-Automata-2013-12-11.tar.gz">
	afp-Presburger-Automata-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Presburger-Automata-2013-11-17.tar.gz">
	afp-Presburger-Automata-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Presburger-Automata-2013-03-02.tar.gz">
	afp-Presburger-Automata-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Presburger-Automata-2013-02-16.tar.gz">
	afp-Presburger-Automata-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Presburger-Automata-2012-05-24.tar.gz">
	afp-Presburger-Automata-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Presburger-Automata-2011-10-11.tar.gz">
	afp-Presburger-Automata-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Presburger-Automata-2011-02-11.tar.gz">
	afp-Presburger-Automata-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Presburger-Automata-2010-07-01.tar.gz">
	afp-Presburger-Automata-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Presburger-Automata-2009-12-12.tar.gz">
	afp-Presburger-Automata-2009-12-12.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Prime_Distribution_Elementary.html b/web/entries/Prime_Distribution_Elementary.html
	--- a/web/entries/Prime_Distribution_Elementary.html
	+++ b/web/entries/Prime_Distribution_Elementary.html
	@@ -1,192 +1,198 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Elementary Facts About the Distribution of Primes - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>lementary

	<font class="first">F</font>acts

	<font class="first">A</font>bout

	the

	<font class="first">D</font>istribution

	of

	<font class="first">P</font>rimes

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Elementary Facts About the Distribution of Primes</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-02-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This entry is a formalisation of Chapter 4 (and parts of
	Chapter 3) of Apostol's <a
	href="https://www.springer.com/de/book/9780387901633"><em>Introduction
	to Analytic Number Theory</em></a>. The main topics that
	are addressed are properties of the distribution of prime numbers that
	can be shown in an elementary way (i. e. without the Prime
	Number Theorem), the various equivalent forms of the PNT (which imply
	each other in elementary ways), and consequences that follow from the
	PNT in elementary ways. The latter include, most notably, asymptotic
	bounds for the number of distinct prime factors of
	<em>n</em>, the divisor function
	<em>d(n)</em>, Euler's totient function
	<em>φ(n)</em>, and
	lcm(1,…,<em>n</em>).</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Prime_Distribution_Elementary-AFP,
	author = {Manuel Eberl},
	title = {Elementary Facts About the Distribution of Primes},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Prime_Distribution_Elementary.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Prime_Number_Theorem.html">Prime_Number_Theorem</a>, <a href="Zeta_Function.html">Zeta_Function</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Prime_Distribution_Elementary/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Prime_Distribution_Elementary/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Prime_Distribution_Elementary/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Prime_Distribution_Elementary-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Prime_Distribution_Elementary-2019-02-22.tar.gz">
	+ afp-Prime_Distribution_Elementary-2019-02-22.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Prime_Harmonic_Series.html b/web/entries/Prime_Harmonic_Series.html
	--- a/web/entries/Prime_Harmonic_Series.html
	+++ b/web/entries/Prime_Harmonic_Series.html
	@@ -1,210 +1,215 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Divergence of the Prime Harmonic Series - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">D</font>ivergence

	of

	the

	<font class="first">P</font>rime

	<font class="first">H</font>armonic

	<font class="first">S</font>eries

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Divergence of the Prime Harmonic Series</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	In this work, we prove the lower bound <span class="nobr">ln(H_n) -
	ln(5/3)</span> for the
	partial sum of the Prime Harmonic series and, based on this, the divergence of
	the Prime Harmonic Series
	<span class="nobr">∑[p prime] · 1/p.</span>
	</p><p>
	The proof relies on the unique squarefree decomposition of natural numbers. This
	is similar to Euler's original proof (which was highly informal and morally
	questionable). Its advantage over proofs by contradiction, like the famous one
	by Paul Erdős, is that it provides a relatively good lower bound for the partial
	sums.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Prime_Harmonic_Series-AFP,
	author = {Manuel Eberl},
	title = {The Divergence of the Prime Harmonic Series},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Prime_Harmonic_Series.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Prime_Harmonic_Series/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Prime_Harmonic_Series/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Prime_Harmonic_Series/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Prime_Harmonic_Series-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Prime_Harmonic_Series-2018-08-16.tar.gz">
	+ afp-Prime_Harmonic_Series-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Prime_Harmonic_Series-2017-10-10.tar.gz">
	afp-Prime_Harmonic_Series-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Prime_Harmonic_Series-2016-12-17.tar.gz">
	afp-Prime_Harmonic_Series-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Prime_Harmonic_Series-2016-02-22.tar.gz">
	afp-Prime_Harmonic_Series-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Prime_Harmonic_Series-2016-01-05.tar.gz">
	afp-Prime_Harmonic_Series-2016-01-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Prime_Number_Theorem.html b/web/entries/Prime_Number_Theorem.html
	--- a/web/entries/Prime_Number_Theorem.html
	+++ b/web/entries/Prime_Number_Theorem.html
	@@ -1,210 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Prime Number Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">P</font>rime

	<font class="first">N</font>umber

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Prime Number Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a> and
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-09-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This article provides a short proof of the Prime Number
	Theorem in several equivalent forms, most notably
	π(<em>x</em>) ~ <em>x</em>/ln
	<em>x</em> where π(<em>x</em>) is the
	number of primes no larger than <em>x</em>. It also
	defines other basic number-theoretic functions related to primes like
	Chebyshev's functions &thetasym; and ψ and the
	“<em>n</em>-th prime number” function
	p<sub><em>n</em></sub>. We also show various
	bounds and relationship between these functions are shown. Lastly, we
	derive Mertens' First and Second Theorem, i. e.
	∑<sub><em>p</em>≤<em>x</em></sub>
	ln <em>p</em>/<em>p</em> = ln
	<em>x</em> + <em>O</em>(1) and
	∑<sub><em>p</em>≤<em>x</em></sub>
	1/<em>p</em> = ln ln <em>x</em> + M +
	<em>O</em>(1/ln <em>x</em>). We also give
	explicit bounds for the remainder terms.</p> <p>The proof
	of the Prime Number Theorem builds on a library of Dirichlet series
	and analytic combinatorics. We essentially follow the presentation by
	Newman. The core part of the proof is a Tauberian theorem for
	Dirichlet series, which is proven using complex analysis and then used
	to strengthen Mertens' First Theorem to
	∑<sub><em>p</em>≤<em>x</em></sub>
	ln <em>p</em>/<em>p</em> = ln
	<em>x</em> + c + <em>o</em>(1).</p>
	<p>A variant of this proof has been formalised before by
	Harrison in HOL Light, and formalisations of Selberg's elementary
	proof exist both by Avigad <em>et al.</em> in Isabelle and
	by Carneiro in Metamath. The advantage of the analytic proof is that,
	while it requires more powerful mathematical tools, it is considerably
	shorter and clearer. This article attempts to provide a short and
	clear formalisation of all components of that proof using the full
	range of mathematical machinery available in Isabelle, staying as
	close as possible to Newman's simple paper proof.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Prime_Number_Theorem-AFP,
	author = {Manuel Eberl and Lawrence C. Paulson},
	title = {The Prime Number Theorem},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Prime_Number_Theorem.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Stirling_Formula.html">Stirling_Formula</a>, <a href="Zeta_Function.html">Zeta_Function</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Prime_Distribution_Elementary.html">Prime_Distribution_Elementary</a>, <a href="Transcendence_Series_Hancl_Rucki.html">Transcendence_Series_Hancl_Rucki</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Prime_Number_Theorem/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Prime_Number_Theorem/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Prime_Number_Theorem/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Prime_Number_Theorem-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Prime_Number_Theorem-2018-09-20.tar.gz">
	+ afp-Prime_Number_Theorem-2018-09-20.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Priority_Queue_Braun.html b/web/entries/Priority_Queue_Braun.html
	--- a/web/entries/Priority_Queue_Braun.html
	+++ b/web/entries/Priority_Queue_Braun.html
	@@ -1,203 +1,208 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Priority Queues Based on Braun Trees - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>riority

	<font class="first">Q</font>ueues

	<font class="first">B</font>ased

	on

	<font class="first">B</font>raun

	<font class="first">T</font>rees

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Priority Queues Based on Braun Trees</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-09-04</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This theory implements priority queues via Braun trees. Insertion
	and deletion take logarithmic time and preserve the balanced nature
	of Braun trees.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Priority_Queue_Braun-AFP,
	author = {Tobias Nipkow},
	title = {Priority Queues Based on Braun Trees},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Priority_Queue_Braun.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Priority_Queue_Braun/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Priority_Queue_Braun/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Priority_Queue_Braun/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Priority_Queue_Braun-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Priority_Queue_Braun-2018-08-16.tar.gz">
	+ afp-Priority_Queue_Braun-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Priority_Queue_Braun-2017-10-10.tar.gz">
	afp-Priority_Queue_Braun-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Priority_Queue_Braun-2016-12-17.tar.gz">
	afp-Priority_Queue_Braun-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Priority_Queue_Braun-2016-02-22.tar.gz">
	afp-Priority_Queue_Braun-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Priority_Queue_Braun-2015-05-27.tar.gz">
	afp-Priority_Queue_Braun-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Priority_Queue_Braun-2014-09-04.tar.gz">
	afp-Priority_Queue_Braun-2014-09-04.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Probabilistic_Noninterference.html b/web/entries/Probabilistic_Noninterference.html
	--- a/web/entries/Probabilistic_Noninterference.html
	+++ b/web/entries/Probabilistic_Noninterference.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Probabilistic Noninterference - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>robabilistic

	<font class="first">N</font>oninterference

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Probabilistic Noninterference</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk) and
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-03-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalize a probabilistic noninterference for a multi-threaded language with uniform scheduling, where probabilistic behaviour comes from both the scheduler and the individual threads. We define notions probabilistic noninterference in two variants: resumption-based and trace-based. For the resumption-based notions, we prove compositionality w.r.t. the language constructs and establish sound type-system-like syntactic criteria. This is a formalization of the mathematical development presented at CPP 2013 and CALCO 2013. It is the probabilistic variant of the Possibilistic Noninterference AFP entry.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Probabilistic_Noninterference-AFP,
	author = {Andrei Popescu and Johannes Hölzl},
	title = {Probabilistic Noninterference},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Probabilistic_Noninterference.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a>, <a href="Markov_Models.html">Markov_Models</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_Noninterference/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Probabilistic_Noninterference/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_Noninterference/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Probabilistic_Noninterference-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Probabilistic_Noninterference-2018-08-16.tar.gz">
	+ afp-Probabilistic_Noninterference-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Probabilistic_Noninterference-2017-10-10.tar.gz">
	afp-Probabilistic_Noninterference-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Probabilistic_Noninterference-2016-12-17.tar.gz">
	afp-Probabilistic_Noninterference-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Probabilistic_Noninterference-2016-02-22.tar.gz">
	afp-Probabilistic_Noninterference-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Probabilistic_Noninterference-2015-05-27.tar.gz">
	afp-Probabilistic_Noninterference-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Probabilistic_Noninterference-2014-08-28.tar.gz">
	afp-Probabilistic_Noninterference-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Probabilistic_Noninterference-2014-03-16.tar.gz">
	afp-Probabilistic_Noninterference-2014-03-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Probabilistic_Prime_Tests.html b/web/entries/Probabilistic_Prime_Tests.html
	--- a/web/entries/Probabilistic_Prime_Tests.html
	+++ b/web/entries/Probabilistic_Prime_Tests.html
	@@ -1,180 +1,186 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Probabilistic Primality Testing - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>robabilistic

	<font class="first">P</font>rimality

	<font class="first">T</font>esting

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Probabilistic Primality Testing</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Daniel Stüwe and
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-02-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>The most efficient known primality tests are
	<em>probabilistic</em> in the sense that they use
	randomness and may, with some probability, mistakenly classify a
	composite number as prime – but never a prime number as
	composite. Examples of this are the Miller–Rabin test, the
	Solovay–Strassen test, and (in most cases) Fermat's
	test.</p> <p>This entry defines these three tests and
	proves their correctness. It also develops some of the
	number-theoretic foundations, such as Carmichael numbers and the
	Jacobi symbol with an efficient executable algorithm to compute
	it.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Probabilistic_Prime_Tests-AFP,
	author = {Daniel Stüwe and Manuel Eberl},
	title = {Probabilistic Primality Testing},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Probabilistic_Prime_Tests.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_Prime_Tests/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Probabilistic_Prime_Tests/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_Prime_Tests/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Probabilistic_Prime_Tests-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Probabilistic_Prime_Tests-2019-02-15.tar.gz">
	+ afp-Probabilistic_Prime_Tests-2019-02-15.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Probabilistic_System_Zoo.html b/web/entries/Probabilistic_System_Zoo.html
	--- a/web/entries/Probabilistic_System_Zoo.html
	+++ b/web/entries/Probabilistic_System_Zoo.html
	@@ -1,203 +1,208 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Zoo of Probabilistic Systems - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">Z</font>oo

	of

	<font class="first">P</font>robabilistic

	<font class="first">S</font>ystems

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Zoo of Probabilistic Systems</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>,
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a> and
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-05-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Numerous models of probabilistic systems are studied in the literature.
	Coalgebra has been used to classify them into system types and compare their
	expressiveness. We formalize the resulting hierarchy of probabilistic system
	types by modeling the semantics of the different systems as codatatypes.
	This approach yields simple and concise proofs, as bisimilarity coincides
	with equality for codatatypes.
	<p>
	This work is described in detail in the ITP 2015 publication by the authors.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Probabilistic_System_Zoo-AFP,
	author = {Johannes Hölzl and Andreas Lochbihler and Dmitriy Traytel},
	title = {A Zoo of Probabilistic Systems},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Probabilistic_System_Zoo.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_System_Zoo/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Probabilistic_System_Zoo/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_System_Zoo/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Probabilistic_System_Zoo-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Probabilistic_System_Zoo-2018-08-16.tar.gz">
	+ afp-Probabilistic_System_Zoo-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Probabilistic_System_Zoo-2017-10-10.tar.gz">
	afp-Probabilistic_System_Zoo-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Probabilistic_System_Zoo-2016-12-17.tar.gz">
	afp-Probabilistic_System_Zoo-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Probabilistic_System_Zoo-2016-02-22.tar.gz">
	afp-Probabilistic_System_Zoo-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Probabilistic_System_Zoo-2015-05-28.tar.gz">
	afp-Probabilistic_System_Zoo-2015-05-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Probabilistic_Timed_Automata.html b/web/entries/Probabilistic_Timed_Automata.html
	--- a/web/entries/Probabilistic_Timed_Automata.html
	+++ b/web/entries/Probabilistic_Timed_Automata.html
	@@ -1,188 +1,193 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Probabilistic Timed Automata - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>robabilistic

	<font class="first">T</font>imed

	<font class="first">A</font>utomata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Probabilistic Timed Automata</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a> and
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-05-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formalization of probabilistic timed automata (PTA) for
	which we try to follow the formula MDP + TA = PTA as far as possible:
	our work starts from our existing formalizations of Markov decision
	processes (MDP) and timed automata (TA) and combines them modularly.
	We prove the fundamental result for probabilistic timed automata: the
	region construction that is known from timed automata carries over to
	the probabilistic setting. In particular, this allows us to prove that
	minimum and maximum reachability probabilities can be computed via a
	reduction to MDP model checking, including the case where one wants to
	disregard unrealizable behavior. Further information can be found in
	our ITP paper [2].</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Probabilistic_Timed_Automata-AFP,
	author = {Simon Wimmer and Johannes Hölzl},
	title = {Probabilistic Timed Automata},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Probabilistic_Timed_Automata.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Markov_Models.html">Markov_Models</a>, <a href="Timed_Automata.html">Timed_Automata</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_Timed_Automata/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Probabilistic_Timed_Automata/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_Timed_Automata/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Probabilistic_Timed_Automata-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Probabilistic_Timed_Automata-2018-08-16.tar.gz">
	+ afp-Probabilistic_Timed_Automata-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Probabilistic_Timed_Automata-2018-05-25.tar.gz">
	afp-Probabilistic_Timed_Automata-2018-05-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Probabilistic_While.html b/web/entries/Probabilistic_While.html
	--- a/web/entries/Probabilistic_While.html
	+++ b/web/entries/Probabilistic_While.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Probabilistic while loop - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>robabilistic

	while

	loop

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Probabilistic while loop</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This AFP entry defines a probabilistic while operator based on
	sub-probability mass functions and formalises zero-one laws and variant
	rules for probabilistic loop termination. As applications, we
	implement probabilistic algorithms for the Bernoulli, geometric and
	arbitrary uniform distributions that only use fair coin flips, and
	prove them correct and terminating with probability 1.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-02-02]:
	Added a proof that probabilistic conditioning can be implemented by repeated sampling.
	(revision 305867c4e911)<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Probabilistic_While-AFP,
	author = {Andreas Lochbihler},
	title = {Probabilistic while loop},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Probabilistic_While.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a>, <a href="MFMC_Countable.html">MFMC_Countable</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CryptHOL.html">CryptHOL</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_While/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Probabilistic_While/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Probabilistic_While/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Probabilistic_While-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Probabilistic_While-2018-08-16.tar.gz">
	+ afp-Probabilistic_While-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Probabilistic_While-2017-10-10.tar.gz">
	afp-Probabilistic_While-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Probabilistic_While-2017-05-11.tar.gz">
	afp-Probabilistic_While-2017-05-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Program-Conflict-Analysis.html b/web/entries/Program-Conflict-Analysis.html
	--- a/web/entries/Program-Conflict-Analysis.html
	+++ b/web/entries/Program-Conflict-Analysis.html
	@@ -1,275 +1,280 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of Conflict Analysis of Programs with Procedures, Thread Creation, and Monitors - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	<font class="first">C</font>onflict

	<font class="first">A</font>nalysis

	of

	<font class="first">P</font>rograms

	with

	<font class="first">P</font>rocedures,

	<font class="first">T</font>hread

	<font class="first">C</font>reation,

	and

	<font class="first">M</font>onitors

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of Conflict Analysis of Programs with Procedures, Thread Creation, and Monitors</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	<a href="http://cs.uni-muenster.de/u/mmo/">Markus Müller-Olm</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2007-12-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">In this work we formally verify the soundness and precision of a static program analysis that detects conflicts (e. g. data races) in programs with procedures, thread creation and monitors with the Isabelle theorem prover. As common in static program analysis, our program model abstracts guarded branching by nondeterministic branching, but completely interprets the call-/return behavior of procedures, synchronization by monitors, and thread creation. The analysis is based on the observation that all conflicts already occur in a class of particularly restricted schedules. These restricted schedules are suited to constraint-system-based program analysis. The formalization is based upon a flowgraph-based program model with an operational semantics as reference point.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Program-Conflict-Analysis-AFP,
	author = {Peter Lammich and Markus Müller-Olm},
	title = {Formalization of Conflict Analysis of Programs with Procedures, Thread Creation, and Monitors},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2007,
	note = {\url{http://isa-afp.org/entries/Program-Conflict-Analysis.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Flow_Networks.html">Flow_Networks</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Program-Conflict-Analysis/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Program-Conflict-Analysis/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Program-Conflict-Analysis/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Program-Conflict-Analysis-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Program-Conflict-Analysis-2018-08-16.tar.gz">
	+ afp-Program-Conflict-Analysis-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Program-Conflict-Analysis-2017-10-10.tar.gz">
	afp-Program-Conflict-Analysis-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Program-Conflict-Analysis-2016-12-17.tar.gz">
	afp-Program-Conflict-Analysis-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Program-Conflict-Analysis-2016-02-22.tar.gz">
	afp-Program-Conflict-Analysis-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Program-Conflict-Analysis-2015-05-27.tar.gz">
	afp-Program-Conflict-Analysis-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Program-Conflict-Analysis-2014-08-28.tar.gz">
	afp-Program-Conflict-Analysis-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Program-Conflict-Analysis-2013-12-11.tar.gz">
	afp-Program-Conflict-Analysis-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Program-Conflict-Analysis-2013-11-17.tar.gz">
	afp-Program-Conflict-Analysis-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Program-Conflict-Analysis-2013-03-02.tar.gz">
	afp-Program-Conflict-Analysis-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Program-Conflict-Analysis-2013-02-16.tar.gz">
	afp-Program-Conflict-Analysis-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Program-Conflict-Analysis-2012-05-24.tar.gz">
	afp-Program-Conflict-Analysis-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Program-Conflict-Analysis-2011-10-11.tar.gz">
	afp-Program-Conflict-Analysis-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Program-Conflict-Analysis-2011-02-11.tar.gz">
	afp-Program-Conflict-Analysis-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Program-Conflict-Analysis-2010-07-01.tar.gz">
	afp-Program-Conflict-Analysis-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Program-Conflict-Analysis-2009-12-12.tar.gz">
	afp-Program-Conflict-Analysis-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Program-Conflict-Analysis-2009-04-29.tar.gz">
	afp-Program-Conflict-Analysis-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Program-Conflict-Analysis-2008-06-10.tar.gz">
	afp-Program-Conflict-Analysis-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Program-Conflict-Analysis-2007-12-20.tar.gz">
	afp-Program-Conflict-Analysis-2007-12-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Projective_Geometry.html b/web/entries/Projective_Geometry.html
	--- a/web/entries/Projective_Geometry.html
	+++ b/web/entries/Projective_Geometry.html
	@@ -1,180 +1,185 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Projective Geometry - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>rojective

	<font class="first">G</font>eometry

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Projective Geometry</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://sites.google.com/site/anthonybordg/">Anthony Bordg</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-06-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize the basics of projective geometry. In particular, we give
	a proof of the so-called Hessenberg's theorem in projective plane
	geometry. We also provide a proof of the so-called Desargues's
	theorem based on an axiomatization of (higher) projective space
	geometry using the notion of rank of a matroid. This last approach
	allows to handle incidence relations in an homogeneous way dealing
	only with points and without the need of talking explicitly about
	lines, planes or any higher entity.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Projective_Geometry-AFP,
	author = {Anthony Bordg},
	title = {Projective Geometry},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Projective_Geometry.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Projective_Geometry/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Projective_Geometry/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Projective_Geometry/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Projective_Geometry-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Projective_Geometry-2018-08-16.tar.gz">
	+ afp-Projective_Geometry-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Projective_Geometry-2018-06-15.tar.gz">
	afp-Projective_Geometry-2018-06-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Promela.html b/web/entries/Promela.html
	--- a/web/entries/Promela.html
	+++ b/web/entries/Promela.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Promela Formalization - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>romela

	<font class="first">F</font>ormalization

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Promela Formalization</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	René Neumann (rene /dot/ neumann /at/ in /dot/ tum /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-05-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present an executable formalization of the language Promela, the
	description language 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.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Promela-AFP,
	author = {René Neumann},
	title = {Promela Formalization},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Promela.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="CAVA_Automata.html">CAVA_Automata</a>, <a href="LTL.html">LTL</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="CAVA_LTL_Modelchecker.html">CAVA_LTL_Modelchecker</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Promela/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Promela/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Promela/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Promela-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Promela-2018-08-16.tar.gz">
	+ afp-Promela-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Promela-2017-10-10.tar.gz">
	afp-Promela-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Promela-2016-12-17.tar.gz">
	afp-Promela-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Promela-2016-02-22.tar.gz">
	afp-Promela-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Promela-2015-05-27.tar.gz">
	afp-Promela-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Promela-2014-08-28.tar.gz">
	afp-Promela-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Promela-2014-05-29.tar.gz">
	afp-Promela-2014-05-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Proof_Strategy_Language.html b/web/entries/Proof_Strategy_Language.html
	--- a/web/entries/Proof_Strategy_Language.html
	+++ b/web/entries/Proof_Strategy_Language.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Proof Strategy Language - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>roof

	<font class="first">S</font>trategy

	<font class="first">L</font>anguage

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Proof Strategy Language</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Yutaka Nagashima
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-12-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Isabelle includes various automatic tools for finding proofs under
	certain conditions. However, for each conjecture, knowing which
	automation to use, and how to tweak its parameters, is currently
	labour intensive. We have developed a language, PSL, designed to
	capture high level proof strategies. PSL offloads the construction of
	human-readable fast-to-replay proof scripts to automatic search,
	making use of search-time information about each conjecture. Our
	preliminary evaluations show that PSL reduces the labour cost of
	interactive theorem proving. This submission contains the
	implementation of PSL and an example theory file, Example.thy, showing
	how to write poof strategies in PSL.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Proof_Strategy_Language-AFP,
	author = {Yutaka Nagashima},
	title = {Proof Strategy Language},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Proof_Strategy_Language.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Proof_Strategy_Language/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Proof_Strategy_Language/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Proof_Strategy_Language/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Proof_Strategy_Language-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Proof_Strategy_Language-2018-08-16.tar.gz">
	+ afp-Proof_Strategy_Language-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Proof_Strategy_Language-2017-10-10.tar.gz">
	afp-Proof_Strategy_Language-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Proof_Strategy_Language-2016-12-21.tar.gz">
	afp-Proof_Strategy_Language-2016-12-21.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/PropResPI.html b/web/entries/PropResPI.html
	--- a/web/entries/PropResPI.html
	+++ b/web/entries/PropResPI.html
	@@ -1,217 +1,222 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Propositional Resolution and Prime Implicates Generation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>ropositional

	<font class="first">R</font>esolution

	and

	<font class="first">P</font>rime

	<font class="first">I</font>mplicates

	<font class="first">G</font>eneration

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Propositional Resolution and Prime Implicates Generation</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://membres-lig.imag.fr/peltier/">Nicolas Peltier</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-03-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We provide formal proofs in Isabelle-HOL (using mostly structured Isar
	proofs) of the soundness and completeness of the Resolution rule in
	propositional logic. The completeness proofs take into account the
	usual redundancy elimination rules (tautology elimination and
	subsumption), and several refinements of the Resolution rule are
	considered: ordered resolution (with selection functions), positive
	and negative resolution, semantic resolution and unit resolution (the
	latter refinement is complete only for clause sets that are Horn-
	renamable). We also define a concrete procedure for computing
	saturated sets and establish its soundness and completeness. The
	clause sets are not assumed to be finite, so that the results can be
	applied to formulas obtained by grounding sets of first-order clauses
	(however, a total ordering among atoms is assumed to be given).
	Next, we show that the unrestricted Resolution rule is deductive-
	complete, in the sense that it is able to generate all (prime)
	implicates of any set of propositional clauses (i.e., all entailment-
	minimal, non-valid, clausal consequences of the considered set). The
	generation of prime implicates is an important problem, with many
	applications in artificial intelligence and verification (for
	abductive reasoning, knowledge compilation, diagnosis, debugging
	etc.). We also show that implicates can be computed in an incremental
	way, by fixing an ordering among all the atoms in the considered sets
	and resolving upon these atoms one by one in the considered order
	(with no backtracking). This feature is critical for the efficient
	computation of prime implicates. Building on these results, we provide
	a procedure for computing such implicates and establish its soundness
	and completeness.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{PropResPI-AFP,
	author = {Nicolas Peltier},
	title = {Propositional Resolution and Prime Implicates Generation},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/PropResPI.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PropResPI/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/PropResPI/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PropResPI/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-PropResPI-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-PropResPI-2018-08-16.tar.gz">
	+ afp-PropResPI-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-PropResPI-2017-10-10.tar.gz">
	afp-PropResPI-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-PropResPI-2016-12-17.tar.gz">
	afp-PropResPI-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-PropResPI-2016-03-11.tar.gz">
	afp-PropResPI-2016-03-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Propositional_Proof_Systems.html b/web/entries/Propositional_Proof_Systems.html
	--- a/web/entries/Propositional_Proof_Systems.html
	+++ b/web/entries/Propositional_Proof_Systems.html
	@@ -1,186 +1,191 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Propositional Proof Systems - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>ropositional

	<font class="first">P</font>roof

	<font class="first">S</font>ystems

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Propositional Proof Systems</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://liftm.de">Julius Michaelis</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-06-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize a range of proof systems for classical propositional
	logic (sequent calculus, natural deduction, Hilbert systems,
	resolution) and prove the most important meta-theoretic results about
	semantics and proofs: compactness, soundness, completeness,
	translations between proof systems, cut-elimination, interpolation and
	model existence.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Propositional_Proof_Systems-AFP,
	author = {Julius Michaelis and Tobias Nipkow},
	title = {Propositional Proof Systems},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Propositional_Proof_Systems.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Propositional_Proof_Systems/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Propositional_Proof_Systems/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Propositional_Proof_Systems/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Propositional_Proof_Systems-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Propositional_Proof_Systems-2018-08-16.tar.gz">
	+ afp-Propositional_Proof_Systems-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Propositional_Proof_Systems-2017-10-10.tar.gz">
	afp-Propositional_Proof_Systems-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Propositional_Proof_Systems-2017-06-22.tar.gz">
	afp-Propositional_Proof_Systems-2017-06-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Prpu_Maxflow.html b/web/entries/Prpu_Maxflow.html
	--- a/web/entries/Prpu_Maxflow.html
	+++ b/web/entries/Prpu_Maxflow.html
	@@ -1,192 +1,197 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalizing Push-Relabel Algorithms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalizing

	<font class="first">P</font>ush-Relabel

	<font class="first">A</font>lgorithms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalizing Push-Relabel Algorithms</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	S. Reza Sefidgar
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-06-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formalization of push-relabel algorithms for computing
	the maximum flow in a network. We start with Goldberg's et
	al.~generic push-relabel algorithm, for which we show correctness and
	the time complexity bound of O(V^2E). We then derive the
	relabel-to-front and FIFO implementation. Using stepwise refinement
	techniques, we derive an efficient verified implementation. Our
	formal proof of the abstract algorithms closely follows a standard
	textbook proof. It is accessible even without being an expert in
	Isabelle/HOL, the interactive theorem prover used for the
	formalization.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Prpu_Maxflow-AFP,
	author = {Peter Lammich and S. Reza Sefidgar},
	title = {Formalizing Push-Relabel Algorithms},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Prpu_Maxflow.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Flow_Networks.html">Flow_Networks</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Prpu_Maxflow/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Prpu_Maxflow/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Prpu_Maxflow/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Prpu_Maxflow-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Prpu_Maxflow-2018-08-16.tar.gz">
	+ afp-Prpu_Maxflow-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Prpu_Maxflow-2017-10-10.tar.gz">
	afp-Prpu_Maxflow-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Prpu_Maxflow-2017-06-02.tar.gz">
	afp-Prpu_Maxflow-2017-06-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/PseudoHoops.html b/web/entries/PseudoHoops.html
	--- a/web/entries/PseudoHoops.html
	+++ b/web/entries/PseudoHoops.html
	@@ -1,226 +1,231 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Pseudo Hoops - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>seudo

	<font class="first">H</font>oops

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Pseudo Hoops</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	George Georgescu,
	Laurentiu Leustean and
	Viorel Preoteasa (viorel /dot/ preoteasa /at/ aalto /dot/ fi)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-09-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Pseudo-hoops are algebraic structures introduced by B. Bosbach under the name of complementary semigroups. In this formalization we prove some properties of pseudo-hoops and we define the basic concepts of filter and normal filter. The lattice of normal filters is isomorphic with the lattice of congruences of a pseudo-hoop. We also study some important classes of pseudo-hoops. Bounded Wajsberg pseudo-hoops are equivalent to pseudo-Wajsberg algebras and bounded basic pseudo-hoops are equivalent to pseudo-BL algebras. Some examples of pseudo-hoops are given in the last section of the formalization.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{PseudoHoops-AFP,
	author = {George Georgescu and Laurentiu Leustean and Viorel Preoteasa},
	title = {Pseudo Hoops},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/PseudoHoops.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="LatticeProperties.html">LatticeProperties</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PseudoHoops/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/PseudoHoops/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/PseudoHoops/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-PseudoHoops-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-PseudoHoops-2018-08-16.tar.gz">
	+ afp-PseudoHoops-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-PseudoHoops-2017-10-10.tar.gz">
	afp-PseudoHoops-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-PseudoHoops-2016-12-17.tar.gz">
	afp-PseudoHoops-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-PseudoHoops-2016-02-22.tar.gz">
	afp-PseudoHoops-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-PseudoHoops-2015-05-27.tar.gz">
	afp-PseudoHoops-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-PseudoHoops-2014-08-28.tar.gz">
	afp-PseudoHoops-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-PseudoHoops-2013-12-11.tar.gz">
	afp-PseudoHoops-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-PseudoHoops-2013-11-17.tar.gz">
	afp-PseudoHoops-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-PseudoHoops-2013-02-16.tar.gz">
	afp-PseudoHoops-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-PseudoHoops-2012-05-24.tar.gz">
	afp-PseudoHoops-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-PseudoHoops-2011-10-11.tar.gz">
	afp-PseudoHoops-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-PseudoHoops-2011-09-27.tar.gz">
	afp-PseudoHoops-2011-09-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Psi_Calculi.html b/web/entries/Psi_Calculi.html
	--- a/web/entries/Psi_Calculi.html
	+++ b/web/entries/Psi_Calculi.html
	@@ -1,220 +1,225 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Psi-calculi in Isabelle - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>si-calculi

	in

	<font class="first">I</font>sabelle

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Psi-calculi in Isabelle</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.itu.dk/people/jebe">Jesper Bengtson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-05-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Psi-calculi are extensions of the pi-calculus, accommodating arbitrary nominal datatypes to represent not only data but also communication channels, assertions and conditions, giving it an expressive power beyond the applied pi-calculus and the concurrent constraint pi-calculus.
	<p>
	We have formalised psi-calculi in the interactive theorem prover Isabelle using its nominal datatype package. One distinctive feature is that the framework needs to treat binding sequences, as opposed to single binders, in an efficient way. While different methods for formalising single binder calculi have been proposed over the last decades, representations for such binding sequences are not very well explored.
	<p>
	The main effort in the formalisation is to keep the machine checked proofs as close to their pen-and-paper counterparts as possible. This includes treating all binding sequences as atomic elements, and creating custom induction and inversion rules that to remove the bulk of manual alpha-conversions.
	<p>
	This entry is described in detail in <a href="http://www.itu.dk/people/jebe/files/thesis.pdf">Bengtson's thesis</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Psi_Calculi-AFP,
	author = {Jesper Bengtson},
	title = {Psi-calculi in Isabelle},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Psi_Calculi.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Psi_Calculi/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Psi_Calculi/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Psi_Calculi/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Psi_Calculi-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Psi_Calculi-2018-08-16.tar.gz">
	+ afp-Psi_Calculi-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Psi_Calculi-2017-10-10.tar.gz">
	afp-Psi_Calculi-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Psi_Calculi-2016-12-17.tar.gz">
	afp-Psi_Calculi-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Psi_Calculi-2016-02-22.tar.gz">
	afp-Psi_Calculi-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Psi_Calculi-2015-05-27.tar.gz">
	afp-Psi_Calculi-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Psi_Calculi-2014-08-28.tar.gz">
	afp-Psi_Calculi-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Psi_Calculi-2013-12-11.tar.gz">
	afp-Psi_Calculi-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Psi_Calculi-2013-11-17.tar.gz">
	afp-Psi_Calculi-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Psi_Calculi-2013-02-16.tar.gz">
	afp-Psi_Calculi-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Psi_Calculi-2012-06-14.tar.gz">
	afp-Psi_Calculi-2012-06-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Ptolemys_Theorem.html b/web/entries/Ptolemys_Theorem.html
	--- a/web/entries/Ptolemys_Theorem.html
	+++ b/web/entries/Ptolemys_Theorem.html
	@@ -1,187 +1,192 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Ptolemy's Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>tolemy's

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Ptolemy's Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-08-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides an analytic proof to Ptolemy's Theorem using
	polar form transformation and trigonometric identities.
	In this formalization, we use ideas from John Harrison's HOL Light
	formalization and the proof sketch on the Wikipedia entry of Ptolemy's Theorem.
	This theorem is the 95th theorem of the Top 100 Theorems list.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Ptolemys_Theorem-AFP,
	author = {Lukas Bulwahn},
	title = {Ptolemy's Theorem},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Ptolemys_Theorem.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ptolemys_Theorem/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Ptolemys_Theorem/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ptolemys_Theorem/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Ptolemys_Theorem-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Ptolemys_Theorem-2018-08-16.tar.gz">
	+ afp-Ptolemys_Theorem-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Ptolemys_Theorem-2017-10-10.tar.gz">
	afp-Ptolemys_Theorem-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Ptolemys_Theorem-2016-12-17.tar.gz">
	afp-Ptolemys_Theorem-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Ptolemys_Theorem-2016-08-08.tar.gz">
	afp-Ptolemys_Theorem-2016-08-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/QHLProver.html b/web/entries/QHLProver.html
	--- a/web/entries/QHLProver.html
	+++ b/web/entries/QHLProver.html
	@@ -1,183 +1,189 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Quantum Hoare Logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">Q</font>uantum

	<font class="first">H</font>oare

	<font class="first">L</font>ogic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Quantum Hoare Logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Junyi Liu,
	<a href="http://lcs.ios.ac.cn/~bzhan/">Bohua Zhan</a>,
	Shuling Wang,
	Shenggang Ying,
	Tao Liu,
	Yangjia Li,
	Mingsheng Ying and
	Naijun Zhan
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-03-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize quantum Hoare logic as given in [1]. In particular, we
	specify the syntax and denotational semantics of a simple model of
	quantum programs. Then, we write down the rules of quantum Hoare logic
	for partial correctness, and show the soundness and completeness of
	the resulting proof system. As an application, we verify the
	correctness of Grover’s algorithm.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{QHLProver-AFP,
	author = {Junyi Liu and Bohua Zhan and Shuling Wang and Shenggang Ying and Tao Liu and Yangjia Li and Mingsheng Ying and Naijun Zhan},
	title = {Quantum Hoare Logic},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/QHLProver.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Deep_Learning.html">Deep_Learning</a>, <a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/QHLProver/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/QHLProver/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/QHLProver/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-QHLProver-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-QHLProver-2019-03-25.tar.gz">
	+ afp-QHLProver-2019-03-25.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/QR_Decomposition.html b/web/entries/QR_Decomposition.html
	--- a/web/entries/QR_Decomposition.html
	+++ b/web/entries/QR_Decomposition.html
	@@ -1,199 +1,204 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>QR Decomposition - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">Q</font>R

	<font class="first">D</font>ecomposition

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">QR Decomposition</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a> and
	<a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-02-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-06-18]: The second part of the Fundamental Theorem of Linear Algebra has been generalized to more general inner product spaces.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/QR_Decomposition.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Gauss_Jordan.html">Gauss_Jordan</a>, <a href="Rank_Nullity_Theorem.html">Rank_Nullity_Theorem</a>, <a href="Real_Impl.html">Real_Impl</a>, <a href="Sqrt_Babylonian.html">Sqrt_Babylonian</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/QR_Decomposition/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/QR_Decomposition/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/QR_Decomposition/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-QR_Decomposition-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-QR_Decomposition-2018-08-16.tar.gz">
	+ afp-QR_Decomposition-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-QR_Decomposition-2017-10-10.tar.gz">
	afp-QR_Decomposition-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-QR_Decomposition-2016-12-17.tar.gz">
	afp-QR_Decomposition-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-QR_Decomposition-2016-02-22.tar.gz">
	afp-QR_Decomposition-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-QR_Decomposition-2015-05-27.tar.gz">
	afp-QR_Decomposition-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-QR_Decomposition-2015-02-13.tar.gz">
	afp-QR_Decomposition-2015-02-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Quantales.html b/web/entries/Quantales.html
	--- a/web/entries/Quantales.html
	+++ b/web/entries/Quantales.html
	@@ -1,171 +1,177 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Quantales - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">Q</font>uantales

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Quantales</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-12-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	These mathematical components formalise basic properties of quantales,
	together with some important models, constructions, and concepts,
	including quantic nuclei and conuclei.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Quantales-AFP,
	author = {Georg Struth},
	title = {Quantales},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Quantales.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Kleene_Algebra.html">Kleene_Algebra</a>, <a href="Order_Lattice_Props.html">Order_Lattice_Props</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Transformer_Semantics.html">Transformer_Semantics</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Quantales/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Quantales/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Quantales/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Quantales-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Quantales-2018-12-19.tar.gz">
	+ afp-Quantales-2018-12-19.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Quaternions.html b/web/entries/Quaternions.html
	--- a/web/entries/Quaternions.html
	+++ b/web/entries/Quaternions.html
	@@ -1,173 +1,179 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Quaternions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">Q</font>uaternions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Quaternions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-09-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This theory is inspired by the HOL Light development of quaternions,
	but follows its own route. Quaternions are developed coinductively, as
	in the existing formalisation of the complex numbers. Quaternions are
	quickly shown to belong to the type classes of real normed division
	algebras and real inner product spaces. And therefore they inherit a
	great body of facts involving algebraic laws, limits, continuity,
	etc., which must be proved explicitly in the HOL Light version. The
	development concludes with the geometric interpretation of the product
	of imaginary quaternions.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Quaternions-AFP,
	author = {Lawrence C. Paulson},
	title = {Quaternions},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Quaternions.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Quaternions/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Quaternions/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Quaternions/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Quaternions-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Quaternions-2018-09-07.tar.gz">
	+ afp-Quaternions-2018-09-07.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Quick_Sort_Cost.html b/web/entries/Quick_Sort_Cost.html
	--- a/web/entries/Quick_Sort_Cost.html
	+++ b/web/entries/Quick_Sort_Cost.html
	@@ -1,198 +1,203 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The number of comparisons in QuickSort - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	number

	of

	comparisons

	in

	<font class="first">Q</font>uickSort

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The number of comparisons in QuickSort</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-03-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>We give a formal proof of the well-known results about the
	number of comparisons performed by two variants of QuickSort: first,
	the expected number of comparisons of randomised QuickSort
	(i. e. QuickSort with random pivot choice) is
	<em>2 (n+1) H<sub>n</sub> -
	4 n</em>, which is asymptotically equivalent to
	<em>2 n ln n</em>; second, the number of
	comparisons performed by the classic non-randomised QuickSort has the
	same distribution in the average case as the randomised one.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Quick_Sort_Cost-AFP,
	author = {Manuel Eberl},
	title = {The number of comparisons in QuickSort},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Quick_Sort_Cost.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Comparison_Sort_Lower_Bound.html">Comparison_Sort_Lower_Bound</a>, <a href="Landau_Symbols.html">Landau_Symbols</a>, <a href="List-Index.html">List-Index</a>, <a href="Regular-Sets.html">Regular-Sets</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Random_BSTs.html">Random_BSTs</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Quick_Sort_Cost/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Quick_Sort_Cost/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Quick_Sort_Cost/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Quick_Sort_Cost-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Quick_Sort_Cost-2018-08-16.tar.gz">
	+ afp-Quick_Sort_Cost-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Quick_Sort_Cost-2017-10-10.tar.gz">
	afp-Quick_Sort_Cost-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Quick_Sort_Cost-2017-03-16.tar.gz">
	afp-Quick_Sort_Cost-2017-03-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/RIPEMD-160-SPARK.html b/web/entries/RIPEMD-160-SPARK.html
	--- a/web/entries/RIPEMD-160-SPARK.html
	+++ b/web/entries/RIPEMD-160-SPARK.html
	@@ -1,229 +1,234 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>RIPEMD-160 - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>IPEMD-160

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">RIPEMD-160</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-01-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This work presents a verification of an implementation in SPARK/ADA of the cryptographic hash-function RIPEMD-160. A functional specification of RIPEMD-160 is given in Isabelle/HOL. Proofs for the verification conditions generated by the static-analysis toolset of SPARK certify the functional correctness of the implementation.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-11-09]: Entry is now obsolete, moved to Isabelle distribution.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{RIPEMD-160-SPARK-AFP,
	author = {Fabian Immler},
	title = {RIPEMD-160},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/RIPEMD-160-SPARK.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/RIPEMD-160-SPARK/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/RIPEMD-160-SPARK/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/RIPEMD-160-SPARK/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-RIPEMD-160-SPARK-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-RIPEMD-160-SPARK-2018-08-16.tar.gz">
	+ afp-RIPEMD-160-SPARK-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-RIPEMD-160-SPARK-2017-10-10.tar.gz">
	afp-RIPEMD-160-SPARK-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-RIPEMD-160-SPARK-2016-12-17.tar.gz">
	afp-RIPEMD-160-SPARK-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-RIPEMD-160-SPARK-2016-02-22.tar.gz">
	afp-RIPEMD-160-SPARK-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-RIPEMD-160-SPARK-2015-05-27.tar.gz">
	afp-RIPEMD-160-SPARK-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-RIPEMD-160-SPARK-2014-08-28.tar.gz">
	afp-RIPEMD-160-SPARK-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-RIPEMD-160-SPARK-2013-12-11.tar.gz">
	afp-RIPEMD-160-SPARK-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-RIPEMD-160-SPARK-2013-11-17.tar.gz">
	afp-RIPEMD-160-SPARK-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-RIPEMD-160-SPARK-2013-02-16.tar.gz">
	afp-RIPEMD-160-SPARK-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-RIPEMD-160-SPARK-2012-05-24.tar.gz">
	afp-RIPEMD-160-SPARK-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-RIPEMD-160-SPARK-2011-10-11.tar.gz">
	afp-RIPEMD-160-SPARK-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-RIPEMD-160-SPARK-2011-02-11.tar.gz">
	afp-RIPEMD-160-SPARK-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-RIPEMD-160-SPARK-2011-01-19.tar.gz">
	afp-RIPEMD-160-SPARK-2011-01-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/ROBDD.html b/web/entries/ROBDD.html
	--- a/web/entries/ROBDD.html
	+++ b/web/entries/ROBDD.html
	@@ -1,204 +1,209 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Algorithms for Reduced Ordered Binary Decision Diagrams - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>lgorithms

	for

	<font class="first">R</font>educed

	<font class="first">O</font>rdered

	<font class="first">B</font>inary

	<font class="first">D</font>ecision

	<font class="first">D</font>iagrams

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Algorithms for Reduced Ordered Binary Decision Diagrams</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://liftm.de">Julius Michaelis</a>,
	<a href="https://home.in.tum.de/~haslbecm">Maximilian Haslbeck</a>,
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-04-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a verified and executable implementation of ROBDDs in
	Isabelle/HOL. Our implementation relates pointer-based computation in
	the Heap monad to operations on an abstract definition of boolean
	functions. Internally, we implemented the if-then-else combinator in a
	recursive fashion, following the Shannon decomposition of the argument
	functions. The implementation mixes and adapts known techniques and is
	built with efficiency in mind.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{ROBDD-AFP,
	author = {Julius Michaelis and Maximilian Haslbeck and Peter Lammich and Lars Hupel},
	title = {Algorithms for Reduced Ordered Binary Decision Diagrams},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/ROBDD.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Automatic_Refinement.html">Automatic_Refinement</a>, <a href="Collections.html">Collections</a>, <a href="Native_Word.html">Native_Word</a>, <a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ROBDD/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/ROBDD/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ROBDD/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-ROBDD-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-ROBDD-2018-08-16.tar.gz">
	+ afp-ROBDD-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-ROBDD-2017-10-10.tar.gz">
	afp-ROBDD-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-ROBDD-2016-12-17.tar.gz">
	afp-ROBDD-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-ROBDD-2016-04-27.tar.gz">
	afp-ROBDD-2016-04-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/RSAPSS.html b/web/entries/RSAPSS.html
	--- a/web/entries/RSAPSS.html
	+++ b/web/entries/RSAPSS.html
	@@ -1,264 +1,269 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>SHA1, RSA, PSS and more - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>HA1,

	<font class="first">R</font>SA,

	<font class="first">P</font>SS

	and

	more

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">SHA1, RSA, PSS and more</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christina Lindenberg and
	Kai Wirt
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2005-05-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Formal verification is getting more and more important in computer science. However the state of the art formal verification methods in cryptography are very rudimentary. These theories are one step to provide a tool box allowing the use of formal methods in every aspect of cryptography. Moreover we present a proof of concept for the feasibility of verification techniques to a standard signature algorithm.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{RSAPSS-AFP,
	author = {Christina Lindenberg and Kai Wirt},
	title = {SHA1, RSA, PSS and more},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2005,
	note = {\url{http://isa-afp.org/entries/RSAPSS.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/RSAPSS/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/RSAPSS/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/RSAPSS/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-RSAPSS-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-RSAPSS-2018-08-16.tar.gz">
	+ afp-RSAPSS-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-RSAPSS-2017-10-10.tar.gz">
	afp-RSAPSS-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-RSAPSS-2016-12-17.tar.gz">
	afp-RSAPSS-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-RSAPSS-2016-02-22.tar.gz">
	afp-RSAPSS-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-RSAPSS-2015-05-27.tar.gz">
	afp-RSAPSS-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-RSAPSS-2014-08-28.tar.gz">
	afp-RSAPSS-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-RSAPSS-2013-12-11.tar.gz">
	afp-RSAPSS-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-RSAPSS-2013-11-17.tar.gz">
	afp-RSAPSS-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-RSAPSS-2013-03-02.tar.gz">
	afp-RSAPSS-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-RSAPSS-2013-02-16.tar.gz">
	afp-RSAPSS-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-RSAPSS-2012-05-24.tar.gz">
	afp-RSAPSS-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-RSAPSS-2011-10-11.tar.gz">
	afp-RSAPSS-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-RSAPSS-2011-02-11.tar.gz">
	afp-RSAPSS-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-RSAPSS-2010-07-01.tar.gz">
	afp-RSAPSS-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-RSAPSS-2009-12-12.tar.gz">
	afp-RSAPSS-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-RSAPSS-2009-04-29.tar.gz">
	afp-RSAPSS-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-RSAPSS-2008-06-10.tar.gz">
	afp-RSAPSS-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-RSAPSS-2007-11-27.tar.gz">
	afp-RSAPSS-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-RSAPSS-2005-10-14.tar.gz">
	afp-RSAPSS-2005-10-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Ramsey-Infinite.html b/web/entries/Ramsey-Infinite.html
	--- a/web/entries/Ramsey-Infinite.html
	+++ b/web/entries/Ramsey-Infinite.html
	@@ -1,266 +1,271 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Ramsey's theorem, infinitary version - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>amsey's

	theorem,

	infinitary

	version

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Ramsey's theorem, infinitary version</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Tom Ridge
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-09-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This formalization of Ramsey's theorem (infinitary version) is taken from Boolos and Jeffrey, <i>Computability and Logic</i>, 3rd edition, Chapter 26. It differs slightly from the text by assuming a slightly stronger hypothesis. In particular, the induction hypothesis is stronger, holding for any infinite subset of the naturals. This avoids the rather peculiar mapping argument between kj and aikj on p.263, which is unnecessary and slightly mars this really beautiful result.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Ramsey-Infinite-AFP,
	author = {Tom Ridge},
	title = {Ramsey's theorem, infinitary version},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Ramsey-Infinite.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ramsey-Infinite/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Ramsey-Infinite/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ramsey-Infinite/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Ramsey-Infinite-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Ramsey-Infinite-2018-08-16.tar.gz">
	+ afp-Ramsey-Infinite-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Ramsey-Infinite-2017-10-10.tar.gz">
	afp-Ramsey-Infinite-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Ramsey-Infinite-2016-12-17.tar.gz">
	afp-Ramsey-Infinite-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Ramsey-Infinite-2016-02-22.tar.gz">
	afp-Ramsey-Infinite-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Ramsey-Infinite-2015-05-27.tar.gz">
	afp-Ramsey-Infinite-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Ramsey-Infinite-2014-08-28.tar.gz">
	afp-Ramsey-Infinite-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Ramsey-Infinite-2013-12-11.tar.gz">
	afp-Ramsey-Infinite-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Ramsey-Infinite-2013-11-17.tar.gz">
	afp-Ramsey-Infinite-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Ramsey-Infinite-2013-02-16.tar.gz">
	afp-Ramsey-Infinite-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Ramsey-Infinite-2012-05-24.tar.gz">
	afp-Ramsey-Infinite-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Ramsey-Infinite-2011-10-11.tar.gz">
	afp-Ramsey-Infinite-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Ramsey-Infinite-2011-02-11.tar.gz">
	afp-Ramsey-Infinite-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Ramsey-Infinite-2010-07-01.tar.gz">
	afp-Ramsey-Infinite-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Ramsey-Infinite-2009-12-12.tar.gz">
	afp-Ramsey-Infinite-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Ramsey-Infinite-2009-04-29.tar.gz">
	afp-Ramsey-Infinite-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Ramsey-Infinite-2008-06-10.tar.gz">
	afp-Ramsey-Infinite-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Ramsey-Infinite-2007-11-27.tar.gz">
	afp-Ramsey-Infinite-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Ramsey-Infinite-2005-10-14.tar.gz">
	afp-Ramsey-Infinite-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Ramsey-Infinite-2004-09-21.tar.gz">
	afp-Ramsey-Infinite-2004-09-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Ramsey-Infinite-2004-09-20.tar.gz">
	afp-Ramsey-Infinite-2004-09-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Random_BSTs.html b/web/entries/Random_BSTs.html
	--- a/web/entries/Random_BSTs.html
	+++ b/web/entries/Random_BSTs.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Expected Shape of Random Binary Search Trees - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>xpected

	<font class="first">S</font>hape

	of

	<font class="first">R</font>andom

	<font class="first">B</font>inary

	<font class="first">S</font>earch

	<font class="first">T</font>rees

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Expected Shape of Random Binary Search Trees</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-04-04</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This entry contains proofs for the textbook results about the
	distributions of the height and internal path length of random binary
	search trees (BSTs), i. e. BSTs that are formed by taking
	an empty BST and inserting elements from a fixed set in random
	order.</p> <p>In particular, we prove a logarithmic upper
	bound on the expected height and the <em>Θ(n log n)</em>
	closed-form solution for the expected internal path length in terms of
	the harmonic numbers. We also show how the internal path length
	relates to the average-case cost of a lookup in a BST.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Random_BSTs-AFP,
	author = {Manuel Eberl},
	title = {Expected Shape of Random Binary Search Trees},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Random_BSTs.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Landau_Symbols.html">Landau_Symbols</a>, <a href="Quick_Sort_Cost.html">Quick_Sort_Cost</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Randomised_BSTs.html">Randomised_BSTs</a>, <a href="Treaps.html">Treaps</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Random_BSTs/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Random_BSTs/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Random_BSTs/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Random_BSTs-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Random_BSTs-2018-08-16.tar.gz">
	+ afp-Random_BSTs-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Random_BSTs-2017-10-10.tar.gz">
	afp-Random_BSTs-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Random_BSTs-2017-04-04.tar.gz">
	afp-Random_BSTs-2017-04-04.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Random_Graph_Subgraph_Threshold.html b/web/entries/Random_Graph_Subgraph_Threshold.html
	--- a/web/entries/Random_Graph_Subgraph_Threshold.html
	+++ b/web/entries/Random_Graph_Subgraph_Threshold.html
	@@ -1,209 +1,214 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Properties of Random Graphs -- Subgraph Containment - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">P</font>roperties

	of

	<font class="first">R</font>andom

	<font class="first">G</font>raphs

	<font class="first">-</font>-

	<font class="first">S</font>ubgraph

	<font class="first">C</font>ontainment

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Properties of Random Graphs -- Subgraph Containment</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-02-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Random graphs are graphs with a fixed number of vertices, where each edge is present with a fixed probability. We are interested in the probability that a random graph contains a certain pattern, for example a cycle or a clique. A very high edge probability gives rise to perhaps too many edges (which degrades performance for many algorithms), whereas a low edge probability might result in a disconnected graph. We prove a theorem about a threshold probability such that a higher edge probability will asymptotically almost surely produce a random graph with the desired subgraph.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Random_Graph_Subgraph_Threshold-AFP,
	author = {Lars Hupel},
	title = {Properties of Random Graphs -- Subgraph Containment},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Random_Graph_Subgraph_Threshold.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Girth_Chromatic.html">Girth_Chromatic</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Random_Graph_Subgraph_Threshold/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Random_Graph_Subgraph_Threshold/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Random_Graph_Subgraph_Threshold/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Random_Graph_Subgraph_Threshold-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Random_Graph_Subgraph_Threshold-2018-08-16.tar.gz">
	+ afp-Random_Graph_Subgraph_Threshold-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Random_Graph_Subgraph_Threshold-2017-10-10.tar.gz">
	afp-Random_Graph_Subgraph_Threshold-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Random_Graph_Subgraph_Threshold-2016-12-17.tar.gz">
	afp-Random_Graph_Subgraph_Threshold-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Random_Graph_Subgraph_Threshold-2016-02-22.tar.gz">
	afp-Random_Graph_Subgraph_Threshold-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Random_Graph_Subgraph_Threshold-2015-05-27.tar.gz">
	afp-Random_Graph_Subgraph_Threshold-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Random_Graph_Subgraph_Threshold-2014-08-28.tar.gz">
	afp-Random_Graph_Subgraph_Threshold-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Random_Graph_Subgraph_Threshold-2014-02-14.tar.gz">
	afp-Random_Graph_Subgraph_Threshold-2014-02-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Randomised_BSTs.html b/web/entries/Randomised_BSTs.html
	--- a/web/entries/Randomised_BSTs.html
	+++ b/web/entries/Randomised_BSTs.html
	@@ -1,179 +1,185 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Randomised Binary Search Trees - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>andomised

	<font class="first">B</font>inary

	<font class="first">S</font>earch

	<font class="first">T</font>rees

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Randomised Binary Search Trees</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-10-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This work is a formalisation of the Randomised Binary Search
	Trees introduced by Martínez and Roura, including definitions and
	correctness proofs.</p> <p>Like randomised treaps, they
	are a probabilistic data structure that behaves exactly as if elements
	were inserted into a non-balancing BST in random order. However,
	unlike treaps, they only use discrete probability distributions, but
	their use of randomness is more complicated.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Randomised_BSTs-AFP,
	author = {Manuel Eberl},
	title = {Randomised Binary Search Trees},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Randomised_BSTs.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Monad_Normalisation.html">Monad_Normalisation</a>, <a href="Random_BSTs.html">Random_BSTs</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Randomised_BSTs/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Randomised_BSTs/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Randomised_BSTs/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Randomised_BSTs-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Randomised_BSTs-2018-10-19.tar.gz">
	+ afp-Randomised_BSTs-2018-10-19.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Randomised_Social_Choice.html b/web/entries/Randomised_Social_Choice.html
	--- a/web/entries/Randomised_Social_Choice.html
	+++ b/web/entries/Randomised_Social_Choice.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Randomised Social Choice Theory - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>andomised

	<font class="first">S</font>ocial

	<font class="first">C</font>hoice

	<font class="first">T</font>heory

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Randomised Social Choice Theory</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This work contains a formalisation of basic Randomised Social Choice,
	including Stochastic Dominance and Social Decision Schemes (SDSs)
	along with some of their most important properties (Anonymity,
	Neutrality, ex-post- and SD-Efficiency, SD-Strategy-Proofness) and two
	particular SDSs – Random Dictatorship and Random Serial Dictatorship
	(with proofs of the properties that they satisfy). Many important
	properties of these concepts are also proven – such as the two
	equivalent characterisations of Stochastic Dominance and the fact that
	SD-efficiency of a lottery only depends on the support. The entry
	also provides convenient commands to define Preference Profiles, prove
	their well-formedness, and automatically derive restrictions that
	sufficiently nice SDSs need to satisfy on the defined profiles.
	Currently, the formalisation focuses on weak preferences and
	Stochastic Dominance, but it should be easy to extend it to other
	domains – such as strict preferences – or other lottery extensions –
	such as Bilinear Dominance or Pairwise Comparison.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Randomised_Social_Choice-AFP,
	author = {Manuel Eberl},
	title = {Randomised Social Choice Theory},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Randomised_Social_Choice.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="List-Index.html">List-Index</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Fishburn_Impossibility.html">Fishburn_Impossibility</a>, <a href="SDS_Impossibility.html">SDS_Impossibility</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Randomised_Social_Choice/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Randomised_Social_Choice/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Randomised_Social_Choice/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Randomised_Social_Choice-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Randomised_Social_Choice-2018-08-16.tar.gz">
	+ afp-Randomised_Social_Choice-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Randomised_Social_Choice-2017-10-10.tar.gz">
	afp-Randomised_Social_Choice-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Randomised_Social_Choice-2016-12-17.tar.gz">
	afp-Randomised_Social_Choice-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Randomised_Social_Choice-2016-05-05.tar.gz">
	afp-Randomised_Social_Choice-2016-05-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Rank_Nullity_Theorem.html b/web/entries/Rank_Nullity_Theorem.html
	--- a/web/entries/Rank_Nullity_Theorem.html
	+++ b/web/entries/Rank_Nullity_Theorem.html
	@@ -1,225 +1,230 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Rank-Nullity Theorem in Linear Algebra - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>ank-Nullity

	<font class="first">T</font>heorem

	in

	<font class="first">L</font>inear

	<font class="first">A</font>lgebra

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Rank-Nullity Theorem in Linear Algebra</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a> and
	<a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-01-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">In this contribution, we present some formalizations based on the HOL-Multivariate-Analysis session of Isabelle. Firstly, a generalization of several theorems of such library are presented. Secondly, some definitions and proofs involving Linear Algebra and the four fundamental subspaces of a matrix are shown. Finally, we present a proof of the result known in Linear Algebra as the ``Rank-Nullity Theorem'', which states that, given any linear map f from a finite dimensional vector space V to a vector space W, then the dimension of V is equal to the dimension of the kernel of f (which is a subspace of V) and the dimension of the range of f (which is a subspace of W). The proof presented here is based on the one given by Sheldon Axler in his book <i>Linear Algebra Done Right</i>. As a corollary of the previous theorem, and taking advantage of the relationship between linear maps and matrices, we prove that, for every matrix A (which has associated a linear map between finite dimensional vector spaces), the sum of its null space and its column space (which is equal to the range of the linear map) is equal to the number of columns of A.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2014-07-14]: Added some generalizations that allow us to formalize the Rank-Nullity Theorem over finite dimensional vector spaces, instead of over the more particular euclidean spaces. Updated abstract.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Rank_Nullity_Theorem-AFP,
	author = {Jose Divasón and Jesús Aransay},
	title = {Rank-Nullity Theorem in Linear Algebra},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Rank_Nullity_Theorem.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Echelon_Form.html">Echelon_Form</a>, <a href="Gauss_Jordan.html">Gauss_Jordan</a>, <a href="Perron_Frobenius.html">Perron_Frobenius</a>, <a href="QR_Decomposition.html">QR_Decomposition</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Rank_Nullity_Theorem/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Rank_Nullity_Theorem/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Rank_Nullity_Theorem/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Rank_Nullity_Theorem-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Rank_Nullity_Theorem-2018-08-16.tar.gz">
	+ afp-Rank_Nullity_Theorem-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Rank_Nullity_Theorem-2017-10-10.tar.gz">
	afp-Rank_Nullity_Theorem-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Rank_Nullity_Theorem-2016-12-17.tar.gz">
	afp-Rank_Nullity_Theorem-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Rank_Nullity_Theorem-2016-02-22.tar.gz">
	afp-Rank_Nullity_Theorem-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Rank_Nullity_Theorem-2015-05-27.tar.gz">
	afp-Rank_Nullity_Theorem-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Rank_Nullity_Theorem-2014-08-28.tar.gz">
	afp-Rank_Nullity_Theorem-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Rank_Nullity_Theorem-2013-12-11.tar.gz">
	afp-Rank_Nullity_Theorem-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Rank_Nullity_Theorem-2013-11-17.tar.gz">
	afp-Rank_Nullity_Theorem-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Rank_Nullity_Theorem-2013-02-16.tar.gz">
	afp-Rank_Nullity_Theorem-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Rank_Nullity_Theorem-2013-01-16.tar.gz">
	afp-Rank_Nullity_Theorem-2013-01-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Real_Impl.html b/web/entries/Real_Impl.html
	--- a/web/entries/Real_Impl.html
	+++ b/web/entries/Real_Impl.html
	@@ -1,224 +1,229 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Implementing field extensions of the form Q[sqrt(b)] - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>mplementing

	field

	extensions

	of

	the

	form

	<font class="first">Q</font>[sqrt(b)]

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Implementing field extensions of the form Q[sqrt(b)]</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-02-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	<p>
	Our results have been used to certify termination proofs which involve
	polynomial interpretations over the reals.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2014-07-11]: Moved NthRoot_Impl to Sqrt-Babylonian.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Real_Impl.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Deriving.html">Deriving</a>, <a href="Show.html">Show</a>, <a href="Sqrt_Babylonian.html">Sqrt_Babylonian</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="QR_Decomposition.html">QR_Decomposition</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Real_Impl/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Real_Impl/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Real_Impl/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Real_Impl-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Real_Impl-2018-08-16.tar.gz">
	+ afp-Real_Impl-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Real_Impl-2017-10-10.tar.gz">
	afp-Real_Impl-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Real_Impl-2016-12-17.tar.gz">
	afp-Real_Impl-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Real_Impl-2016-02-22.tar.gz">
	afp-Real_Impl-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Real_Impl-2015-05-27.tar.gz">
	afp-Real_Impl-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Real_Impl-2014-08-28.tar.gz">
	afp-Real_Impl-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Real_Impl-2014-02-11.tar.gz">
	afp-Real_Impl-2014-02-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Recursion-Theory-I.html b/web/entries/Recursion-Theory-I.html
	--- a/web/entries/Recursion-Theory-I.html
	+++ b/web/entries/Recursion-Theory-I.html
	@@ -1,251 +1,256 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Recursion Theory I - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>ecursion

	<font class="first">T</font>heory

	<font class="first">I</font>

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Recursion Theory I</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Michael Nedzelsky
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-04-05</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document presents the formalization of introductory material from recursion theory --- definitions and basic properties of primitive recursive functions, Cantor pairing function and computably enumerable sets (including a proof of existence of a one-complete computably enumerable set and a proof of the Rice's theorem).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Recursion-Theory-I-AFP,
	author = {Michael Nedzelsky},
	title = {Recursion Theory I},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/Recursion-Theory-I.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Minsky_Machines.html">Minsky_Machines</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Recursion-Theory-I/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Recursion-Theory-I/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Recursion-Theory-I/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Recursion-Theory-I-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Recursion-Theory-I-2018-08-16.tar.gz">
	+ afp-Recursion-Theory-I-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Recursion-Theory-I-2017-10-10.tar.gz">
	afp-Recursion-Theory-I-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Recursion-Theory-I-2016-12-17.tar.gz">
	afp-Recursion-Theory-I-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Recursion-Theory-I-2016-02-22.tar.gz">
	afp-Recursion-Theory-I-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Recursion-Theory-I-2015-05-27.tar.gz">
	afp-Recursion-Theory-I-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Recursion-Theory-I-2014-08-28.tar.gz">
	afp-Recursion-Theory-I-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Recursion-Theory-I-2013-12-11.tar.gz">
	afp-Recursion-Theory-I-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Recursion-Theory-I-2013-11-17.tar.gz">
	afp-Recursion-Theory-I-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Recursion-Theory-I-2013-02-16.tar.gz">
	afp-Recursion-Theory-I-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Recursion-Theory-I-2012-05-24.tar.gz">
	afp-Recursion-Theory-I-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Recursion-Theory-I-2011-10-11.tar.gz">
	afp-Recursion-Theory-I-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Recursion-Theory-I-2011-02-11.tar.gz">
	afp-Recursion-Theory-I-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Recursion-Theory-I-2010-07-01.tar.gz">
	afp-Recursion-Theory-I-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Recursion-Theory-I-2009-12-12.tar.gz">
	afp-Recursion-Theory-I-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Recursion-Theory-I-2009-04-29.tar.gz">
	afp-Recursion-Theory-I-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Recursion-Theory-I-2008-06-10.tar.gz">
	afp-Recursion-Theory-I-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Recursion-Theory-I-2008-04-11.tar.gz">
	afp-Recursion-Theory-I-2008-04-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Refine_Imperative_HOL.html b/web/entries/Refine_Imperative_HOL.html
	--- a/web/entries/Refine_Imperative_HOL.html
	+++ b/web/entries/Refine_Imperative_HOL.html
	@@ -1,211 +1,216 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Imperative Refinement Framework - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">I</font>mperative

	<font class="first">R</font>efinement

	<font class="first">F</font>ramework

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Imperative Refinement Framework</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-08-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present the Imperative Refinement Framework (IRF), a tool that
	supports a stepwise refinement based approach to imperative programs.
	This entry is based on the material we presented in [ITP-2015,
	CPP-2016]. It uses the Monadic Refinement Framework as a frontend for
	the specification of the abstract programs, and Imperative/HOL as a
	backend to generate executable imperative programs. The IRF comes
	with tool support to synthesize imperative programs from more
	abstract, functional ones, using efficient imperative implementations
	for the abstract data structures. This entry also includes the
	Imperative Isabelle Collection Framework (IICF), which provides a
	library of re-usable imperative collection data structures. Moreover,
	this entry contains a quickstart guide and a reference manual, which
	provide an introduction to using the IRF for Isabelle/HOL experts. It
	also provids a collection of (partly commented) practical examples,
	some highlights being Dijkstra's Algorithm, Nested-DFS, and a generic
	worklist algorithm with subsumption. Finally, this entry contains
	benchmark scripts that compare the runtime of some examples against
	reference implementations of the algorithms in Java and C++.
	[ITP-2015] Peter Lammich: Refinement to Imperative/HOL. ITP 2015:
	253--269 [CPP-2016] Peter Lammich: Refinement based verification of
	imperative data structures. CPP 2016: 27--36</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Refine_Imperative_HOL-AFP,
	author = {Peter Lammich},
	title = {The Imperative Refinement Framework},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Refine_Imperative_HOL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="DFS_Framework.html">DFS_Framework</a>, <a href="Dijkstra_Shortest_Path.html">Dijkstra_Shortest_Path</a>, <a href="List-Index.html">List-Index</a>, <a href="Separation_Logic_Imperative_HOL.html">Separation_Logic_Imperative_HOL</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Flow_Networks.html">Flow_Networks</a>, <a href="Floyd_Warshall.html">Floyd_Warshall</a>, <a href="Knuth_Morris_Pratt.html">Knuth_Morris_Pratt</a>, <a href="Kruskal.html">Kruskal</a>, <a href="ROBDD.html">ROBDD</a>, <a href="VerifyThis2018.html">VerifyThis2018</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Refine_Imperative_HOL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Refine_Imperative_HOL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Refine_Imperative_HOL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Refine_Imperative_HOL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Refine_Imperative_HOL-2018-08-16.tar.gz">
	+ afp-Refine_Imperative_HOL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Refine_Imperative_HOL-2017-10-10.tar.gz">
	afp-Refine_Imperative_HOL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Refine_Imperative_HOL-2016-12-17.tar.gz">
	afp-Refine_Imperative_HOL-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Refine_Imperative_HOL-2016-08-08.tar.gz">
	afp-Refine_Imperative_HOL-2016-08-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Refine_Monadic.html b/web/entries/Refine_Monadic.html
	--- a/web/entries/Refine_Monadic.html
	+++ b/web/entries/Refine_Monadic.html
	@@ -1,257 +1,262 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Refinement for Monadic Programs - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>efinement

	for

	<font class="first">M</font>onadic

	<font class="first">P</font>rograms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Refinement for Monadic Programs</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-01-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We provide a framework for program and data refinement in Isabelle/HOL.
	The framework is based on a nondeterminism-monad with assertions, i.e.,
	the monad carries a set of results or an assertion failure.
	Recursion is expressed by fixed points. For convenience, we also provide
	while and foreach combinators.
	<p>
	The framework provides tools to automatize canonical tasks, such as
	verification condition generation, finding appropriate data refinement relations,
	and refine an executable program to a form that is accepted by the
	Isabelle/HOL code generator.
	<p>
	This submission comes with a collection of examples and a user-guide,
	illustrating the usage of the framework.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2012-04-23] Introduced ordered FOREACH loops<br>
	[2012-06] New features:
	REC_rule_arb and RECT_rule_arb allow for generalizing over variables.
	prepare_code_thms - command extracts code equations for recursion combinators.<br>
	[2012-07] New example: Nested DFS for emptiness check of Buchi-automata with witness.<br>
	New feature:
	fo_rule method to apply resolution using first-order matching. Useful for arg_conf, fun_cong.<br>
	[2012-08] Adaptation to ICF v2.<br>
	[2012-10-05] Adaptations to include support for Automatic Refinement Framework.<br>
	[2013-09] This entry now depends on Automatic Refinement<br>
	[2014-06] New feature: vc_solve method to solve verification conditions.
	Maintenace changes: VCG-rules for nfoldli, improved setup for FOREACH-loops.<br>
	[2014-07] Now defining recursion via flat domain. Dropped many single-valued prerequisites.
	Changed notion of data refinement. In single-valued case, this matches the old notion.
	In non-single valued case, the new notion allows for more convenient rules.
	In particular, the new definitions allow for projecting away ghost variables as a refinement step.<br>
	[2014-11] New features: le-or-fail relation (leof), modular reasoning about loop invariants.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Refine_Monadic-AFP,
	author = {Peter Lammich},
	title = {Refinement for Monadic Programs},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Refine_Monadic.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Automatic_Refinement.html">Automatic_Refinement</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="JinjaThreads.html">JinjaThreads</a>, <a href="Kruskal.html">Kruskal</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Refine_Monadic/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Refine_Monadic/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Refine_Monadic/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Refine_Monadic-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Refine_Monadic-2018-08-16.tar.gz">
	+ afp-Refine_Monadic-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Refine_Monadic-2017-10-10.tar.gz">
	afp-Refine_Monadic-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Refine_Monadic-2016-12-17.tar.gz">
	afp-Refine_Monadic-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Refine_Monadic-2016-02-22.tar.gz">
	afp-Refine_Monadic-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Refine_Monadic-2015-05-27.tar.gz">
	afp-Refine_Monadic-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Refine_Monadic-2014-08-28.tar.gz">
	afp-Refine_Monadic-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Refine_Monadic-2013-12-11.tar.gz">
	afp-Refine_Monadic-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Refine_Monadic-2013-11-17.tar.gz">
	afp-Refine_Monadic-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Refine_Monadic-2013-02-16.tar.gz">
	afp-Refine_Monadic-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Refine_Monadic-2012-05-24.tar.gz">
	afp-Refine_Monadic-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Refine_Monadic-2012-02-10.tar.gz">
	afp-Refine_Monadic-2012-02-10.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/RefinementReactive.html b/web/entries/RefinementReactive.html
	--- a/web/entries/RefinementReactive.html
	+++ b/web/entries/RefinementReactive.html
	@@ -1,217 +1,222 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalization of Refinement Calculus for Reactive Systems - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalization

	of

	<font class="first">R</font>efinement

	<font class="first">C</font>alculus

	for

	<font class="first">R</font>eactive

	<font class="first">S</font>ystems

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalization of Refinement Calculus for Reactive Systems</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Viorel Preoteasa (viorel /dot/ preoteasa /at/ aalto /dot/ fi)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-10-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formalization of refinement calculus for reactive systems.
	Refinement calculus is based on monotonic predicate transformers
	(monotonic functions from sets of post-states to sets of pre-states),
	and it is a powerful formalism for reasoning about imperative programs.
	We model reactive systems as monotonic property transformers
	that transform sets of output infinite sequences into sets of input
	infinite sequences. Within this semantics we can model
	refinement of reactive systems, (unbounded) angelic and
	demonic nondeterminism, sequential composition, and
	other semantic properties. We can model systems that may
	fail for some inputs, and we can model compatibility of systems.
	We can specify systems that have liveness properties using
	linear temporal logic, and we can refine system specifications
	into systems based on symbolic transitions systems, suitable
	for implementations.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{RefinementReactive-AFP,
	author = {Viorel Preoteasa},
	title = {Formalization of Refinement Calculus for Reactive Systems},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/RefinementReactive.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/RefinementReactive/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/RefinementReactive/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/RefinementReactive/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-RefinementReactive-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-RefinementReactive-2018-08-16.tar.gz">
	+ afp-RefinementReactive-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-RefinementReactive-2017-10-10.tar.gz">
	afp-RefinementReactive-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-RefinementReactive-2016-12-17.tar.gz">
	afp-RefinementReactive-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-RefinementReactive-2016-02-22.tar.gz">
	afp-RefinementReactive-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-RefinementReactive-2015-05-27.tar.gz">
	afp-RefinementReactive-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-RefinementReactive-2014-10-08.tar.gz">
	afp-RefinementReactive-2014-10-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Regex_Equivalence.html b/web/entries/Regex_Equivalence.html
	--- a/web/entries/Regex_Equivalence.html
	+++ b/web/entries/Regex_Equivalence.html
	@@ -1,226 +1,231 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Unified Decision Procedures for Regular Expression Equivalence - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">U</font>nified

	<font class="first">D</font>ecision

	<font class="first">P</font>rocedures

	for

	<font class="first">R</font>egular

	<font class="first">E</font>xpression

	<font class="first">E</font>quivalence

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Unified Decision Procedures for Regular Expression Equivalence</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a> and
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-01-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize a unified framework for verified decision procedures for regular
	expression equivalence. Five recently published formalizations of such
	decision procedures (three based on derivatives, two on marked regular
	expressions) can be obtained as instances of the framework. We discover that
	the two approaches based on marked regular expressions, which were previously
	thought to be the same, are different, and one seems to produce uniformly
	smaller automata. The common framework makes it possible to compare the
	performance of the different decision procedures in a meaningful way.
	<a href="http://www21.in.tum.de/~nipkow/pubs/itp14.html">
	The formalization is described in a paper of the same name presented at
	Interactive Theorem Proving 2014</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Regex_Equivalence-AFP,
	author = {Tobias Nipkow and Dmitriy Traytel},
	title = {Unified Decision Procedures for Regular Expression Equivalence},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Regex_Equivalence.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Efficient-Mergesort.html">Efficient-Mergesort</a>, <a href="Regular-Sets.html">Regular-Sets</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Regex_Equivalence/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Regex_Equivalence/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Regex_Equivalence/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Regex_Equivalence-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Regex_Equivalence-2018-08-16.tar.gz">
	+ afp-Regex_Equivalence-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Regex_Equivalence-2017-10-10.tar.gz">
	afp-Regex_Equivalence-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Regex_Equivalence-2016-12-17.tar.gz">
	afp-Regex_Equivalence-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Regex_Equivalence-2016-02-22.tar.gz">
	afp-Regex_Equivalence-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Regex_Equivalence-2015-05-27.tar.gz">
	afp-Regex_Equivalence-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Regex_Equivalence-2014-11-30.tar.gz">
	afp-Regex_Equivalence-2014-11-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Regex_Equivalence-2014-08-28.tar.gz">
	afp-Regex_Equivalence-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Regex_Equivalence-2014-01-30.tar.gz">
	afp-Regex_Equivalence-2014-01-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Regular-Sets.html b/web/entries/Regular-Sets.html
	--- a/web/entries/Regular-Sets.html
	+++ b/web/entries/Regular-Sets.html
	@@ -1,253 +1,258 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Regular Sets and Expressions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>egular

	<font class="first">S</font>ets

	and

	<font class="first">E</font>xpressions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Regular Sets and Expressions</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.in.tum.de/~krauss">Alexander Krauss</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>

	<tr>
	<td class="datahead">
	Contributor:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>


	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-05-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This is a library of constructions on regular expressions and languages. It provides the operations of concatenation, Kleene star and derivative on languages. Regular expressions and their meaning are defined. An executable equivalence checker for regular expressions is verified; it does not need automata but works directly on regular expressions. <i>By mapping regular expressions to binary relations, an automatic and complete proof method for (in)equalities of binary relations over union, concatenation and (reflexive) transitive closure is obtained.</i> <P> Extended regular expressions with complement and intersection are also defined and an equivalence checker is provided.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2011-08-26]: Christian Urban added a theory about derivatives and partial derivatives of regular expressions<br>
	[2012-05-10]: Tobias Nipkow added extended regular expressions<br>
	[2012-05-10]: Tobias Nipkow added equivalence checking with partial derivatives</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Regular-Sets-AFP,
	author = {Alexander Krauss and Tobias Nipkow},
	title = {Regular Sets and Expressions},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Regular-Sets.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a>, <a href="Coinductive_Languages.html">Coinductive_Languages</a>, <a href="Containers.html">Containers</a>, <a href="Finite_Automata_HF.html">Finite_Automata_HF</a>, <a href="Functional-Automata.html">Functional-Automata</a>, <a href="Lambda_Free_KBOs.html">Lambda_Free_KBOs</a>, <a href="List_Update.html">List_Update</a>, <a href="Myhill-Nerode.html">Myhill-Nerode</a>, <a href="Posix-Lexing.html">Posix-Lexing</a>, <a href="Quick_Sort_Cost.html">Quick_Sort_Cost</a>, <a href="Regex_Equivalence.html">Regex_Equivalence</a>, <a href="Transitive-Closure-II.html">Transitive-Closure-II</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Regular-Sets/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Regular-Sets/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Regular-Sets/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Regular-Sets-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Regular-Sets-2018-08-16.tar.gz">
	+ afp-Regular-Sets-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Regular-Sets-2017-10-10.tar.gz">
	afp-Regular-Sets-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Regular-Sets-2016-12-17.tar.gz">
	afp-Regular-Sets-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Regular-Sets-2016-02-22.tar.gz">
	afp-Regular-Sets-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Regular-Sets-2015-05-27.tar.gz">
	afp-Regular-Sets-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Regular-Sets-2014-08-28.tar.gz">
	afp-Regular-Sets-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Regular-Sets-2013-12-11.tar.gz">
	afp-Regular-Sets-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Regular-Sets-2013-11-17.tar.gz">
	afp-Regular-Sets-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Regular-Sets-2013-03-02.tar.gz">
	afp-Regular-Sets-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Regular-Sets-2013-02-16.tar.gz">
	afp-Regular-Sets-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Regular-Sets-2012-05-24.tar.gz">
	afp-Regular-Sets-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Regular-Sets-2011-10-11.tar.gz">
	afp-Regular-Sets-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Regular-Sets-2011-02-11.tar.gz">
	afp-Regular-Sets-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Regular-Sets-2010-07-01.tar.gz">
	afp-Regular-Sets-2010-07-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Regular_Algebras.html b/web/entries/Regular_Algebras.html
	--- a/web/entries/Regular_Algebras.html
	+++ b/web/entries/Regular_Algebras.html
	@@ -1,208 +1,213 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Regular Algebras - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>egular

	<font class="first">A</font>lgebras

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Regular Algebras</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www-users.cs.york.ac.uk/~simonf/">Simon Foster</a> and
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-05-21</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Regular algebras axiomatise the equational theory of regular expressions as induced by
	regular language identity. We use Isabelle/HOL for a detailed systematic study of regular
	algebras given by Boffa, Conway, Kozen and Salomaa. We investigate the relationships between
	these classes, formalise a soundness proof for the smallest class (Salomaa's) and obtain
	completeness of the largest one (Boffa's) relative to a deep result by Krob. In addition
	we provide a large collection of regular identities in the general setting of Boffa's axiom.
	Our regular algebra hierarchy is orthogonal to the Kleene algebra hierarchy in the Archive
	of Formal Proofs; we have not aimed at an integration for pragmatic reasons.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Regular_Algebras-AFP,
	author = {Simon Foster and Georg Struth},
	title = {Regular Algebras},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Regular_Algebras.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Kleene_Algebra.html">Kleene_Algebra</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Regular_Algebras/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Regular_Algebras/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Regular_Algebras/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Regular_Algebras-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Regular_Algebras-2018-08-16.tar.gz">
	+ afp-Regular_Algebras-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Regular_Algebras-2017-10-10.tar.gz">
	afp-Regular_Algebras-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Regular_Algebras-2016-12-17.tar.gz">
	afp-Regular_Algebras-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Regular_Algebras-2016-02-22.tar.gz">
	afp-Regular_Algebras-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Regular_Algebras-2015-05-27.tar.gz">
	afp-Regular_Algebras-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Regular_Algebras-2014-08-28.tar.gz">
	afp-Regular_Algebras-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Regular_Algebras-2014-05-22.tar.gz">
	afp-Regular_Algebras-2014-05-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Relation_Algebra.html b/web/entries/Relation_Algebra.html
	--- a/web/entries/Relation_Algebra.html
	+++ b/web/entries/Relation_Algebra.html
	@@ -1,215 +1,220 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Relation Algebra - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>elation

	<font class="first">A</font>lgebra

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Relation Algebra</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Alasdair Armstrong,
	<a href="https://www-users.cs.york.ac.uk/~simonf/">Simon Foster</a>,
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a> and
	Tjark Weber (tjark /dot/ weber /at/ it /dot/ uu /dot/ se)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-01-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Tarski's algebra of binary relations is formalised along the lines of
	the standard textbooks of Maddux and Schmidt and Ströhlein. This
	includes relation-algebraic concepts such as subidentities, vectors and
	a domain operation as well as various notions associated to functions.
	Relation algebras are also expanded by a reflexive transitive closure
	operation, and they are linked with Kleene algebras and models of binary
	relations and Boolean matrices.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Relation_Algebra-AFP,
	author = {Alasdair Armstrong and Simon Foster and Georg Struth and Tjark Weber},
	title = {Relation Algebra},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Relation_Algebra.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Kleene_Algebra.html">Kleene_Algebra</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Residuated_Lattices.html">Residuated_Lattices</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Relation_Algebra/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Relation_Algebra/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Relation_Algebra/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Relation_Algebra-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Relation_Algebra-2018-08-16.tar.gz">
	+ afp-Relation_Algebra-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Relation_Algebra-2017-10-10.tar.gz">
	afp-Relation_Algebra-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Relation_Algebra-2016-12-17.tar.gz">
	afp-Relation_Algebra-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Relation_Algebra-2016-02-22.tar.gz">
	afp-Relation_Algebra-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Relation_Algebra-2015-05-27.tar.gz">
	afp-Relation_Algebra-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Relation_Algebra-2014-08-28.tar.gz">
	afp-Relation_Algebra-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Relation_Algebra-2014-01-31.tar.gz">
	afp-Relation_Algebra-2014-01-31.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Relation_Algebra-2014-01-25.tar.gz">
	afp-Relation_Algebra-2014-01-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Rep_Fin_Groups.html b/web/entries/Rep_Fin_Groups.html
	--- a/web/entries/Rep_Fin_Groups.html
	+++ b/web/entries/Rep_Fin_Groups.html
	@@ -1,191 +1,196 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Representations of Finite Groups - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>epresentations

	of

	<font class="first">F</font>inite

	<font class="first">G</font>roups

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Representations of Finite Groups</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://ualberta.ca/~jsylvest/">Jeremy Sylvestre</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-08-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We provide a formal framework for the theory of representations of finite groups, as modules over the group ring. Along the way, we develop the general theory of groups (relying on the group_add class for the basics), modules, and vector spaces, to the extent required for theory of group representations. We then provide formal proofs of several important introductory theorems in the subject, including Maschke's theorem, Schur's lemma, and Frobenius reciprocity. We also prove that every irreducible representation is isomorphic to a submodule of the group ring, leading to the fact that for a finite group there are only finitely many isomorphism classes of irreducible representations. In all of this, no restriction is made on the characteristic of the ring or field of scalars until the definition of a group representation, and then the only restriction made is that the characteristic must not divide the order of the group.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Rep_Fin_Groups-AFP,
	author = {Jeremy Sylvestre},
	title = {Representations of Finite Groups},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Rep_Fin_Groups.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Rep_Fin_Groups/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Rep_Fin_Groups/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Rep_Fin_Groups/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Rep_Fin_Groups-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Rep_Fin_Groups-2018-08-16.tar.gz">
	+ afp-Rep_Fin_Groups-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Rep_Fin_Groups-2017-10-10.tar.gz">
	afp-Rep_Fin_Groups-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Rep_Fin_Groups-2016-12-17.tar.gz">
	afp-Rep_Fin_Groups-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Rep_Fin_Groups-2016-02-22.tar.gz">
	afp-Rep_Fin_Groups-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Rep_Fin_Groups-2015-08-12.tar.gz">
	afp-Rep_Fin_Groups-2015-08-12.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Residuated_Lattices.html b/web/entries/Residuated_Lattices.html
	--- a/web/entries/Residuated_Lattices.html
	+++ b/web/entries/Residuated_Lattices.html
	@@ -1,202 +1,207 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Residuated Lattices - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>esiduated

	<font class="first">L</font>attices

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Residuated Lattices</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Victor B. F. Gomes (vb358 /at/ cl /dot/ cam /dot/ ac /dot/ uk) and
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-04-15</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Residuated_Lattices.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Relation_Algebra.html">Relation_Algebra</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Residuated_Lattices/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Residuated_Lattices/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Residuated_Lattices/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Residuated_Lattices-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Residuated_Lattices-2018-08-16.tar.gz">
	+ afp-Residuated_Lattices-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Residuated_Lattices-2017-10-10.tar.gz">
	afp-Residuated_Lattices-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Residuated_Lattices-2016-12-17.tar.gz">
	afp-Residuated_Lattices-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Residuated_Lattices-2016-02-22.tar.gz">
	afp-Residuated_Lattices-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Residuated_Lattices-2015-05-27.tar.gz">
	afp-Residuated_Lattices-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Residuated_Lattices-2015-04-16.tar.gz">
	afp-Residuated_Lattices-2015-04-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Resolution_FOL.html b/web/entries/Resolution_FOL.html
	--- a/web/entries/Resolution_FOL.html
	+++ b/web/entries/Resolution_FOL.html
	@@ -1,231 +1,236 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Resolution Calculus for First-Order Logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">R</font>esolution

	<font class="first">C</font>alculus

	for

	<font class="first">F</font>irst-Order

	<font class="first">L</font>ogic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Resolution Calculus for First-Order Logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Anders Schlichtkrull (andschl /at/ dtu /dot/ dk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This theory is a formalization of the resolution calculus for
	first-order logic. It is proven sound and complete. The soundness
	proof uses the substitution lemma, which shows a correspondence
	between substitutions and updates to an environment. The completeness
	proof uses semantic trees, i.e. trees whose paths are partial Herbrand
	interpretations. It employs Herbrand's theorem in a formulation which
	states that an unsatisfiable set of clauses has a finite closed
	semantic tree. It also uses the lifting lemma which lifts resolution
	derivation steps from the ground world up to the first-order world.
	The theory is presented in a paper in the Journal of Automated Reasoning
	[Sch18] which extends a paper presented at the International Conference
	on Interactive Theorem Proving [Sch16]. An earlier version was
	presented in an MSc thesis [Sch15]. The formalization mostly follows
	textbooks by Ben-Ari [BA12], Chang and Lee [CL73], and Leitsch [Lei97].
	The theory is part of the IsaFoL project [IsaFoL]. <p>
	<a name="Sch18"></a>[Sch18] Anders Schlichtkrull. "Formalization of the
	Resolution Calculus for First-Order Logic". Journal of Automated
	Reasoning, 2018.<br> <a name="Sch16"></a>[Sch16] Anders
	Schlichtkrull. "Formalization of the Resolution Calculus for First-Order
	Logic". In: ITP 2016. Vol. 9807. LNCS. Springer, 2016.<br>
	<a name="Sch15"></a>[Sch15] Anders Schlichtkrull. <a href="https://people.compute.dtu.dk/andschl/Thesis.pdf">
	"Formalization of Resolution Calculus in Isabelle"</a>.
	<a href="https://people.compute.dtu.dk/andschl/Thesis.pdf">https://people.compute.dtu.dk/andschl/Thesis.pdf</a>.
	MSc thesis. Technical University of Denmark, 2015.<br>
	<a name="BA12"></a>[BA12] Mordechai Ben-Ari. <i>Mathematical Logic for
	Computer Science</i>. 3rd. Springer, 2012.<br> <a
	name="CL73"></a>[CL73] Chin-Liang Chang and Richard Char-Tung Lee.
	<i>Symbolic Logic and Mechanical Theorem Proving</i>. 1st. Academic
	Press, Inc., 1973.<br> <a name="Lei97"></a>[Lei97] Alexander
	Leitsch. <i>The Resolution Calculus</i>. Texts in theoretical computer
	science. Springer, 1997.<br> <a name="IsaFoL"></a>[IsaFoL]
	IsaFoL authors. <a href="https://bitbucket.org/jasmin_blanchette/isafol">
	IsaFoL: Isabelle Formalization of Logic</a>.
	<a href="https://bitbucket.org/jasmin_blanchette/isafol">https://bitbucket.org/jasmin_blanchette/isafol</a>.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2018-01-24]: added several new versions of the soundness and completeness theorems as described in the paper [Sch18]. <br>
	[2018-03-20]: added a concrete instance of the unification and completeness theorems using the First-Order Terms AFP-entry from IsaFoR as described in the papers [Sch16] and [Sch18].</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Resolution_FOL-AFP,
	author = {Anders Schlichtkrull},
	title = {The Resolution Calculus for First-Order Logic},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Resolution_FOL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="First_Order_Terms.html">First_Order_Terms</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Resolution_FOL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Resolution_FOL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Resolution_FOL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Resolution_FOL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Resolution_FOL-2018-08-16.tar.gz">
	+ afp-Resolution_FOL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Resolution_FOL-2017-10-10.tar.gz">
	afp-Resolution_FOL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Resolution_FOL-2016-12-17.tar.gz">
	afp-Resolution_FOL-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Resolution_FOL-2016-06-30.tar.gz">
	afp-Resolution_FOL-2016-06-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Rewriting_Z.html b/web/entries/Rewriting_Z.html
	--- a/web/entries/Rewriting_Z.html
	+++ b/web/entries/Rewriting_Z.html
	@@ -1,194 +1,199 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Z Property - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">Z</font>

	<font class="first">P</font>roperty

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Z Property</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Bertram Felgenhauer,
	Julian Nagele,
	Vincent van Oostrom and
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize the Z property introduced by Dehornoy and van Oostrom.
	First we show that for any abstract rewrite system, Z implies
	confluence. Then we give two examples of proofs using Z: confluence of
	lambda-calculus with respect to beta-reduction and confluence of
	combinatory logic.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Rewriting_Z-AFP,
	author = {Bertram Felgenhauer and Julian Nagele and Vincent van Oostrom and Christian Sternagel},
	title = {The Z Property},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Rewriting_Z.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a>, <a href="Nominal2.html">Nominal2</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Rewriting_Z/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Rewriting_Z/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Rewriting_Z/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Rewriting_Z-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Rewriting_Z-2018-08-16.tar.gz">
	+ afp-Rewriting_Z-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Rewriting_Z-2017-10-10.tar.gz">
	afp-Rewriting_Z-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Rewriting_Z-2016-12-17.tar.gz">
	afp-Rewriting_Z-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Rewriting_Z-2016-06-30.tar.gz">
	afp-Rewriting_Z-2016-06-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Ribbon_Proofs.html b/web/entries/Ribbon_Proofs.html
	--- a/web/entries/Ribbon_Proofs.html
	+++ b/web/entries/Ribbon_Proofs.html
	@@ -1,212 +1,217 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Ribbon Proofs - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>ibbon

	<font class="first">P</font>roofs

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Ribbon Proofs</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	John Wickerson
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-01-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document concerns the theory of ribbon proofs: a diagrammatic proof system, based on separation logic, for verifying program correctness. We include the syntax, proof rules, and soundness results for two alternative formalisations of ribbon proofs. <p> Compared to traditional proof outlines, ribbon proofs emphasise the structure of a proof, so are intelligible and pedagogical. Because they contain less redundancy than proof outlines, and allow each proof step to be checked locally, they may be more scalable. Where proof outlines are cumbersome to modify, ribbon proofs can be visually manoeuvred to yield proofs of variant programs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Ribbon_Proofs-AFP,
	author = {John Wickerson},
	title = {Ribbon Proofs},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Ribbon_Proofs.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ribbon_Proofs/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Ribbon_Proofs/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Ribbon_Proofs/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Ribbon_Proofs-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Ribbon_Proofs-2018-08-16.tar.gz">
	+ afp-Ribbon_Proofs-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Ribbon_Proofs-2017-10-10.tar.gz">
	afp-Ribbon_Proofs-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Ribbon_Proofs-2016-12-17.tar.gz">
	afp-Ribbon_Proofs-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Ribbon_Proofs-2016-02-22.tar.gz">
	afp-Ribbon_Proofs-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Ribbon_Proofs-2015-05-27.tar.gz">
	afp-Ribbon_Proofs-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Ribbon_Proofs-2014-08-28.tar.gz">
	afp-Ribbon_Proofs-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Ribbon_Proofs-2013-12-11.tar.gz">
	afp-Ribbon_Proofs-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Ribbon_Proofs-2013-11-17.tar.gz">
	afp-Ribbon_Proofs-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Ribbon_Proofs-2013-03-02.tar.gz">
	afp-Ribbon_Proofs-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Ribbon_Proofs-2013-02-16.tar.gz">
	afp-Ribbon_Proofs-2013-02-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Robbins-Conjecture.html b/web/entries/Robbins-Conjecture.html
	--- a/web/entries/Robbins-Conjecture.html
	+++ b/web/entries/Robbins-Conjecture.html
	@@ -1,242 +1,247 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Complete Proof of the Robbins Conjecture - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">C</font>omplete

	<font class="first">P</font>roof

	of

	the

	<font class="first">R</font>obbins

	<font class="first">C</font>onjecture

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Complete Proof of the Robbins Conjecture</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Matthew Wampler-Doty
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-05-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document gives a formalization of the proof of the Robbins conjecture, following A. Mann, <i>A Complete Proof of the Robbins Conjecture</i>, 2003.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Robbins-Conjecture-AFP,
	author = {Matthew Wampler-Doty},
	title = {A Complete Proof of the Robbins Conjecture},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Robbins-Conjecture.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Robbins-Conjecture/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Robbins-Conjecture/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Robbins-Conjecture/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Robbins-Conjecture-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Robbins-Conjecture-2018-08-16.tar.gz">
	+ afp-Robbins-Conjecture-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Robbins-Conjecture-2017-10-10.tar.gz">
	afp-Robbins-Conjecture-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Robbins-Conjecture-2016-12-17.tar.gz">
	afp-Robbins-Conjecture-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Robbins-Conjecture-2016-02-22.tar.gz">
	afp-Robbins-Conjecture-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Robbins-Conjecture-2015-05-27.tar.gz">
	afp-Robbins-Conjecture-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Robbins-Conjecture-2014-08-28.tar.gz">
	afp-Robbins-Conjecture-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Robbins-Conjecture-2013-12-11.tar.gz">
	afp-Robbins-Conjecture-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Robbins-Conjecture-2013-11-17.tar.gz">
	afp-Robbins-Conjecture-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Robbins-Conjecture-2013-02-16.tar.gz">
	afp-Robbins-Conjecture-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Robbins-Conjecture-2012-05-24.tar.gz">
	afp-Robbins-Conjecture-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Robbins-Conjecture-2011-10-11.tar.gz">
	afp-Robbins-Conjecture-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Robbins-Conjecture-2011-02-11.tar.gz">
	afp-Robbins-Conjecture-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Robbins-Conjecture-2010-07-01.tar.gz">
	afp-Robbins-Conjecture-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Robbins-Conjecture-2010-05-27.tar.gz">
	afp-Robbins-Conjecture-2010-05-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Root_Balanced_Tree.html b/web/entries/Root_Balanced_Tree.html
	--- a/web/entries/Root_Balanced_Tree.html
	+++ b/web/entries/Root_Balanced_Tree.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Root-Balanced Tree - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>oot-Balanced

	<font class="first">T</font>ree

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Root-Balanced Tree</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-08-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	Andersson introduced <em>general balanced trees</em>,
	search trees based on the design principle of partial rebuilding:
	perform update operations naively until the tree becomes too
	unbalanced, at which point a whole subtree is rebalanced. This article
	defines and analyzes a functional version of general balanced trees,
	which we call <em>root-balanced trees</em>. Using a lightweight model
	of execution time, amortized logarithmic complexity is verified in
	the theorem prover Isabelle.
	</p>
	<p>
	This is the Isabelle formalization of the material decribed in the APLAS 2017 article
	<a href="http://www21.in.tum.de/~nipkow/pubs/aplas17.html">Verified Root-Balanced Trees</a>
	by the same author, which also presents experimental results that show
	competitiveness of root-balanced with AVL and red-black trees.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Root_Balanced_Tree-AFP,
	author = {Tobias Nipkow},
	title = {Root-Balanced Tree},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Root_Balanced_Tree.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Amortized_Complexity.html">Amortized_Complexity</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Root_Balanced_Tree/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Root_Balanced_Tree/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Root_Balanced_Tree/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Root_Balanced_Tree-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Root_Balanced_Tree-2018-08-16.tar.gz">
	+ afp-Root_Balanced_Tree-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Root_Balanced_Tree-2017-10-10.tar.gz">
	afp-Root_Balanced_Tree-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Root_Balanced_Tree-2017-08-20.tar.gz">
	afp-Root_Balanced_Tree-2017-08-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Routing.html b/web/entries/Routing.html
	--- a/web/entries/Routing.html
	+++ b/web/entries/Routing.html
	@@ -1,193 +1,198 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Routing - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>outing

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Routing</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://liftm.de">Julius Michaelis</a> and
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-08-31</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry contains definitions for routing with routing
	tables/longest prefix matching. A routing table entry is modelled as
	a record of a prefix match, a metric, an output port, and an optional
	next hop. A routing table is a list of entries, sorted by prefix
	length and metric. Additionally, a parser and serializer for the
	output of the ip-route command, a function to create a relation from
	output port to corresponding destination IP space, and a model of a
	Linux-style router are included.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Routing-AFP,
	author = {Julius Michaelis and Cornelius Diekmann},
	title = {Routing},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Routing.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Simple_Firewall.html">Simple_Firewall</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Iptables_Semantics.html">Iptables_Semantics</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Routing/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Routing/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Routing/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Routing-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Routing-2018-08-16.tar.gz">
	+ afp-Routing-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Routing-2017-10-10.tar.gz">
	afp-Routing-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Routing-2016-12-17.tar.gz">
	afp-Routing-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Routing-2016-08-31.tar.gz">
	afp-Routing-2016-08-31.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Roy_Floyd_Warshall.html b/web/entries/Roy_Floyd_Warshall.html
	--- a/web/entries/Roy_Floyd_Warshall.html
	+++ b/web/entries/Roy_Floyd_Warshall.html
	@@ -1,207 +1,212 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Transitive closure according to Roy-Floyd-Warshall - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>ransitive

	closure

	according

	to

	<font class="first">R</font>oy-Floyd-Warshall

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Transitive closure according to Roy-Floyd-Warshall</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Makarius Wenzel
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-05-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This formulation of the Roy-Floyd-Warshall algorithm for the
	transitive closure bypasses matrices and arrays, but uses a more direct
	mathematical model with adjacency functions for immediate predecessors and
	successors. This can be implemented efficiently in functional programming
	languages and is particularly adequate for sparse relations.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Roy_Floyd_Warshall-AFP,
	author = {Makarius Wenzel},
	title = {Transitive closure according to Roy-Floyd-Warshall},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Roy_Floyd_Warshall.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Roy_Floyd_Warshall/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Roy_Floyd_Warshall/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Roy_Floyd_Warshall/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Roy_Floyd_Warshall-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Roy_Floyd_Warshall-2018-08-16.tar.gz">
	+ afp-Roy_Floyd_Warshall-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Roy_Floyd_Warshall-2017-10-10.tar.gz">
	afp-Roy_Floyd_Warshall-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Roy_Floyd_Warshall-2016-12-17.tar.gz">
	afp-Roy_Floyd_Warshall-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Roy_Floyd_Warshall-2016-02-22.tar.gz">
	afp-Roy_Floyd_Warshall-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Roy_Floyd_Warshall-2015-05-27.tar.gz">
	afp-Roy_Floyd_Warshall-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Roy_Floyd_Warshall-2014-08-28.tar.gz">
	afp-Roy_Floyd_Warshall-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Roy_Floyd_Warshall-2014-05-24.tar.gz">
	afp-Roy_Floyd_Warshall-2014-05-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/SATSolverVerification.html b/web/entries/SATSolverVerification.html
	--- a/web/entries/SATSolverVerification.html
	+++ b/web/entries/SATSolverVerification.html
	@@ -1,255 +1,260 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formal Verification of Modern SAT Solvers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormal

	<font class="first">V</font>erification

	of

	<font class="first">M</font>odern

	<font class="first">S</font>AT

	<font class="first">S</font>olvers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formal Verification of Modern SAT Solvers</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://poincare.matf.bg.ac.rs/~filip/">Filip Maric</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-07-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document contains formal correctness proofs of modern SAT solvers. Following (Krstic et al, 2007) and (Nieuwenhuis et al., 2006), solvers are described using state-transition systems. Several different SAT solver descriptions are given and their partial correctness and termination is proved. These include: <ul> <li> a solver based on classical DPLL procedure (using only a backtrack-search with unit propagation),</li> <li> a very general solver with backjumping and learning (similar to the description given in (Nieuwenhuis et al., 2006)), and</li> <li> a solver with a specific conflict analysis algorithm (similar to the description given in (Krstic et al., 2007)).</li> </ul> Within the SAT solver correctness proofs, a large number of lemmas about propositional logic and CNF formulae are proved. This theory is self-contained and could be used for further exploring of properties of CNF based SAT algorithms.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{SATSolverVerification-AFP,
	author = {Filip Maric},
	title = {Formal Verification of Modern SAT Solvers},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/SATSolverVerification.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SATSolverVerification/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/SATSolverVerification/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SATSolverVerification/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-SATSolverVerification-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-SATSolverVerification-2018-08-16.tar.gz">
	+ afp-SATSolverVerification-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-SATSolverVerification-2017-10-10.tar.gz">
	afp-SATSolverVerification-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-SATSolverVerification-2016-12-17.tar.gz">
	afp-SATSolverVerification-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-SATSolverVerification-2016-02-22.tar.gz">
	afp-SATSolverVerification-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-SATSolverVerification-2015-05-27.tar.gz">
	afp-SATSolverVerification-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-SATSolverVerification-2014-08-28.tar.gz">
	afp-SATSolverVerification-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-SATSolverVerification-2013-12-11.tar.gz">
	afp-SATSolverVerification-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-SATSolverVerification-2013-11-17.tar.gz">
	afp-SATSolverVerification-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-SATSolverVerification-2013-03-02.tar.gz">
	afp-SATSolverVerification-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-SATSolverVerification-2013-02-16.tar.gz">
	afp-SATSolverVerification-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-SATSolverVerification-2012-05-24.tar.gz">
	afp-SATSolverVerification-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-SATSolverVerification-2011-10-11.tar.gz">
	afp-SATSolverVerification-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-SATSolverVerification-2011-02-11.tar.gz">
	afp-SATSolverVerification-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-SATSolverVerification-2010-07-01.tar.gz">
	afp-SATSolverVerification-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-SATSolverVerification-2009-12-12.tar.gz">
	afp-SATSolverVerification-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-SATSolverVerification-2009-04-29.tar.gz">
	afp-SATSolverVerification-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-SATSolverVerification-2008-07-27.tar.gz">
	afp-SATSolverVerification-2008-07-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/SDS_Impossibility.html b/web/entries/SDS_Impossibility.html
	--- a/web/entries/SDS_Impossibility.html
	+++ b/web/entries/SDS_Impossibility.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Incompatibility of SD-Efficiency and SD-Strategy-Proofness - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">I</font>ncompatibility

	of

	<font class="first">S</font>D-Efficiency

	and

	<font class="first">S</font>D-Strategy-Proofness

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Incompatibility of SD-Efficiency and SD-Strategy-Proofness</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-04</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This formalisation contains the proof that there is no anonymous and
	neutral Social Decision Scheme for at least four voters and
	alternatives that fulfils both SD-Efficiency and SD-Strategy-
	Proofness. The proof is a fully structured and quasi-human-redable
	one. It was derived from the (unstructured) SMT proof of the case for
	exactly four voters and alternatives by Brandl et al. Their proof
	relies on an unverified translation of the original problem to SMT,
	and the proof that lifts the argument for exactly four voters and
	alternatives to the general case is also not machine-checked. In this
	Isabelle proof, on the other hand, all of these steps are fully
	proven and machine-checked. This is particularly important seeing as a
	previously published informal proof of a weaker statement contained a
	mistake in precisely this lifting step.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{SDS_Impossibility-AFP,
	author = {Manuel Eberl},
	title = {The Incompatibility of SD-Efficiency and SD-Strategy-Proofness},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/SDS_Impossibility.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Randomised_Social_Choice.html">Randomised_Social_Choice</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SDS_Impossibility/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/SDS_Impossibility/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SDS_Impossibility/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-SDS_Impossibility-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-SDS_Impossibility-2018-08-16.tar.gz">
	+ afp-SDS_Impossibility-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-SDS_Impossibility-2017-10-10.tar.gz">
	afp-SDS_Impossibility-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-SDS_Impossibility-2016-12-17.tar.gz">
	afp-SDS_Impossibility-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-SDS_Impossibility-2016-05-05.tar.gz">
	afp-SDS_Impossibility-2016-05-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/SIFPL.html b/web/entries/SIFPL.html
	--- a/web/entries/SIFPL.html
	+++ b/web/entries/SIFPL.html
	@@ -1,251 +1,256 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Secure information flow and program logics - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>ecure

	information

	flow

	and

	program

	logics

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Secure information flow and program logics</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Lennart Beringer and
	<a href="http://www.tcs.informatik.uni-muenchen.de/~mhofmann">Martin Hofmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-11-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We present interpretations of type systems for secure information flow in Hoare logic, complementing previous encodings in relational program logics. We first treat the imperative language IMP, extended by a simple procedure call mechanism. For this language we consider base-line non-interference in the style of Volpano et al. and the flow-sensitive type system by Hunt and Sands. In both cases, we show how typing derivations may be used to automatically generate proofs in the program logic that certify the absence of illicit flows. We then add instructions for object creation and manipulation, and derive appropriate proof rules for base-line non-interference. As a consequence of our work, standard verification technology may be used for verifying that a concrete program satisfies the non-interference property.<br><br>The present proof development represents an update of the formalisation underlying our paper [CSF 2007] and is intended to resolve any ambiguities that may be present in the paper.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{SIFPL-AFP,
	author = {Lennart Beringer and Martin Hofmann},
	title = {Secure information flow and program logics},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/SIFPL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SIFPL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/SIFPL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SIFPL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-SIFPL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-SIFPL-2018-08-16.tar.gz">
	+ afp-SIFPL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-SIFPL-2017-10-10.tar.gz">
	afp-SIFPL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-SIFPL-2016-12-17.tar.gz">
	afp-SIFPL-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-SIFPL-2016-02-22.tar.gz">
	afp-SIFPL-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-SIFPL-2015-05-27.tar.gz">
	afp-SIFPL-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-SIFPL-2014-08-28.tar.gz">
	afp-SIFPL-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-SIFPL-2013-12-11.tar.gz">
	afp-SIFPL-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-SIFPL-2013-11-17.tar.gz">
	afp-SIFPL-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-SIFPL-2013-02-16.tar.gz">
	afp-SIFPL-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-SIFPL-2012-05-24.tar.gz">
	afp-SIFPL-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-SIFPL-2011-10-11.tar.gz">
	afp-SIFPL-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-SIFPL-2011-02-11.tar.gz">
	afp-SIFPL-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-SIFPL-2010-07-01.tar.gz">
	afp-SIFPL-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-SIFPL-2009-12-12.tar.gz">
	afp-SIFPL-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-SIFPL-2009-04-29.tar.gz">
	afp-SIFPL-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-SIFPL-2008-11-13.tar.gz">
	afp-SIFPL-2008-11-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/SIFUM_Type_Systems.html b/web/entries/SIFUM_Type_Systems.html
	--- a/web/entries/SIFUM_Type_Systems.html
	+++ b/web/entries/SIFUM_Type_Systems.html
	@@ -1,233 +1,238 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Formalization of Assumptions and Guarantees for Compositional Noninterference - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">F</font>ormalization

	of

	<font class="first">A</font>ssumptions

	and

	<font class="first">G</font>uarantees

	for

	<font class="first">C</font>ompositional

	<font class="first">N</font>oninterference

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Formalization of Assumptions and Guarantees for Compositional Noninterference</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Sylvia Grewe (grewe /at/ st /dot/ informatik /dot/ tu-darmstadt /dot/ de),
	Heiko Mantel (mantel /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de) and
	Daniel Schoepe (daniel /at/ schoepe /dot/ org)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-04-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Research in information-flow security aims at developing methods to
	identify undesired information leaks within programs from private
	(high) sources to public (low) sinks. For a concurrent system, it is
	desirable to have compositional analysis methods that allow for
	analyzing each thread independently and that nevertheless guarantee
	that the parallel composition of successfully analyzed threads
	satisfies a global security guarantee. However, such a compositional
	analysis should not be overly pessimistic about what an environment
	might do with shared resources. Otherwise, the analysis will reject
	many intuitively secure programs.
	<p>
	The paper "Assumptions and Guarantees for Compositional
	Noninterference" by Mantel et. al. presents one solution for this problem:
	an approach for compositionally reasoning about non-interference in
	concurrent programs via rely-guarantee-style reasoning. We present an
	Isabelle/HOL formalization of the concepts and proofs of this approach.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{SIFUM_Type_Systems-AFP,
	author = {Sylvia Grewe and Heiko Mantel and Daniel Schoepe},
	title = {A Formalization of Assumptions and Guarantees for Compositional Noninterference},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/SIFUM_Type_Systems.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SIFUM_Type_Systems/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/SIFUM_Type_Systems/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SIFUM_Type_Systems/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-SIFUM_Type_Systems-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-SIFUM_Type_Systems-2018-08-16.tar.gz">
	+ afp-SIFUM_Type_Systems-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-SIFUM_Type_Systems-2017-10-10.tar.gz">
	afp-SIFUM_Type_Systems-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-SIFUM_Type_Systems-2016-12-17.tar.gz">
	afp-SIFUM_Type_Systems-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-SIFUM_Type_Systems-2016-02-22.tar.gz">
	afp-SIFUM_Type_Systems-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-SIFUM_Type_Systems-2015-05-27.tar.gz">
	afp-SIFUM_Type_Systems-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-SIFUM_Type_Systems-2014-08-28.tar.gz">
	afp-SIFUM_Type_Systems-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-SIFUM_Type_Systems-2014-04-25.tar.gz">
	afp-SIFUM_Type_Systems-2014-04-25.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-SIFUM_Type_Systems-2014-04-24.tar.gz">
	afp-SIFUM_Type_Systems-2014-04-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/SPARCv8.html b/web/entries/SPARCv8.html
	--- a/web/entries/SPARCv8.html
	+++ b/web/entries/SPARCv8.html
	@@ -1,222 +1,227 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A formal model for the SPARCv8 ISA and a proof of non-interference for the LEON3 processor - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	formal

	model

	for

	the

	<font class="first">S</font>PARCv8

	<font class="first">I</font>SA

	and

	a

	proof

	of

	non-interference

	for

	the

	<font class="first">L</font>EON3

	processor

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A formal model for the SPARCv8 ISA and a proof of non-interference for the LEON3 processor</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Zhe Hou (zhe /dot/ hou /at/ ntu /dot/ edu /dot/ sg),
	David Sanan (sanan /at/ ntu /dot/ edu /dot/ sg),
	Alwen Tiu (ATiu /at/ ntu /dot/ edu /dot/ sg) and
	Yang Liu (yangliu /at/ ntu /dot/ edu /dot/ sg)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-10-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalise the SPARCv8 instruction set architecture (ISA) which is
	used in processors such as LEON3. Our formalisation can be specialised
	to any SPARCv8 CPU, here we use LEON3 as a running example. Our model
	covers the operational semantics for all the instructions in the
	integer unit of the SPARCv8 architecture and it supports Isabelle code
	export, which effectively turns the Isabelle model into a SPARCv8 CPU
	simulator. We prove the language-based non-interference property for
	the LEON3 processor. Our model is based on deterministic monad, which
	is a modified version of the non-deterministic monad from NICTA/l4v.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{SPARCv8-AFP,
	author = {Zhe Hou and David Sanan and Alwen Tiu and Yang Liu},
	title = {A formal model for the SPARCv8 ISA and a proof of non-interference for the LEON3 processor},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/SPARCv8.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SPARCv8/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/SPARCv8/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SPARCv8/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-SPARCv8-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-SPARCv8-2018-08-16.tar.gz">
	+ afp-SPARCv8-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-SPARCv8-2017-10-10.tar.gz">
	afp-SPARCv8-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-SPARCv8-2016-12-17.tar.gz">
	afp-SPARCv8-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-SPARCv8-2016-10-19.tar.gz">
	afp-SPARCv8-2016-10-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Safe_OCL.html b/web/entries/Safe_OCL.html
	--- a/web/entries/Safe_OCL.html
	+++ b/web/entries/Safe_OCL.html
	@@ -1,187 +1,193 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Safe OCL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>afe

	<font class="first">O</font>CL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Safe OCL</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Denis Nikiforov
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-03-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>The theory is a formalization of the
	<a href="https://www.omg.org/spec/OCL/">OCL</a> type system, its abstract
	syntax and expression typing rules. The theory does not define a concrete
	syntax and a semantics. In contrast to
	<a href="https://www.isa-afp.org/entries/Featherweight_OCL.html">Featherweight OCL</a>,
	it is based on a deep embedding approach. The type system is defined from scratch,
	it is not based on the Isabelle HOL type system.</p>
	<p>The Safe OCL distincts nullable and non-nullable types. Also the theory gives a
	formal definition of <a href="http://ceur-ws.org/Vol-1512/paper07.pdf">safe
	navigation operations</a>. The Safe OCL typing rules are much stricter than rules
	given in the OCL specification. It allows one to catch more errors on a type
	checking phase.</p>
	<p>The type theory presented is four-layered: classes, basic types, generic types,
	errorable types. We introduce the following new types: non-nullable types (T[1]),
	nullable types (T[?]), OclSuper. OclSuper is a supertype of all other types (basic
	types, collections, tuples). This type allows us to define a total supremum function,
	so types form an upper semilattice. It allows us to define rich expression typing
	rules in an elegant manner.</p>
	<p>The Preliminaries Chapter of the theory defines a number of helper lemmas for
	transitive closures and tuples. It defines also a generic object model independent
	from OCL. It allows one to use the theory as a reference for formalization of analogous languages.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Safe_OCL-AFP,
	author = {Denis Nikiforov},
	title = {Safe OCL},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Safe_OCL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Safe_OCL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Safe_OCL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Safe_OCL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Safe_OCL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Safe_OCL-2019-03-14.tar.gz">
	+ afp-Safe_OCL-2019-03-14.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Secondary_Sylow.html b/web/entries/Secondary_Sylow.html
	--- a/web/entries/Secondary_Sylow.html
	+++ b/web/entries/Secondary_Sylow.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Secondary Sylow Theorems - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>econdary

	<font class="first">S</font>ylow

	<font class="first">T</font>heorems

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Secondary Sylow Theorems</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Jakob von Raumer (psxjv4 /at/ nottingham /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-01-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">These theories extend the existing proof of the first Sylow theorem
	(written by Florian Kammueller and L. C. Paulson) by what are often
	called the second, third and fourth Sylow theorems. These theorems
	state propositions about the number of Sylow p-subgroups of a group
	and the fact that they are conjugate to each other. The proofs make
	use of an implementation of group actions and their properties.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Secondary_Sylow-AFP,
	author = {Jakob von Raumer},
	title = {Secondary Sylow Theorems},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Secondary_Sylow.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Jordan_Hoelder.html">Jordan_Hoelder</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Secondary_Sylow/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Secondary_Sylow/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Secondary_Sylow/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Secondary_Sylow-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Secondary_Sylow-2018-08-16.tar.gz">
	+ afp-Secondary_Sylow-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Secondary_Sylow-2017-10-10.tar.gz">
	afp-Secondary_Sylow-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Secondary_Sylow-2016-12-17.tar.gz">
	afp-Secondary_Sylow-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Secondary_Sylow-2016-02-22.tar.gz">
	afp-Secondary_Sylow-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Secondary_Sylow-2015-05-27.tar.gz">
	afp-Secondary_Sylow-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Secondary_Sylow-2014-08-28.tar.gz">
	afp-Secondary_Sylow-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Secondary_Sylow-2014-01-29.tar.gz">
	afp-Secondary_Sylow-2014-01-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Security_Protocol_Refinement.html b/web/entries/Security_Protocol_Refinement.html
	--- a/web/entries/Security_Protocol_Refinement.html
	+++ b/web/entries/Security_Protocol_Refinement.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Developing Security Protocols by Refinement - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">D</font>eveloping

	<font class="first">S</font>ecurity

	<font class="first">P</font>rotocols

	by

	<font class="first">R</font>efinement

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Developing Security Protocols by Refinement</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christoph Sprenger (sprenger /at/ inf /dot/ ethz /dot/ ch) and
	Ivano Somaini
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We propose a development method for security protocols based on
	stepwise refinement. Our refinement strategy transforms abstract
	security goals into protocols that are secure when operating over an
	insecure channel controlled by a Dolev-Yao-style intruder. As
	intermediate levels of abstraction, we employ messageless guard
	protocols and channel protocols communicating over channels with
	security properties. These abstractions provide insights on why
	protocols are secure and foster the development of families of
	protocols sharing common structure and properties. We have implemented
	our method in Isabelle/HOL and used it to develop different entity
	authentication and key establishment protocols, including realistic
	features such as key confirmation, replay caches, and encrypted
	tickets. Our development highlights that guard protocols and channel
	protocols provide fundamental abstractions for bridging the gap
	between security properties and standard protocol descriptions based
	on cryptographic messages. It also shows that our refinement approach
	scales to protocols of nontrivial size and complexity.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Security_Protocol_Refinement-AFP,
	author = {Christoph Sprenger and Ivano Somaini},
	title = {Developing Security Protocols by Refinement},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Security_Protocol_Refinement.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Security_Protocol_Refinement/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Security_Protocol_Refinement/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Security_Protocol_Refinement/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Security_Protocol_Refinement-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Security_Protocol_Refinement-2018-08-16.tar.gz">
	+ afp-Security_Protocol_Refinement-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Security_Protocol_Refinement-2017-10-10.tar.gz">
	afp-Security_Protocol_Refinement-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Security_Protocol_Refinement-2017-05-25.tar.gz">
	afp-Security_Protocol_Refinement-2017-05-25.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Selection_Heap_Sort.html b/web/entries/Selection_Heap_Sort.html
	--- a/web/entries/Selection_Heap_Sort.html
	+++ b/web/entries/Selection_Heap_Sort.html
	@@ -1,226 +1,231 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Verification of Selection and Heap Sort Using Locales - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erification

	of

	<font class="first">S</font>election

	and

	<font class="first">H</font>eap

	<font class="first">S</font>ort

	<font class="first">U</font>sing

	<font class="first">L</font>ocales

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Verification of Selection and Heap Sort Using Locales</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.matf.bg.ac.rs/~danijela">Danijela Petrovic</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-02-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Stepwise program refinement techniques can be used to simplify
	program verification. Programs are better understood since their
	main properties are clearly stated, and verification of rather
	complex algorithms is reduced to proving simple statements
	connecting successive program specifications. Additionally, it is
	easy to analyze similar algorithms and to compare their properties
	within a single formalization. Usually, formal analysis is not done
	in educational setting due to complexity of verification and a lack
	of tools and procedures to make comparison easy. Verification of an
	algorithm should not only give correctness proof, but also better
	understanding of an algorithm. If the verification is based on small
	step program refinement, it can become simple enough to be
	demonstrated within the university-level computer science
	curriculum. In this paper we demonstrate this and give a formal
	analysis of two well known algorithms (Selection Sort and Heap Sort)
	using proof assistant Isabelle/HOL and program refinement
	techniques.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Selection_Heap_Sort-AFP,
	author = {Danijela Petrovic},
	title = {Verification of Selection and Heap Sort Using Locales},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Selection_Heap_Sort.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Selection_Heap_Sort/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Selection_Heap_Sort/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Selection_Heap_Sort/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Selection_Heap_Sort-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Selection_Heap_Sort-2018-08-16.tar.gz">
	+ afp-Selection_Heap_Sort-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Selection_Heap_Sort-2017-10-10.tar.gz">
	afp-Selection_Heap_Sort-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Selection_Heap_Sort-2016-12-17.tar.gz">
	afp-Selection_Heap_Sort-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Selection_Heap_Sort-2016-02-22.tar.gz">
	afp-Selection_Heap_Sort-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Selection_Heap_Sort-2015-05-27.tar.gz">
	afp-Selection_Heap_Sort-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Selection_Heap_Sort-2014-08-28.tar.gz">
	afp-Selection_Heap_Sort-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Selection_Heap_Sort-2014-02-18.tar.gz">
	afp-Selection_Heap_Sort-2014-02-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/SenSocialChoice.html b/web/entries/SenSocialChoice.html
	--- a/web/entries/SenSocialChoice.html
	+++ b/web/entries/SenSocialChoice.html
	@@ -1,257 +1,262 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Some classical results in Social Choice Theory - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>ome

	classical

	results

	in

	<font class="first">S</font>ocial

	<font class="first">C</font>hoice

	<font class="first">T</font>heory

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Some classical results in Social Choice Theory</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-11-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Drawing on Sen's landmark work "Collective Choice and Social Welfare" (1970), this development proves Arrow's General Possibility Theorem, Sen's Liberal Paradox and May's Theorem in a general setting. The goal was to make precise the classical statements and proofs of these results, and to provide a foundation for more recent results such as the Gibbard-Satterthwaite and Duggan-Schwartz theorems.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{SenSocialChoice-AFP,
	author = {Peter Gammie},
	title = {Some classical results in Social Choice Theory},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/SenSocialChoice.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SenSocialChoice/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/SenSocialChoice/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SenSocialChoice/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-SenSocialChoice-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-SenSocialChoice-2018-08-16.tar.gz">
	+ afp-SenSocialChoice-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-SenSocialChoice-2017-10-10.tar.gz">
	afp-SenSocialChoice-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-SenSocialChoice-2016-12-17.tar.gz">
	afp-SenSocialChoice-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-SenSocialChoice-2016-02-22.tar.gz">
	afp-SenSocialChoice-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-SenSocialChoice-2015-05-27.tar.gz">
	afp-SenSocialChoice-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-SenSocialChoice-2014-08-28.tar.gz">
	afp-SenSocialChoice-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-SenSocialChoice-2013-12-11.tar.gz">
	afp-SenSocialChoice-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-SenSocialChoice-2013-11-17.tar.gz">
	afp-SenSocialChoice-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-SenSocialChoice-2013-02-16.tar.gz">
	afp-SenSocialChoice-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-SenSocialChoice-2012-05-24.tar.gz">
	afp-SenSocialChoice-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-SenSocialChoice-2012-03-15.tar.gz">
	afp-SenSocialChoice-2012-03-15.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-SenSocialChoice-2011-10-11.tar.gz">
	afp-SenSocialChoice-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-SenSocialChoice-2011-02-11.tar.gz">
	afp-SenSocialChoice-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-SenSocialChoice-2010-07-01.tar.gz">
	afp-SenSocialChoice-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-SenSocialChoice-2009-12-12.tar.gz">
	afp-SenSocialChoice-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-SenSocialChoice-2009-04-29.tar.gz">
	afp-SenSocialChoice-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-SenSocialChoice-2008-11-17.tar.gz">
	afp-SenSocialChoice-2008-11-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Separata.html b/web/entries/Separata.html
	--- a/web/entries/Separata.html
	+++ b/web/entries/Separata.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Separata: Isabelle tactics for Separation Algebra - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>eparata:

	<font class="first">I</font>sabelle

	tactics

	for

	<font class="first">S</font>eparation

	<font class="first">A</font>lgebra

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Separata: Isabelle tactics for Separation Algebra</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Zhe Hou (zhe /dot/ hou /at/ ntu /dot/ edu /dot/ sg),
	David Sanan (sanan /at/ ntu /dot/ edu /dot/ sg),
	Alwen Tiu (ATiu /at/ ntu /dot/ edu /dot/ sg),
	Rajeev Gore (rajeev /dot/ gore /at/ anu /dot/ edu /dot/ au) and
	Ranald Clouston (ranald /dot/ clouston /at/ cs /dot/ au /dot/ dk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-11-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We bring the labelled sequent calculus $LS_{PASL}$ for propositional
	abstract separation logic to Isabelle. The tactics given here are
	directly applied on an extension of the Separation Algebra in the AFP.
	In addition to the cancellative separation algebra, we further
	consider some useful properties in the heap model of separation logic,
	such as indivisible unit, disjointness, and cross-split. The tactics
	are essentially a proof search procedure for the calculus $LS_{PASL}$.
	We wrap the tactics in an Isabelle method called separata, and give a
	few examples of separation logic formulae which are provable by
	separata.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Separata-AFP,
	author = {Zhe Hou and David Sanan and Alwen Tiu and Rajeev Gore and Ranald Clouston},
	title = {Separata: Isabelle tactics for Separation Algebra},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Separata.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Separation_Algebra.html">Separation_Algebra</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Separata/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Separata/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Separata/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Separata-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Separata-2018-08-16.tar.gz">
	+ afp-Separata-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Separata-2017-10-10.tar.gz">
	afp-Separata-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Separata-2016-12-17.tar.gz">
	afp-Separata-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Separata-2016-11-17.tar.gz">
	afp-Separata-2016-11-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Separation_Algebra.html b/web/entries/Separation_Algebra.html
	--- a/web/entries/Separation_Algebra.html
	+++ b/web/entries/Separation_Algebra.html
	@@ -1,221 +1,226 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Separation Algebra - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>eparation

	<font class="first">A</font>lgebra

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Separation Algebra</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.cse.unsw.edu.au/~kleing/">Gerwin Klein</a>,
	Rafal Kolanski and
	Andrew Boyton (andrew /dot/ boyton /at/ nicta /dot/ com /dot/ au)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-05-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We present a generic type class implementation of separation algebra for Isabelle/HOL as well as lemmas and generic tactics which can be used directly for any instantiation of the type class. <P> The ex directory contains example instantiations that include structures such as a heap or virtual memory. <P> The abstract separation algebra is based upon "Abstract Separation Logic" by Calcagno et al. These theories are also the basis of the ITP 2012 rough diamond "Mechanised Separation Algebra" by the authors. <P> The aim of this work is to support and significantly reduce the effort for future separation logic developments in Isabelle/HOL by factoring out the part of separation logic that can be treated abstractly once and for all. This includes developing typical default rule sets for reasoning as well as automated tactic support for separation logic.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Separation_Algebra-AFP,
	author = {Gerwin Klein and Rafal Kolanski and Andrew Boyton},
	title = {Separation Algebra},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Separation_Algebra.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Hoare_Time.html">Hoare_Time</a>, <a href="Separata.html">Separata</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Separation_Algebra/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Separation_Algebra/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Separation_Algebra/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Separation_Algebra-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Separation_Algebra-2018-08-16.tar.gz">
	+ afp-Separation_Algebra-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Separation_Algebra-2017-10-10.tar.gz">
	afp-Separation_Algebra-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Separation_Algebra-2016-12-17.tar.gz">
	afp-Separation_Algebra-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Separation_Algebra-2016-02-22.tar.gz">
	afp-Separation_Algebra-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Separation_Algebra-2015-05-27.tar.gz">
	afp-Separation_Algebra-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Separation_Algebra-2014-08-28.tar.gz">
	afp-Separation_Algebra-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Separation_Algebra-2013-12-11.tar.gz">
	afp-Separation_Algebra-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Separation_Algebra-2013-11-17.tar.gz">
	afp-Separation_Algebra-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Separation_Algebra-2013-02-16.tar.gz">
	afp-Separation_Algebra-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Separation_Algebra-2012-05-24.tar.gz">
	afp-Separation_Algebra-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Separation_Algebra-2012-05-11.tar.gz">
	afp-Separation_Algebra-2012-05-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Separation_Logic_Imperative_HOL.html b/web/entries/Separation_Logic_Imperative_HOL.html
	--- a/web/entries/Separation_Logic_Imperative_HOL.html
	+++ b/web/entries/Separation_Logic_Imperative_HOL.html
	@@ -1,244 +1,249 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Separation Logic Framework for Imperative HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">S</font>eparation

	<font class="first">L</font>ogic

	<font class="first">F</font>ramework

	for

	<font class="first">I</font>mperative

	<font class="first">H</font>OL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Separation Logic Framework for Imperative HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	Rene Meis (rene /dot/ meis /at/ uni-due /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-11-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.
	<br>
	As we target Imperative HOL, our programs can be translated to
	efficiently executable code in various target languages, including
	ML, OCaml, Haskell, and Scala.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Separation_Logic_Imperative_HOL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Automatic_Refinement.html">Automatic_Refinement</a>, <a href="Collections.html">Collections</a>, <a href="Native_Word.html">Native_Word</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a>, <a href="UpDown_Scheme.html">UpDown_Scheme</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Separation_Logic_Imperative_HOL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Separation_Logic_Imperative_HOL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Separation_Logic_Imperative_HOL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Separation_Logic_Imperative_HOL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Separation_Logic_Imperative_HOL-2018-08-16.tar.gz">
	+ afp-Separation_Logic_Imperative_HOL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2017-10-10.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2016-12-17.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2016-02-22.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2015-05-27.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2014-08-28.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2013-12-11.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2013-11-17.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2013-03-02.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2013-02-16.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Separation_Logic_Imperative_HOL-2012-11-15.tar.gz">
	afp-Separation_Logic_Imperative_HOL-2012-11-15.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/SequentInvertibility.html b/web/entries/SequentInvertibility.html
	--- a/web/entries/SequentInvertibility.html
	+++ b/web/entries/SequentInvertibility.html
	@@ -1,241 +1,246 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Invertibility in Sequent Calculi - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>nvertibility

	in

	<font class="first">S</font>equent

	<font class="first">C</font>alculi

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Invertibility in Sequent Calculi</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Peter Chapman
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-08-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The invertibility of the rules of a sequent calculus is important for guiding proof search and can be used in some formalised proofs of Cut admissibility. We present sufficient conditions for when a rule is invertible with respect to a calculus. We illustrate the conditions with examples. It must be noted we give purely syntactic criteria; no guarantees are given as to the suitability of the rules.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{SequentInvertibility-AFP,
	author = {Peter Chapman},
	title = {Invertibility in Sequent Calculi},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/SequentInvertibility.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SequentInvertibility/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/SequentInvertibility/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SequentInvertibility/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-SequentInvertibility-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-SequentInvertibility-2018-08-16.tar.gz">
	+ afp-SequentInvertibility-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-SequentInvertibility-2017-10-10.tar.gz">
	afp-SequentInvertibility-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-SequentInvertibility-2016-12-17.tar.gz">
	afp-SequentInvertibility-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-SequentInvertibility-2016-02-22.tar.gz">
	afp-SequentInvertibility-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-SequentInvertibility-2015-05-27.tar.gz">
	afp-SequentInvertibility-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-SequentInvertibility-2014-08-28.tar.gz">
	afp-SequentInvertibility-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-SequentInvertibility-2013-12-11.tar.gz">
	afp-SequentInvertibility-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-SequentInvertibility-2013-11-17.tar.gz">
	afp-SequentInvertibility-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-SequentInvertibility-2013-02-16.tar.gz">
	afp-SequentInvertibility-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-SequentInvertibility-2012-05-24.tar.gz">
	afp-SequentInvertibility-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-SequentInvertibility-2011-10-11.tar.gz">
	afp-SequentInvertibility-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-SequentInvertibility-2011-02-11.tar.gz">
	afp-SequentInvertibility-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-SequentInvertibility-2010-07-01.tar.gz">
	afp-SequentInvertibility-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-SequentInvertibility-2009-12-12.tar.gz">
	afp-SequentInvertibility-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-SequentInvertibility-2009-09-01.tar.gz">
	afp-SequentInvertibility-2009-09-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Shivers-CFA.html b/web/entries/Shivers-CFA.html
	--- a/web/entries/Shivers-CFA.html
	+++ b/web/entries/Shivers-CFA.html
	@@ -1,241 +1,246 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Shivers' Control Flow Analysis - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>hivers'

	<font class="first">C</font>ontrol

	<font class="first">F</font>low

	<font class="first">A</font>nalysis

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Shivers' Control Flow Analysis</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Joachim Breitner (joachim /at/ cis /dot/ upenn /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-11-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	In his dissertation, Olin Shivers introduces a concept of control flow graphs
	for functional languages, provides an algorithm to statically derive a safe
	approximation of the control flow graph and proves this algorithm correct. In
	this research project, Shivers' algorithms and proofs are formalized
	in the HOLCF extension of HOL.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Shivers-CFA-AFP,
	author = {Joachim Breitner},
	title = {Shivers' Control Flow Analysis},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Shivers-CFA.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Shivers-CFA/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Shivers-CFA/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Shivers-CFA/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Shivers-CFA-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Shivers-CFA-2018-08-16.tar.gz">
	+ afp-Shivers-CFA-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Shivers-CFA-2017-10-10.tar.gz">
	afp-Shivers-CFA-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Shivers-CFA-2016-12-17.tar.gz">
	afp-Shivers-CFA-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Shivers-CFA-2016-02-22.tar.gz">
	afp-Shivers-CFA-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Shivers-CFA-2015-05-27.tar.gz">
	afp-Shivers-CFA-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Shivers-CFA-2014-08-28.tar.gz">
	afp-Shivers-CFA-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Shivers-CFA-2013-12-11.tar.gz">
	afp-Shivers-CFA-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Shivers-CFA-2013-11-17.tar.gz">
	afp-Shivers-CFA-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Shivers-CFA-2013-02-16.tar.gz">
	afp-Shivers-CFA-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Shivers-CFA-2012-05-24.tar.gz">
	afp-Shivers-CFA-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Shivers-CFA-2011-10-11.tar.gz">
	afp-Shivers-CFA-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Shivers-CFA-2011-02-11.tar.gz">
	afp-Shivers-CFA-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Shivers-CFA-2010-11-18.tar.gz">
	afp-Shivers-CFA-2010-11-18.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Shivers-CFA-2010-11-17.tar.gz">
	afp-Shivers-CFA-2010-11-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/ShortestPath.html b/web/entries/ShortestPath.html
	--- a/web/entries/ShortestPath.html
	+++ b/web/entries/ShortestPath.html
	@@ -1,223 +1,228 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>An Axiomatic Characterization of the Single-Source Shortest Path Problem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>n

	<font class="first">A</font>xiomatic

	<font class="first">C</font>haracterization

	of

	the

	<font class="first">S</font>ingle-Source

	<font class="first">S</font>hortest

	<font class="first">P</font>ath

	<font class="first">P</font>roblem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">An Axiomatic Characterization of the Single-Source Shortest Path Problem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Christine Rizkallah
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-05-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This theory is split into two sections. In the first section, we give a formal proof that a well-known axiomatic characterization of the single-source shortest path problem is correct. Namely, we prove that in a directed graph with a non-negative cost function on the edges the single-source shortest path function is the only function that satisfies a set of four axioms. In the second section, we give a formal proof of the correctness of an axiomatic characterization of the single-source shortest path problem for directed graphs with general cost functions. The axioms here are more involved because we have to account for potential negative cycles in the graph. The axioms are summarized in three Isabelle locales.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{ShortestPath-AFP,
	author = {Christine Rizkallah},
	title = {An Axiomatic Characterization of the Single-Source Shortest Path Problem},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/ShortestPath.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Graph_Theory.html">Graph_Theory</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ShortestPath/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/ShortestPath/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/ShortestPath/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-ShortestPath-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-ShortestPath-2018-08-16.tar.gz">
	+ afp-ShortestPath-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-ShortestPath-2017-10-10.tar.gz">
	afp-ShortestPath-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-ShortestPath-2016-12-17.tar.gz">
	afp-ShortestPath-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-ShortestPath-2016-02-22.tar.gz">
	afp-ShortestPath-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-ShortestPath-2015-05-27.tar.gz">
	afp-ShortestPath-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-ShortestPath-2014-08-28.tar.gz">
	afp-ShortestPath-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-ShortestPath-2013-12-11.tar.gz">
	afp-ShortestPath-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-ShortestPath-2013-11-17.tar.gz">
	afp-ShortestPath-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-ShortestPath-2013-05-30.tar.gz">
	afp-ShortestPath-2013-05-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Show.html b/web/entries/Show.html
	--- a/web/entries/Show.html
	+++ b/web/entries/Show.html
	@@ -1,219 +1,224 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Haskell's Show Class in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">H</font>askell's

	<font class="first">S</font>how

	<font class="first">C</font>lass

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Haskell's Show Class in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-07-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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".</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2015-03-11]: Adapted development to new-style (BNF-based) datatypes.<br>
	[2015-04-10]: Moved development for old-style datatypes into subdirectory
	"Old_Datatype".<br></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@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://isa-afp.org/entries/Show.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Datatype_Order_Generator.html">Datatype_Order_Generator</a>, <a href="Deriving.html">Deriving</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Affine_Arithmetic.html">Affine_Arithmetic</a>, <a href="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a>, <a href="CakeML.html">CakeML</a>, <a href="Certification_Monads.html">Certification_Monads</a>, <a href="Dict_Construction.html">Dict_Construction</a>, <a href="Formula_Derivatives.html">Formula_Derivatives</a>, <a href="Monad_Memo_DP.html">Monad_Memo_DP</a>, <a href="Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a>, <a href="Polynomials.html">Polynomials</a>, <a href="Real_Impl.html">Real_Impl</a>, <a href="XML.html">XML</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Show/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Show/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Show/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Show-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Show-2018-08-16.tar.gz">
	+ afp-Show-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Show-2017-10-10.tar.gz">
	afp-Show-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Show-2016-12-17.tar.gz">
	afp-Show-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Show-2016-02-22.tar.gz">
	afp-Show-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Show-2015-05-27.tar.gz">
	afp-Show-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Show-2014-08-29.tar.gz">
	afp-Show-2014-08-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Show-2014-08-28.tar.gz">
	afp-Show-2014-08-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Signature_Groebner.html b/web/entries/Signature_Groebner.html
	--- a/web/entries/Signature_Groebner.html
	+++ b/web/entries/Signature_Groebner.html
	@@ -1,188 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Signature-Based Gröbner Basis Algorithms - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>ignature-Based

	<font class="first">G</font>röbner

	<font class="first">B</font>asis

	<font class="first">A</font>lgorithms

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Signature-Based Gröbner Basis Algorithms</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-09-20</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>This article formalizes signature-based algorithms for computing
	Gröbner bases. Such algorithms are, in general, superior to
	other algorithms in terms of efficiency, and have not been formalized
	in any proof assistant so far. The present development is both
	generic, in the sense that most known variants of signature-based
	algorithms are covered by it, and effectively executable on concrete
	input thanks to Isabelle's code generator. Sample computations of
	benchmark problems show that the verified implementation of
	signature-based algorithms indeed outperforms the existing
	implementation of Buchberger's algorithm in Isabelle/HOL.</p>
	<p>Besides total correctness of the algorithms, the article also proves
	that under certain conditions they a-priori detect and avoid all
	useless zero-reductions, and always return 'minimal' (in
	some sense) Gröbner bases if an input parameter is chosen in
	the right way.</p><p>The formalization follows the recent survey article by
	Eder and Faugère.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Signature_Groebner-AFP,
	author = {Alexander Maletzky},
	title = {Signature-Based Gröbner Basis Algorithms},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Signature_Groebner.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Groebner_Bases.html">Groebner_Bases</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Signature_Groebner/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Signature_Groebner/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Signature_Groebner/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Signature_Groebner-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Signature_Groebner-2018-09-20.tar.gz">
	+ afp-Signature_Groebner-2018-09-20.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Simpl.html b/web/entries/Simpl.html
	--- a/web/entries/Simpl.html
	+++ b/web/entries/Simpl.html
	@@ -1,274 +1,279 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Sequential Imperative Programming Language Syntax, Semantics, Hoare Logics and Verification Environment - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">S</font>equential

	<font class="first">I</font>mperative

	<font class="first">P</font>rogramming

	<font class="first">L</font>anguage

	<font class="first">S</font>yntax,

	<font class="first">S</font>emantics,

	<font class="first">H</font>oare

	<font class="first">L</font>ogics

	and

	<font class="first">V</font>erification

	<font class="first">E</font>nvironment

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Sequential Imperative Programming Language Syntax, Semantics, Hoare Logics and Verification Environment</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Norbert Schirmer (norbert /dot/ schirmer /at/ web /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-02-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We present the theory of Simpl, a sequential imperative programming language. We introduce its syntax, its semantics (big and small-step operational semantics) and Hoare logics for both partial as well as total correctness. We prove soundness and completeness of the Hoare logic. We integrate and automate the Hoare logic in Isabelle/HOL to obtain a practically usable verification environment for imperative programs. Simpl is independent of a concrete programming language but expressive enough to cover all common language features: mutually recursive procedures, abrupt termination and exceptions, runtime faults, local and global variables, pointers and heap, expressions with side effects, pointers to procedures, partial application and closures, dynamic method invocation and also unbounded nondeterminism.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Simpl-AFP,
	author = {Norbert Schirmer},
	title = {A Sequential Imperative Programming Language Syntax, Semantics, Hoare Logics and Verification Environment},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/Simpl.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="BDD.html">BDD</a>, <a href="Planarity_Certificates.html">Planarity_Certificates</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Simpl/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Simpl/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Simpl/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Simpl-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Simpl-2018-08-16.tar.gz">
	+ afp-Simpl-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Simpl-2017-10-10.tar.gz">
	afp-Simpl-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Simpl-2016-12-17.tar.gz">
	afp-Simpl-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Simpl-2016-02-22.tar.gz">
	afp-Simpl-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Simpl-2015-05-27.tar.gz">
	afp-Simpl-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Simpl-2014-08-28.tar.gz">
	afp-Simpl-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Simpl-2013-12-11.tar.gz">
	afp-Simpl-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Simpl-2013-11-17.tar.gz">
	afp-Simpl-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Simpl-2013-02-16.tar.gz">
	afp-Simpl-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Simpl-2012-05-24.tar.gz">
	afp-Simpl-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Simpl-2011-10-11.tar.gz">
	afp-Simpl-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Simpl-2011-02-11.tar.gz">
	afp-Simpl-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Simpl-2010-07-01.tar.gz">
	afp-Simpl-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Simpl-2009-12-12.tar.gz">
	afp-Simpl-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Simpl-2009-09-12.tar.gz">
	afp-Simpl-2009-09-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Simpl-2009-04-29.tar.gz">
	afp-Simpl-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Simpl-2008-06-10.tar.gz">
	afp-Simpl-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Simpl-2008-03-07.tar.gz">
	afp-Simpl-2008-03-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Simple_Firewall.html b/web/entries/Simple_Firewall.html
	--- a/web/entries/Simple_Firewall.html
	+++ b/web/entries/Simple_Firewall.html
	@@ -1,203 +1,208 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Simple Firewall - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>imple

	<font class="first">F</font>irewall

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Simple Firewall</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>,
	<a href="http://liftm.de">Julius Michaelis</a> and
	<a href="https://home.in.tum.de/~haslbecm">Maximilian Haslbeck</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-08-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a simple model of a firewall. The firewall can accept or
	drop a packet and can match on interfaces, IP addresses, protocol, and
	ports. It was designed to feature nice mathematical properties: The
	type of match expressions was carefully crafted such that the
	conjunction of two match expressions is only one match expression.
	This model is too simplistic to mirror all aspects of the real world.
	In the upcoming entry "Iptables Semantics", we will translate the
	Linux firewall iptables to this model. For a fixed service (e.g. ssh,
	http), we provide an algorithm to compute an overview of the
	firewall's filtering behavior. The algorithm computes minimal service
	matrices, i.e. graphs which partition the complete IPv4 and IPv6
	address space and visualize the allowed accesses between partitions.
	For a detailed description, see
	<a href="http://dl.ifip.org/db/conf/networking/networking2016/1570232858.pdf">Verified iptables Firewall
	Analysis</a>, IFIP Networking 2016.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Simple_Firewall-AFP,
	author = {Cornelius Diekmann and Julius Michaelis and Maximilian Haslbeck},
	title = {Simple Firewall},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Simple_Firewall.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="IP_Addresses.html">IP_Addresses</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Routing.html">Routing</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Simple_Firewall/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Simple_Firewall/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Simple_Firewall/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Simple_Firewall-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Simple_Firewall-2018-08-16.tar.gz">
	+ afp-Simple_Firewall-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Simple_Firewall-2017-10-10.tar.gz">
	afp-Simple_Firewall-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Simple_Firewall-2016-12-17.tar.gz">
	afp-Simple_Firewall-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Simple_Firewall-2016-08-24.tar.gz">
	afp-Simple_Firewall-2016-08-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Simplex.html b/web/entries/Simplex.html
	--- a/web/entries/Simplex.html
	+++ b/web/entries/Simplex.html
	@@ -1,191 +1,197 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>An Incremental Simplex Algorithm with Unsatisfiable Core Generation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>n

	<font class="first">I</font>ncremental

	<font class="first">S</font>implex

	<font class="first">A</font>lgorithm

	with

	<font class="first">U</font>nsatisfiable

	<font class="first">C</font>ore

	<font class="first">G</font>eneration

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">An Incremental Simplex Algorithm with Unsatisfiable Core Generation</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Filip Marić (filip /at/ matf /dot/ bg /dot/ ac /dot/ rs),
	Mirko Spasić (mirko /at/ matf /dot/ bg /dot/ ac /dot/ rs) and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-08-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present an Isabelle/HOL formalization and total correctness proof
	for the incremental version of the Simplex algorithm which is used in
	most state-of-the-art SMT solvers. It supports extraction of
	satisfying assignments, extraction of minimal unsatisfiable cores, incremental
	assertion of constraints and backtracking. The formalization relies on
	stepwise program refinement, starting from a simple specification,
	going through a number of refinement steps, and ending up in a fully
	executable functional implementation. Symmetries present in the
	algorithm are handled with special care.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Simplex-AFP,
	author = {Filip Marić and Mirko Spasić and René Thiemann},
	title = {An Incremental Simplex Algorithm with Unsatisfiable Core Generation},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Simplex.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Farkas.html">Farkas</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Simplex/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Simplex/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Simplex/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Simplex-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Simplex-2018-08-27.tar.gz">
	+ afp-Simplex-2018-08-27.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Skew_Heap.html b/web/entries/Skew_Heap.html
	--- a/web/entries/Skew_Heap.html
	+++ b/web/entries/Skew_Heap.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Skew Heap - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>kew

	<font class="first">H</font>eap

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Skew Heap</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-08-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Skew heaps are an amazingly simple and lightweight implementation of
	priority queues. They were invented by Sleator and Tarjan [SIAM 1986]
	and have logarithmic amortized complexity. This entry provides executable
	and verified functional skew heaps.
	<p>
	The amortized complexity of skew heaps is analyzed in the AFP entry
	<a href="http://isa-afp.org/entries/Amortized_Complexity.html">Amortized Complexity</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Skew_Heap-AFP,
	author = {Tobias Nipkow},
	title = {Skew Heap},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Skew_Heap.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Amortized_Complexity.html">Amortized_Complexity</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Skew_Heap/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Skew_Heap/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Skew_Heap/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Skew_Heap-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Skew_Heap-2018-08-16.tar.gz">
	+ afp-Skew_Heap-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Skew_Heap-2017-10-10.tar.gz">
	afp-Skew_Heap-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Skew_Heap-2016-12-17.tar.gz">
	afp-Skew_Heap-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Skew_Heap-2016-02-22.tar.gz">
	afp-Skew_Heap-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Skew_Heap-2015-05-27.tar.gz">
	afp-Skew_Heap-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Skew_Heap-2014-08-29.tar.gz">
	afp-Skew_Heap-2014-08-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Skew_Heap-2014-08-28.tar.gz">
	afp-Skew_Heap-2014-08-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Slicing.html b/web/entries/Slicing.html
	--- a/web/entries/Slicing.html
	+++ b/web/entries/Slicing.html
	@@ -1,253 +1,258 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Towards Certified Slicing - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>owards

	<font class="first">C</font>ertified

	<font class="first">S</font>licing

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Towards Certified Slicing</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-09-16</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Slicing is a widely-used technique with applications in e.g. compiler technology and software security. Thus verification of algorithms in these areas is often based on the correctness of slicing, which should ideally be proven independent of concrete programming languages and with the help of well-known verifying techniques such as proof assistants. As a first step in this direction, this contribution presents a framework for dynamic and static intraprocedural slicing based on control flow and program dependence graphs. Abstracting from concrete syntax we base the framework on a graph representation of the program fulfilling certain structural and well-formedness properties.<br><br>The formalization consists of the basic framework (in subdirectory Basic/), the correctness proof for dynamic slicing (in subdirectory Dynamic/), the correctness proof for static intraprocedural slicing (in subdirectory StaticIntra/) and instantiations of the framework with a simple While language (in subdirectory While/) and the sophisticated object-oriented bytecode language of Jinja (in subdirectory JinjaVM/). For more information on the framework, see the TPHOLS 2008 paper by Wasserrab and Lochbihler and the PLAS 2009 paper by Wasserrab et al.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Slicing-AFP,
	author = {Daniel Wasserrab},
	title = {Towards Certified Slicing},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/Slicing.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Jinja.html">Jinja</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Formal_SSA.html">Formal_SSA</a>, <a href="InformationFlowSlicing.html">InformationFlowSlicing</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Slicing/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Slicing/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Slicing/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Slicing-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Slicing-2018-08-16.tar.gz">
	+ afp-Slicing-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Slicing-2017-10-10.tar.gz">
	afp-Slicing-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Slicing-2016-12-17.tar.gz">
	afp-Slicing-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Slicing-2016-02-22.tar.gz">
	afp-Slicing-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Slicing-2015-05-27.tar.gz">
	afp-Slicing-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Slicing-2014-08-28.tar.gz">
	afp-Slicing-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Slicing-2013-12-11.tar.gz">
	afp-Slicing-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Slicing-2013-11-17.tar.gz">
	afp-Slicing-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Slicing-2013-02-16.tar.gz">
	afp-Slicing-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Slicing-2012-05-24.tar.gz">
	afp-Slicing-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Slicing-2011-10-11.tar.gz">
	afp-Slicing-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Slicing-2011-02-11.tar.gz">
	afp-Slicing-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Slicing-2010-07-01.tar.gz">
	afp-Slicing-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Slicing-2009-12-12.tar.gz">
	afp-Slicing-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Slicing-2009-04-30.tar.gz">
	afp-Slicing-2009-04-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Slicing-2009-04-29.tar.gz">
	afp-Slicing-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Slicing-2008-09-22.tar.gz">
	afp-Slicing-2008-09-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Smooth_Manifolds.html b/web/entries/Smooth_Manifolds.html
	--- a/web/entries/Smooth_Manifolds.html
	+++ b/web/entries/Smooth_Manifolds.html
	@@ -1,174 +1,180 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Smooth Manifolds - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>mooth

	<font class="first">M</font>anifolds

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Smooth Manifolds</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a> and
	<a href="http://lcs.ios.ac.cn/~bzhan/">Bohua Zhan</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-10-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize the definition and basic properties of smooth manifolds
	in Isabelle/HOL. Concepts covered include partition of unity, tangent
	and cotangent spaces, and the fundamental theorem of path integrals.
	We also examine some concrete manifolds such as spheres and projective
	spaces. The formalization makes extensive use of the analysis and
	linear algebra libraries in Isabelle/HOL, in particular its
	“types-to-sets” mechanism.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Smooth_Manifolds-AFP,
	author = {Fabian Immler and Bohua Zhan},
	title = {Smooth Manifolds},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Smooth_Manifolds.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Smooth_Manifolds/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Smooth_Manifolds/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Smooth_Manifolds/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Smooth_Manifolds-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Smooth_Manifolds-2018-10-23.tar.gz">
	+ afp-Smooth_Manifolds-2018-10-23.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Sort_Encodings.html b/web/entries/Sort_Encodings.html
	--- a/web/entries/Sort_Encodings.html
	+++ b/web/entries/Sort_Encodings.html
	@@ -1,238 +1,243 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Sound and Complete Sort Encodings for First-Order Logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>ound

	and

	<font class="first">C</font>omplete

	<font class="first">S</font>ort

	<font class="first">E</font>ncodings

	for

	<font class="first">F</font>irst-Order

	<font class="first">L</font>ogic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Sound and Complete Sort Encodings for First-Order Logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl) and
	Andrei Popescu (a /dot/ popescu /at/ mdx /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-06-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This is a formalization of the soundness and completeness properties
	for various efficient encodings of sorts in unsorted first-order logic
	used by Isabelle's Sledgehammer tool.
	<p>
	Essentially, the encodings proceed as follows:
	a many-sorted problem is decorated with (as few as possible) tags or
	guards that make the problem monotonic; then sorts can be soundly
	erased.
	<p>
	The development employs a formalization of many-sorted first-order logic
	in clausal form (clauses, structures and the basic properties
	of the satisfaction relation), which could be of interest as the starting
	point for other formalizations of first-order logic metatheory.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Sort_Encodings-AFP,
	author = {Jasmin Christian Blanchette and Andrei Popescu},
	title = {Sound and Complete Sort Encodings for First-Order Logic},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Sort_Encodings.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Sort_Encodings/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Sort_Encodings/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Sort_Encodings/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Sort_Encodings-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Sort_Encodings-2018-08-16.tar.gz">
	+ afp-Sort_Encodings-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Sort_Encodings-2017-10-10.tar.gz">
	afp-Sort_Encodings-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Sort_Encodings-2016-12-17.tar.gz">
	afp-Sort_Encodings-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Sort_Encodings-2016-02-22.tar.gz">
	afp-Sort_Encodings-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Sort_Encodings-2015-05-27.tar.gz">
	afp-Sort_Encodings-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Sort_Encodings-2014-08-28.tar.gz">
	afp-Sort_Encodings-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Sort_Encodings-2013-12-11.tar.gz">
	afp-Sort_Encodings-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Sort_Encodings-2013-11-17.tar.gz">
	afp-Sort_Encodings-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Sort_Encodings-2013-07-04.tar.gz">
	afp-Sort_Encodings-2013-07-04.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Sort_Encodings-2013-07-01.tar.gz">
	afp-Sort_Encodings-2013-07-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Source_Coding_Theorem.html b/web/entries/Source_Coding_Theorem.html
	--- a/web/entries/Source_Coding_Theorem.html
	+++ b/web/entries/Source_Coding_Theorem.html
	@@ -1,189 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Source Coding Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>ource

	<font class="first">C</font>oding

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Source Coding Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Quentin Hibon (qh225 /at/ cl /dot/ cam /dot/ ac /dot/ uk) and
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-10-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This document contains a proof of the necessary condition on the code
	rate of a source code, namely that this code rate is bounded by the
	entropy of the source. This represents one half of Shannon's source
	coding theorem, which is itself an equivalence.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Source_Coding_Theorem-AFP,
	author = {Quentin Hibon and Lawrence C. Paulson},
	title = {Source Coding Theorem},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Source_Coding_Theorem.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Source_Coding_Theorem/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Source_Coding_Theorem/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Source_Coding_Theorem/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Source_Coding_Theorem-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Source_Coding_Theorem-2018-08-16.tar.gz">
	+ afp-Source_Coding_Theorem-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Source_Coding_Theorem-2017-10-10.tar.gz">
	afp-Source_Coding_Theorem-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Source_Coding_Theorem-2016-12-17.tar.gz">
	afp-Source_Coding_Theorem-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Source_Coding_Theorem-2016-10-19.tar.gz">
	afp-Source_Coding_Theorem-2016-10-19.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Special_Function_Bounds.html b/web/entries/Special_Function_Bounds.html
	--- a/web/entries/Special_Function_Bounds.html
	+++ b/web/entries/Special_Function_Bounds.html
	@@ -1,209 +1,214 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Real-Valued Special Functions: Upper and Lower Bounds - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">R</font>eal-Valued

	<font class="first">S</font>pecial

	<font class="first">F</font>unctions:

	<font class="first">U</font>pper

	and

	<font class="first">L</font>ower

	<font class="first">B</font>ounds

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Real-Valued Special Functions: Upper and Lower Bounds</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-08-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This development proves upper and lower bounds for several familiar real-valued functions. For sin, cos, exp and sqrt, it defines and verifies infinite families of upper and lower bounds, mostly based on Taylor series expansions. For arctan, ln and exp, it verifies a finite collection of upper and lower bounds, originally obtained from the functions' continued fraction expansions using the computer algebra system Maple. A common theme in these proofs is to take the difference between a function and its approximation, which should be zero at one point, and then consider the sign of the derivative. The immediate purpose of this development is to verify axioms used by MetiTarski, an automatic theorem prover for real-valued special functions. Crucial to MetiTarski's operation is the provision of upper and lower bounds for each function of interest.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Special_Function_Bounds-AFP,
	author = {Lawrence C. Paulson},
	title = {Real-Valued Special Functions: Upper and Lower Bounds},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Special_Function_Bounds.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Sturm_Sequences.html">Sturm_Sequences</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Special_Function_Bounds/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Special_Function_Bounds/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Special_Function_Bounds/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Special_Function_Bounds-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Special_Function_Bounds-2018-08-16.tar.gz">
	+ afp-Special_Function_Bounds-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Special_Function_Bounds-2017-10-10.tar.gz">
	afp-Special_Function_Bounds-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Special_Function_Bounds-2016-12-17.tar.gz">
	afp-Special_Function_Bounds-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Special_Function_Bounds-2016-02-22.tar.gz">
	afp-Special_Function_Bounds-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Special_Function_Bounds-2015-05-27.tar.gz">
	afp-Special_Function_Bounds-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Special_Function_Bounds-2014-09-05.tar.gz">
	afp-Special_Function_Bounds-2014-09-05.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Special_Function_Bounds-2014-08-29.tar.gz">
	afp-Special_Function_Bounds-2014-08-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Splay_Tree.html b/web/entries/Splay_Tree.html
	--- a/web/entries/Splay_Tree.html
	+++ b/web/entries/Splay_Tree.html
	@@ -1,204 +1,209 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Splay Tree - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>play

	<font class="first">T</font>ree

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Splay Tree</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-08-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Splay trees are self-adjusting binary search trees which were invented by Sleator and Tarjan [JACM 1985].
	This entry provides executable and verified functional splay trees
	as well as the related splay heaps (due to Okasaki).
	<p>
	The amortized complexity of splay trees and heaps is analyzed in the AFP entry
	<a href="http://isa-afp.org/entries/Amortized_Complexity.html">Amortized Complexity</a>.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2016-07-12]: Moved splay heaps here from Amortized_Complexity</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Splay_Tree-AFP,
	author = {Tobias Nipkow},
	title = {Splay Tree},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Splay_Tree.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Amortized_Complexity.html">Amortized_Complexity</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Splay_Tree/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Splay_Tree/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Splay_Tree/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Splay_Tree-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Splay_Tree-2018-08-16.tar.gz">
	+ afp-Splay_Tree-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Splay_Tree-2017-10-10.tar.gz">
	afp-Splay_Tree-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Splay_Tree-2016-12-17.tar.gz">
	afp-Splay_Tree-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Splay_Tree-2016-02-22.tar.gz">
	afp-Splay_Tree-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Splay_Tree-2015-05-27.tar.gz">
	afp-Splay_Tree-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Splay_Tree-2014-08-28.tar.gz">
	afp-Splay_Tree-2014-08-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Sqrt_Babylonian.html b/web/entries/Sqrt_Babylonian.html
	--- a/web/entries/Sqrt_Babylonian.html
	+++ b/web/entries/Sqrt_Babylonian.html
	@@ -1,235 +1,240 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Computing N-th Roots using the Babylonian Method - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">C</font>omputing

	<font class="first">N</font>-th

	<font class="first">R</font>oots

	using

	the

	<font class="first">B</font>abylonian

	<font class="first">M</font>ethod

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Computing N-th Roots using the Babylonian Method</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-01-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We implement the Babylonian method to compute n-th roots of numbers.
	We provide precise algorithms for naturals, integers and rationals, and
	offer an approximation algorithm for square roots over linear ordered fields. Moreover, there
	are precise algorithms to compute the floor and the ceiling of n-th roots.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2013-10-16]: Added algorithms to compute floor and ceiling of sqrt of integers.
	[2014-07-11]: Moved NthRoot_Impl from Real-Impl to this entry.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Sqrt_Babylonian-AFP,
	author = {René Thiemann},
	title = {Computing N-th Roots using the Babylonian Method},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Sqrt_Babylonian.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Cauchy.html">Cauchy</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Polynomial_Factorization.html">Polynomial_Factorization</a>, <a href="Polynomial_Interpolation.html">Polynomial_Interpolation</a>, <a href="QR_Decomposition.html">QR_Decomposition</a>, <a href="Real_Impl.html">Real_Impl</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Sqrt_Babylonian/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Sqrt_Babylonian/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Sqrt_Babylonian/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Sqrt_Babylonian-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Sqrt_Babylonian-2018-08-16.tar.gz">
	+ afp-Sqrt_Babylonian-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Sqrt_Babylonian-2017-10-10.tar.gz">
	afp-Sqrt_Babylonian-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Sqrt_Babylonian-2016-12-17.tar.gz">
	afp-Sqrt_Babylonian-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Sqrt_Babylonian-2016-02-22.tar.gz">
	afp-Sqrt_Babylonian-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Sqrt_Babylonian-2015-05-27.tar.gz">
	afp-Sqrt_Babylonian-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Sqrt_Babylonian-2014-08-28.tar.gz">
	afp-Sqrt_Babylonian-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Sqrt_Babylonian-2013-12-11.tar.gz">
	afp-Sqrt_Babylonian-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Sqrt_Babylonian-2013-11-17.tar.gz">
	afp-Sqrt_Babylonian-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Sqrt_Babylonian-2013-02-16.tar.gz">
	afp-Sqrt_Babylonian-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Sqrt_Babylonian-2013-01-04.tar.gz">
	afp-Sqrt_Babylonian-2013-01-04.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stable_Matching.html b/web/entries/Stable_Matching.html
	--- a/web/entries/Stable_Matching.html
	+++ b/web/entries/Stable_Matching.html
	@@ -1,187 +1,192 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stable Matching - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>table

	<font class="first">M</font>atching

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stable Matching</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-10-24</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We mechanize proofs of several results from the matching with
	contracts literature, which generalize those of the classical
	two-sided matching scenarios that go by the name of stable marriage.
	Our focus is on game theoretic issues. Along the way we develop
	executable algorithms for computing optimal stable matches.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stable_Matching-AFP,
	author = {Peter Gammie},
	title = {Stable Matching},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Stable_Matching.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stable_Matching/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stable_Matching/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stable_Matching/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stable_Matching-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stable_Matching-2018-08-16.tar.gz">
	+ afp-Stable_Matching-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stable_Matching-2017-10-10.tar.gz">
	afp-Stable_Matching-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Stable_Matching-2016-12-17.tar.gz">
	afp-Stable_Matching-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Stable_Matching-2016-10-24.tar.gz">
	afp-Stable_Matching-2016-10-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Statecharts.html b/web/entries/Statecharts.html
	--- a/web/entries/Statecharts.html
	+++ b/web/entries/Statecharts.html
	@@ -1,245 +1,250 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formalizing Statecharts using Hierarchical Automata - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormalizing

	<font class="first">S</font>tatecharts

	using

	<font class="first">H</font>ierarchical

	<font class="first">A</font>utomata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formalizing Statecharts using Hierarchical Automata</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Steffen Helke (helke /at/ cs /dot/ tu-berlin /dot/ de) and
	Florian Kammüller (flokam /at/ cs /dot/ tu-berlin /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2010-08-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalize in Isabelle/HOL the abtract syntax and a synchronous
	step semantics for the specification language Statecharts. The formalization
	is based on Hierarchical Automata which allow a structural decomposition of
	Statecharts into Sequential Automata. To support the composition of
	Statecharts, we introduce calculating operators to construct a Hierarchical
	Automaton in a stepwise manner. Furthermore, we present a complete semantics
	of Statecharts including a theory of data spaces, which enables the modelling
	of racing effects. We also adapt CTL for
	Statecharts to build a bridge for future combinations with model
	checking. However the main motivation of this work is to provide a sound and
	complete basis for reasoning on Statecharts. As a central meta theorem we
	prove that the well-formedness of a Statechart is preserved by the semantics.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Statecharts-AFP,
	author = {Steffen Helke and Florian Kammüller},
	title = {Formalizing Statecharts using Hierarchical Automata},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2010,
	note = {\url{http://isa-afp.org/entries/Statecharts.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Statecharts/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Statecharts/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Statecharts/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Statecharts-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Statecharts-2018-08-16.tar.gz">
	+ afp-Statecharts-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Statecharts-2017-10-10.tar.gz">
	afp-Statecharts-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Statecharts-2016-12-17.tar.gz">
	afp-Statecharts-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Statecharts-2016-02-22.tar.gz">
	afp-Statecharts-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Statecharts-2015-05-27.tar.gz">
	afp-Statecharts-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Statecharts-2014-08-28.tar.gz">
	afp-Statecharts-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Statecharts-2013-12-11.tar.gz">
	afp-Statecharts-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Statecharts-2013-11-17.tar.gz">
	afp-Statecharts-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Statecharts-2013-02-16.tar.gz">
	afp-Statecharts-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Statecharts-2012-05-24.tar.gz">
	afp-Statecharts-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Statecharts-2011-10-11.tar.gz">
	afp-Statecharts-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Statecharts-2011-02-11.tar.gz">
	afp-Statecharts-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Statecharts-2010-08-18.tar.gz">
	afp-Statecharts-2010-08-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stern_Brocot.html b/web/entries/Stern_Brocot.html
	--- a/web/entries/Stern_Brocot.html
	+++ b/web/entries/Stern_Brocot.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Stern-Brocot Tree - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">S</font>tern-Brocot

	<font class="first">T</font>ree

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Stern-Brocot Tree</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a> and
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The Stern-Brocot tree contains all rational numbers exactly once and in their lowest terms. We formalise the Stern-Brocot tree as a coinductive tree using recursive and iterative specifications, which we have proven equivalent, and show that it indeed contains all the numbers as stated. Following Hinze, we prove that the Stern-Brocot tree can be linearised looplessly into Stern's diatonic sequence (also known as Dijkstra's fusc function) and that it is a permutation of the Bird tree.
	</p><p>
	The reasoning stays at an abstract level by appealing to the uniqueness of solutions of guarded recursive equations and lifting algebraic laws point-wise to trees and streams using applicative functors.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stern_Brocot-AFP,
	author = {Peter Gammie and Andreas Lochbihler},
	title = {The Stern-Brocot Tree},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Stern_Brocot.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Applicative_Lifting.html">Applicative_Lifting</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stern_Brocot/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stern_Brocot/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stern_Brocot/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stern_Brocot-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stern_Brocot-2018-08-16.tar.gz">
	+ afp-Stern_Brocot-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stern_Brocot-2017-10-10.tar.gz">
	afp-Stern_Brocot-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Stern_Brocot-2016-12-17.tar.gz">
	afp-Stern_Brocot-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Stern_Brocot-2016-02-22.tar.gz">
	afp-Stern_Brocot-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Stern_Brocot-2015-12-22.tar.gz">
	afp-Stern_Brocot-2015-12-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stewart_Apollonius.html b/web/entries/Stewart_Apollonius.html
	--- a/web/entries/Stewart_Apollonius.html
	+++ b/web/entries/Stewart_Apollonius.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stewart's Theorem and Apollonius' Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tewart's

	<font class="first">T</font>heorem

	and

	<font class="first">A</font>pollonius'

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stewart's Theorem and Apollonius' Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-07-31</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry formalizes the two geometric theorems, Stewart's and
	Apollonius' theorem. Stewart's Theorem relates the length of
	a triangle's cevian to the lengths of the triangle's two
	sides. Apollonius' Theorem is a specialisation of Stewart's
	theorem, restricting the cevian to be the median. The proof applies
	the law of cosines, some basic geometric facts about triangles and
	then simply transforms the terms algebraically to yield the
	conjectured relation. The formalization in Isabelle can closely follow
	the informal proofs described in the Wikipedia articles of those two
	theorems.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stewart_Apollonius-AFP,
	author = {Lukas Bulwahn},
	title = {Stewart's Theorem and Apollonius' Theorem},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Stewart_Apollonius.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Triangle.html">Triangle</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stewart_Apollonius/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stewart_Apollonius/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stewart_Apollonius/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stewart_Apollonius-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stewart_Apollonius-2018-08-16.tar.gz">
	+ afp-Stewart_Apollonius-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stewart_Apollonius-2017-10-10.tar.gz">
	afp-Stewart_Apollonius-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Stewart_Apollonius-2017-08-01.tar.gz">
	afp-Stewart_Apollonius-2017-08-01.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stirling_Formula.html b/web/entries/Stirling_Formula.html
	--- a/web/entries/Stirling_Formula.html
	+++ b/web/entries/Stirling_Formula.html
	@@ -1,189 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stirling's formula - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tirling's

	formula

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stirling's formula</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-09-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This work contains a proof of Stirling's formula both for the
	factorial n! &sim; √<span style="text-decoration:
	overline">2πn</span> (n/e)<sup>n</sup> on natural numbers and the
	real Gamma function Γ(x) &sim; √<span
	style="text-decoration: overline">2π/x</span> (x/e)<sup>x</sup>.
	The proof is based on work by <a
	href="http://www.maths.lancs.ac.uk/~jameson/stirlgamma.pdf">Graham
	Jameson</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stirling_Formula-AFP,
	author = {Manuel Eberl},
	title = {Stirling's formula},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Stirling_Formula.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Bernoulli.html">Bernoulli</a>, <a href="Landau_Symbols.html">Landau_Symbols</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Comparison_Sort_Lower_Bound.html">Comparison_Sort_Lower_Bound</a>, <a href="Prime_Number_Theorem.html">Prime_Number_Theorem</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stirling_Formula/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stirling_Formula/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stirling_Formula/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stirling_Formula-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stirling_Formula-2018-08-16.tar.gz">
	+ afp-Stirling_Formula-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stirling_Formula-2017-10-10.tar.gz">
	afp-Stirling_Formula-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Stirling_Formula-2016-12-17.tar.gz">
	afp-Stirling_Formula-2016-12-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stochastic_Matrices.html b/web/entries/Stochastic_Matrices.html
	--- a/web/entries/Stochastic_Matrices.html
	+++ b/web/entries/Stochastic_Matrices.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stochastic Matrices and the Perron-Frobenius Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tochastic

	<font class="first">M</font>atrices

	and

	the

	<font class="first">P</font>erron-Frobenius

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stochastic Matrices and the Perron-Frobenius Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-11-22</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Stochastic matrices are a convenient way to model discrete-time and
	finite state Markov chains. The Perron–Frobenius theorem
	tells us something about the existence and uniqueness of non-negative
	eigenvectors of a stochastic matrix. In this entry, we formalize
	stochastic matrices, link the formalization to the existing AFP-entry
	on Markov chains, and apply the Perron–Frobenius theorem to
	prove that stationary distributions always exist, and they are unique
	if the stochastic matrix is irreducible.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stochastic_Matrices-AFP,
	author = {René Thiemann},
	title = {Stochastic Matrices and the Perron-Frobenius Theorem},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Stochastic_Matrices.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a>, <a href="Markov_Models.html">Markov_Models</a>, <a href="Perron_Frobenius.html">Perron_Frobenius</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stochastic_Matrices/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stochastic_Matrices/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stochastic_Matrices/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stochastic_Matrices-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stochastic_Matrices-2018-08-16.tar.gz">
	+ afp-Stochastic_Matrices-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stochastic_Matrices-2017-11-23.tar.gz">
	afp-Stochastic_Matrices-2017-11-23.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stone_Algebras.html b/web/entries/Stone_Algebras.html
	--- a/web/entries/Stone_Algebras.html
	+++ b/web/entries/Stone_Algebras.html
	@@ -1,192 +1,197 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stone Algebras - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tone

	<font class="first">A</font>lgebras

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stone Algebras</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-09-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	A range of algebras between lattices and Boolean algebras generalise
	the notion of a complement. We develop a hierarchy of these
	pseudo-complemented algebras that includes Stone algebras.
	Independently of this theory we study filters based on partial orders.
	Both theories are combined to prove Chen and Grätzer's construction
	theorem for Stone algebras. The latter involves extensive reasoning
	about algebraic structures in addition to reasoning in algebraic
	structures.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stone_Algebras-AFP,
	author = {Walter Guttmann},
	title = {Stone Algebras},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Stone_Algebras.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Stone_Relation_Algebras.html">Stone_Relation_Algebras</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stone_Algebras/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stone_Algebras/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stone_Algebras/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stone_Algebras-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stone_Algebras-2018-08-16.tar.gz">
	+ afp-Stone_Algebras-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stone_Algebras-2017-10-10.tar.gz">
	afp-Stone_Algebras-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Stone_Algebras-2016-12-17.tar.gz">
	afp-Stone_Algebras-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Stone_Algebras-2016-09-06.tar.gz">
	afp-Stone_Algebras-2016-09-06.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stone_Kleene_Relation_Algebras.html b/web/entries/Stone_Kleene_Relation_Algebras.html
	--- a/web/entries/Stone_Kleene_Relation_Algebras.html
	+++ b/web/entries/Stone_Kleene_Relation_Algebras.html
	@@ -1,187 +1,192 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stone-Kleene Relation Algebras - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tone-Kleene

	<font class="first">R</font>elation

	<font class="first">A</font>lgebras

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stone-Kleene Relation Algebras</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-07-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We develop Stone-Kleene relation algebras, which expand Stone relation
	algebras with a Kleene star operation to describe reachability in
	weighted graphs. Many properties of the Kleene star arise as a special
	case of a more general theory of iteration based on Conway semirings
	extended by simulation axioms. This includes several theorems
	representing complex program transformations. We formally prove the
	correctness of Conway's automata-based construction of the Kleene
	star of a matrix. We prove numerous results useful for reasoning about
	weighted graphs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stone_Kleene_Relation_Algebras-AFP,
	author = {Walter Guttmann},
	title = {Stone-Kleene Relation Algebras},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Stone_Kleene_Relation_Algebras.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Stone_Relation_Algebras.html">Stone_Relation_Algebras</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Aggregation_Algebras.html">Aggregation_Algebras</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stone_Kleene_Relation_Algebras/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stone_Kleene_Relation_Algebras/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stone_Kleene_Relation_Algebras/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stone_Kleene_Relation_Algebras-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stone_Kleene_Relation_Algebras-2018-08-16.tar.gz">
	+ afp-Stone_Kleene_Relation_Algebras-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stone_Kleene_Relation_Algebras-2017-10-10.tar.gz">
	afp-Stone_Kleene_Relation_Algebras-2017-10-10.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stone_Relation_Algebras.html b/web/entries/Stone_Relation_Algebras.html
	--- a/web/entries/Stone_Relation_Algebras.html
	+++ b/web/entries/Stone_Relation_Algebras.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stone Relation Algebras - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tone

	<font class="first">R</font>elation

	<font class="first">A</font>lgebras

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stone Relation Algebras</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-02-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We develop Stone relation algebras, which generalise relation algebras
	by replacing the underlying Boolean algebra structure with a Stone
	algebra. We show that finite matrices over extended real numbers form
	an instance. As a consequence, relation-algebraic concepts and methods
	can be used for reasoning about weighted graphs. We also develop a
	fixpoint calculus and apply it to compare different definitions of
	reflexive-transitive closures in semirings.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stone_Relation_Algebras-AFP,
	author = {Walter Guttmann},
	title = {Stone Relation Algebras},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Stone_Relation_Algebras.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Stone_Algebras.html">Stone_Algebras</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Stone_Kleene_Relation_Algebras.html">Stone_Kleene_Relation_Algebras</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stone_Relation_Algebras/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stone_Relation_Algebras/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stone_Relation_Algebras/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stone_Relation_Algebras-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stone_Relation_Algebras-2018-08-16.tar.gz">
	+ afp-Stone_Relation_Algebras-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stone_Relation_Algebras-2017-10-10.tar.gz">
	afp-Stone_Relation_Algebras-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Stone_Relation_Algebras-2017-02-09.tar.gz">
	afp-Stone_Relation_Algebras-2017-02-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Store_Buffer_Reduction.html b/web/entries/Store_Buffer_Reduction.html
	--- a/web/entries/Store_Buffer_Reduction.html
	+++ b/web/entries/Store_Buffer_Reduction.html
	@@ -1,199 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Reduction Theorem for Store Buffers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">R</font>eduction

	<font class="first">T</font>heorem

	for

	<font class="first">S</font>tore

	<font class="first">B</font>uffers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Reduction Theorem for Store Buffers</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Ernie Cohen (ecohen /at/ amazon /dot/ com) and
	Norbert Schirmer (norbert /dot/ schirmer /at/ web /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-01-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	When verifying a concurrent program, it is usual to assume that memory
	is sequentially consistent. However, most modern multiprocessors
	depend on store buffering for efficiency, and provide native
	sequential consistency only at a substantial performance penalty. To
	regain sequential consistency, a programmer has to follow an
	appropriate programming discipline. However, naïve disciplines,
	such as protecting all shared accesses with locks, are not flexible
	enough for building high-performance multiprocessor software. We
	present a new discipline for concurrent programming under TSO (total
	store order, with store buffer forwarding). It does not depend on
	concurrency primitives, such as locks. Instead, threads use ghost
	operations to acquire and release ownership of memory addresses. A
	thread can write to an address only if no other thread owns it, and
	can read from an address only if it owns it or it is shared and the
	thread has flushed its store buffer since it last wrote to an address
	it did not own. This discipline covers both coarse-grained concurrency
	(where data is protected by locks) as well as fine-grained concurrency
	(where atomic operations race to memory). We formalize this
	discipline in Isabelle/HOL, and prove that if every execution of a
	program in a system without store buffers follows the discipline, then
	every execution of the program with store buffers is sequentially
	consistent. Thus, we can show sequential consistency under TSO by
	ordinary assertional reasoning about the program, without having to
	consider store buffers at all.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Store_Buffer_Reduction-AFP,
	author = {Ernie Cohen and Norbert Schirmer},
	title = {A Reduction Theorem for Store Buffers},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Store_Buffer_Reduction.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Store_Buffer_Reduction/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Store_Buffer_Reduction/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Store_Buffer_Reduction/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Store_Buffer_Reduction-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Store_Buffer_Reduction-2019-01-11.tar.gz">
	+ afp-Store_Buffer_Reduction-2019-01-11.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stream-Fusion.html b/web/entries/Stream-Fusion.html
	--- a/web/entries/Stream-Fusion.html
	+++ b/web/entries/Stream-Fusion.html
	@@ -1,242 +1,247 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stream Fusion - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tream

	<font class="first">F</font>usion

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stream Fusion</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Brian Huffman
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-04-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Stream Fusion is a system for removing intermediate list structures from Haskell programs; it consists of a Haskell library along with several compiler rewrite rules. (The library is available <a href="http://hackage.haskell.org/package/stream-fusion">online</a>.)<br><br>These theories contain a formalization of much of the Stream Fusion library in HOLCF. Lazy list and stream types are defined, along with coercions between the two types, as well as an equivalence relation for streams that generate the same list. List and stream versions of map, filter, foldr, enumFromTo, append, zipWith, and concatMap are defined, and the stream versions are shown to respect stream equivalence.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stream-Fusion-AFP,
	author = {Brian Huffman},
	title = {Stream Fusion},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/Stream-Fusion.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stream-Fusion/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stream-Fusion/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stream-Fusion/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stream-Fusion-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stream-Fusion-2018-08-16.tar.gz">
	+ afp-Stream-Fusion-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stream-Fusion-2017-10-10.tar.gz">
	afp-Stream-Fusion-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Stream-Fusion-2016-12-17.tar.gz">
	afp-Stream-Fusion-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Stream-Fusion-2016-02-22.tar.gz">
	afp-Stream-Fusion-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Stream-Fusion-2015-05-27.tar.gz">
	afp-Stream-Fusion-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Stream-Fusion-2014-08-28.tar.gz">
	afp-Stream-Fusion-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Stream-Fusion-2013-12-11.tar.gz">
	afp-Stream-Fusion-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Stream-Fusion-2013-11-17.tar.gz">
	afp-Stream-Fusion-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Stream-Fusion-2013-02-16.tar.gz">
	afp-Stream-Fusion-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Stream-Fusion-2012-05-24.tar.gz">
	afp-Stream-Fusion-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Stream-Fusion-2011-10-11.tar.gz">
	afp-Stream-Fusion-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Stream-Fusion-2011-02-11.tar.gz">
	afp-Stream-Fusion-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Stream-Fusion-2010-07-01.tar.gz">
	afp-Stream-Fusion-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Stream-Fusion-2009-12-12.tar.gz">
	afp-Stream-Fusion-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Stream-Fusion-2009-05-13.tar.gz">
	afp-Stream-Fusion-2009-05-13.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Stream-Fusion-2009-05-11.tar.gz">
	afp-Stream-Fusion-2009-05-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stream_Fusion_Code.html b/web/entries/Stream_Fusion_Code.html
	--- a/web/entries/Stream_Fusion_Code.html
	+++ b/web/entries/Stream_Fusion_Code.html
	@@ -1,210 +1,215 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stream Fusion in HOL with Code Generation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tream

	<font class="first">F</font>usion

	in

	<font class="first">H</font>OL

	with

	<font class="first">C</font>ode

	<font class="first">G</font>eneration

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stream Fusion in HOL with Code Generation</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a> and
	Alexandra Maximova (amaximov /at/ student /dot/ ethz /dot/ ch)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-10-10</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Stream Fusion is a system for removing intermediate list data structures from functional programs, in particular Haskell. This entry adapts stream fusion to Isabelle/HOL and its code generator. We define stream types for finite and possibly infinite lists and stream versions for most of the fusible list functions in the theories List and Coinductive_List, and prove them correct with respect to the conversion functions between lists and streams. The Stream Fusion transformation itself is implemented as a simproc in the preprocessor of the code generator. [Brian Huffman's <a href="http://isa-afp.org/entries/Stream-Fusion.html">AFP entry</a> formalises stream fusion in HOLCF for the domain of lazy lists to prove the GHC compiler rewrite rules correct. In contrast, this work enables Isabelle's code generator to perform stream fusion itself. To that end, it covers both finite and coinductive lists from the HOL library and the Coinductive entry. The fusible list functions require specification and proof principles different from Huffman's.]</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stream_Fusion_Code-AFP,
	author = {Andreas Lochbihler and Alexandra Maximova},
	title = {Stream Fusion in HOL with Code Generation},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Stream_Fusion_Code.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stream_Fusion_Code/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stream_Fusion_Code/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stream_Fusion_Code/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stream_Fusion_Code-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stream_Fusion_Code-2018-08-16.tar.gz">
	+ afp-Stream_Fusion_Code-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stream_Fusion_Code-2017-10-10.tar.gz">
	afp-Stream_Fusion_Code-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Stream_Fusion_Code-2016-12-17.tar.gz">
	afp-Stream_Fusion_Code-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Stream_Fusion_Code-2016-02-22.tar.gz">
	afp-Stream_Fusion_Code-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Stream_Fusion_Code-2015-05-27.tar.gz">
	afp-Stream_Fusion_Code-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Stream_Fusion_Code-2014-10-13.tar.gz">
	afp-Stream_Fusion_Code-2014-10-13.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Stream_Fusion_Code-2014-10-10.tar.gz">
	afp-Stream_Fusion_Code-2014-10-10.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Strong_Security.html b/web/entries/Strong_Security.html
	--- a/web/entries/Strong_Security.html
	+++ b/web/entries/Strong_Security.html
	@@ -1,227 +1,232 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Formalization of Strong Security - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">F</font>ormalization

	of

	<font class="first">S</font>trong

	<font class="first">S</font>ecurity

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Formalization of Strong Security</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Sylvia Grewe (grewe /at/ st /dot/ informatik /dot/ tu-darmstadt /dot/ de),
	Alexander Lux (lux /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de),
	Heiko Mantel (mantel /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de) and
	Jens Sauer (sauer /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-04-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Research in information-flow security aims at developing methods to
	identify undesired information leaks within programs from private
	sources to public sinks. Noninterference captures this
	intuition. Strong security from Sabelfeld and Sands
	formalizes noninterference for concurrent systems.
	<p>
	We present an Isabelle/HOL formalization of strong security for
	arbitrary security lattices (Sabelfeld and Sands use
	a two-element security lattice in the original publication).
	The formalization includes
	compositionality proofs for strong security and a soundness proof
	for a security type system that checks strong security for programs
	in a simple while language with dynamic thread creation.
	<p>
	Our formalization of the security type system is abstract in the
	language for expressions and in the semantic side conditions for
	expressions. It can easily be instantiated with different syntactic
	approximations for these side conditions. The soundness proof of
	such an instantiation boils down to showing that these syntactic
	approximations imply the semantic side conditions.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Strong_Security-AFP,
	author = {Sylvia Grewe and Alexander Lux and Heiko Mantel and Jens Sauer},
	title = {A Formalization of Strong Security},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Strong_Security.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="WHATandWHERE_Security.html">WHATandWHERE_Security</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Strong_Security/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Strong_Security/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Strong_Security/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Strong_Security-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Strong_Security-2018-08-16.tar.gz">
	+ afp-Strong_Security-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Strong_Security-2017-10-10.tar.gz">
	afp-Strong_Security-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Strong_Security-2016-12-17.tar.gz">
	afp-Strong_Security-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Strong_Security-2016-02-22.tar.gz">
	afp-Strong_Security-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Strong_Security-2015-05-27.tar.gz">
	afp-Strong_Security-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Strong_Security-2014-08-28.tar.gz">
	afp-Strong_Security-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Strong_Security-2014-04-24.tar.gz">
	afp-Strong_Security-2014-04-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Sturm_Sequences.html b/web/entries/Sturm_Sequences.html
	--- a/web/entries/Sturm_Sequences.html
	+++ b/web/entries/Sturm_Sequences.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Sturm's Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>turm's

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Sturm's Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-01-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Sturm's Theorem states that polynomial sequences with certain
	properties, so-called Sturm sequences, can be used to count the number
	of real roots of a real polynomial. This work contains a proof of
	Sturm's Theorem and code for constructing Sturm sequences efficiently.
	It also provides the “sturm” proof method, which can decide certain
	statements about the roots of real polynomials, such as “the polynomial
	P has exactly n roots in the interval I” or “P(x) > Q(x) for all x
	∈ ℝ”.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Sturm_Sequences-AFP,
	author = {Manuel Eberl},
	title = {Sturm's Theorem},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Sturm_Sequences.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Algebraic_Numbers.html">Algebraic_Numbers</a>, <a href="Perron_Frobenius.html">Perron_Frobenius</a>, <a href="Special_Function_Bounds.html">Special_Function_Bounds</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Sturm_Sequences/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Sturm_Sequences/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Sturm_Sequences/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Sturm_Sequences-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Sturm_Sequences-2018-08-16.tar.gz">
	+ afp-Sturm_Sequences-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Sturm_Sequences-2017-10-10.tar.gz">
	afp-Sturm_Sequences-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Sturm_Sequences-2016-12-17.tar.gz">
	afp-Sturm_Sequences-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Sturm_Sequences-2016-02-22.tar.gz">
	afp-Sturm_Sequences-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Sturm_Sequences-2015-05-27.tar.gz">
	afp-Sturm_Sequences-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Sturm_Sequences-2014-08-28.tar.gz">
	afp-Sturm_Sequences-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Sturm_Sequences-2014-01-12.tar.gz">
	afp-Sturm_Sequences-2014-01-12.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Sturm_Tarski.html b/web/entries/Sturm_Tarski.html
	--- a/web/entries/Sturm_Tarski.html
	+++ b/web/entries/Sturm_Tarski.html
	@@ -1,201 +1,206 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Sturm-Tarski Theorem - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">S</font>turm-Tarski

	<font class="first">T</font>heorem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Sturm-Tarski Theorem</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-09-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We have formalized the Sturm-Tarski theorem (also referred as the Tarski theorem), which generalizes Sturm's theorem. Sturm's theorem is usually used as a way to count distinct real roots, while the Sturm-Tarksi theorem forms the basis for Tarski's classic quantifier elimination for real closed field.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Sturm_Tarski-AFP,
	author = {Wenda Li},
	title = {The Sturm-Tarski Theorem},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/Sturm_Tarski.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Budan_Fourier.html">Budan_Fourier</a>, <a href="Count_Complex_Roots.html">Count_Complex_Roots</a>, <a href="Winding_Number_Eval.html">Winding_Number_Eval</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Sturm_Tarski/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Sturm_Tarski/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Sturm_Tarski/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Sturm_Tarski-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Sturm_Tarski-2018-08-16.tar.gz">
	+ afp-Sturm_Tarski-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Sturm_Tarski-2017-10-10.tar.gz">
	afp-Sturm_Tarski-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Sturm_Tarski-2016-12-17.tar.gz">
	afp-Sturm_Tarski-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Sturm_Tarski-2016-02-22.tar.gz">
	afp-Sturm_Tarski-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Sturm_Tarski-2015-05-27.tar.gz">
	afp-Sturm_Tarski-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Sturm_Tarski-2014-12-05.tar.gz">
	afp-Sturm_Tarski-2014-12-05.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Sturm_Tarski-2014-09-20.tar.gz">
	afp-Sturm_Tarski-2014-09-20.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Stuttering_Equivalence.html b/web/entries/Stuttering_Equivalence.html
	--- a/web/entries/Stuttering_Equivalence.html
	+++ b/web/entries/Stuttering_Equivalence.html
	@@ -1,230 +1,235 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Stuttering Equivalence - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>tuttering

	<font class="first">E</font>quivalence

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Stuttering Equivalence</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.loria.fr/~merz">Stephan Merz</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-05-07</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract"><p>Two omega-sequences are stuttering equivalent if they differ only by finite repetitions of elements. Stuttering equivalence is a fundamental concept in the theory of concurrent and distributed systems. Notably, Lamport argues that refinement notions for such systems should be insensitive to finite stuttering. Peled and Wilke showed that all PLTL (propositional linear-time temporal logic) properties that are insensitive to stuttering equivalence can be expressed without the next-time operator. Stuttering equivalence is also important for certain verification techniques such as partial-order reduction for model checking.</p> <p>We formalize stuttering equivalence in Isabelle/HOL. Our development relies on the notion of stuttering sampling functions that may skip blocks of identical sequence elements. We also encode PLTL and prove the theorem due to Peled and Wilke.</p></td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2013-01-31]: Added encoding of PLTL and proved Peled and Wilke's theorem. Adjusted abstract accordingly.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Stuttering_Equivalence-AFP,
	author = {Stephan Merz},
	title = {Stuttering Equivalence},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Stuttering_Equivalence.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="LTL.html">LTL</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Consensus_Refined.html">Consensus_Refined</a>, <a href="Heard_Of.html">Heard_Of</a>, <a href="LTL_to_GBA.html">LTL_to_GBA</a>, <a href="Partial_Order_Reduction.html">Partial_Order_Reduction</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stuttering_Equivalence/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Stuttering_Equivalence/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Stuttering_Equivalence/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Stuttering_Equivalence-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Stuttering_Equivalence-2018-08-16.tar.gz">
	+ afp-Stuttering_Equivalence-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Stuttering_Equivalence-2017-10-10.tar.gz">
	afp-Stuttering_Equivalence-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Stuttering_Equivalence-2016-12-17.tar.gz">
	afp-Stuttering_Equivalence-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Stuttering_Equivalence-2016-02-22.tar.gz">
	afp-Stuttering_Equivalence-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Stuttering_Equivalence-2015-05-27.tar.gz">
	afp-Stuttering_Equivalence-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Stuttering_Equivalence-2014-08-28.tar.gz">
	afp-Stuttering_Equivalence-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Stuttering_Equivalence-2013-12-11.tar.gz">
	afp-Stuttering_Equivalence-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Stuttering_Equivalence-2013-11-17.tar.gz">
	afp-Stuttering_Equivalence-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Stuttering_Equivalence-2013-02-16.tar.gz">
	afp-Stuttering_Equivalence-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Stuttering_Equivalence-2013-02-02.tar.gz">
	afp-Stuttering_Equivalence-2013-02-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Stuttering_Equivalence-2012-05-24.tar.gz">
	afp-Stuttering_Equivalence-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Stuttering_Equivalence-2012-05-08.tar.gz">
	afp-Stuttering_Equivalence-2012-05-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Subresultants.html b/web/entries/Subresultants.html
	--- a/web/entries/Subresultants.html
	+++ b/web/entries/Subresultants.html
	@@ -1,185 +1,190 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Subresultants - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>ubresultants

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Subresultants</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a> and
	Akihisa Yamada (ayamada /at/ trs /dot/ cm /dot/ is /dot/ nagoya-u /dot/ ac /dot/ jp)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-04-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize the theory of subresultants and the subresultant
	polynomial remainder sequence as described by Brown and Traub. As a
	result, we obtain efficient certified algorithms for computing the
	resultant and the greatest common divisor of polynomials.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Subresultants-AFP,
	author = {Sebastiaan Joosten and René Thiemann and Akihisa Yamada},
	title = {Subresultants},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Subresultants.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Subresultants/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Subresultants/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Subresultants/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Subresultants-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Subresultants-2018-08-16.tar.gz">
	+ afp-Subresultants-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Subresultants-2017-10-10.tar.gz">
	afp-Subresultants-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Subresultants-2017-04-07.tar.gz">
	afp-Subresultants-2017-04-07.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/SumSquares.html b/web/entries/SumSquares.html
	--- a/web/entries/SumSquares.html
	+++ b/web/entries/SumSquares.html
	@@ -1,255 +1,260 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Sums of Two and Four Squares - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>ums

	of

	<font class="first">T</font>wo

	and

	<font class="first">F</font>our

	<font class="first">S</font>quares

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Sums of Two and Four Squares</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Roelof Oosterhuis
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2007-08-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This document presents the mechanised proofs of the following results:<ul><li>any prime number of the form 4m+1 can be written as the sum of two squares;</li><li>any natural number can be written as the sum of four squares</li></ul></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{SumSquares-AFP,
	author = {Roelof Oosterhuis},
	title = {Sums of Two and Four Squares},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2007,
	note = {\url{http://isa-afp.org/entries/SumSquares.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SumSquares/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/SumSquares/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SumSquares/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-SumSquares-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-SumSquares-2018-08-16.tar.gz">
	+ afp-SumSquares-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-SumSquares-2017-10-10.tar.gz">
	afp-SumSquares-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-SumSquares-2016-12-17.tar.gz">
	afp-SumSquares-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-SumSquares-2016-02-22.tar.gz">
	afp-SumSquares-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-SumSquares-2015-05-27.tar.gz">
	afp-SumSquares-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-SumSquares-2014-08-28.tar.gz">
	afp-SumSquares-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-SumSquares-2013-12-11.tar.gz">
	afp-SumSquares-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-SumSquares-2013-11-17.tar.gz">
	afp-SumSquares-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-SumSquares-2013-02-16.tar.gz">
	afp-SumSquares-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-SumSquares-2012-05-24.tar.gz">
	afp-SumSquares-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-SumSquares-2011-10-11.tar.gz">
	afp-SumSquares-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-SumSquares-2011-02-11.tar.gz">
	afp-SumSquares-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-SumSquares-2010-07-01.tar.gz">
	afp-SumSquares-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-SumSquares-2009-12-12.tar.gz">
	afp-SumSquares-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-SumSquares-2009-04-29.tar.gz">
	afp-SumSquares-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-SumSquares-2008-06-10.tar.gz">
	afp-SumSquares-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-SumSquares-2007-11-27.tar.gz">
	afp-SumSquares-2007-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/SuperCalc.html b/web/entries/SuperCalc.html
	--- a/web/entries/SuperCalc.html
	+++ b/web/entries/SuperCalc.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Variant of the Superposition Calculus - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">V</font>ariant

	of

	the

	<font class="first">S</font>uperposition

	<font class="first">C</font>alculus

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Variant of the Superposition Calculus</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://membres-lig.imag.fr/peltier/">Nicolas Peltier</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-09-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We provide a formalization of a variant of the superposition
	calculus, together with formal proofs of soundness and refutational
	completeness (w.r.t. the usual redundancy criteria based on clause
	ordering). This version of the calculus uses all the standard
	restrictions of the superposition rules, together with the following
	refinement, inspired by the basic superposition calculus: each clause
	is associated with a set of terms which are assumed to be in normal
	form -- thus any application of the replacement rule on these terms is
	blocked. The set is initially empty and terms may be added or removed
	at each inference step. The set of terms that are assumed to be in
	normal form includes any term introduced by previous unifiers as well
	as any term occurring in the parent clauses at a position that is
	smaller (according to some given ordering on positions) than a
	previously replaced term. The standard superposition calculus
	corresponds to the case where the set of irreducible terms is always
	empty.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{SuperCalc-AFP,
	author = {Nicolas Peltier},
	title = {A Variant of the Superposition Calculus},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/SuperCalc.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SuperCalc/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/SuperCalc/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/SuperCalc/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-SuperCalc-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-SuperCalc-2018-08-16.tar.gz">
	+ afp-SuperCalc-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-SuperCalc-2017-10-10.tar.gz">
	afp-SuperCalc-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-SuperCalc-2016-12-17.tar.gz">
	afp-SuperCalc-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-SuperCalc-2016-09-06.tar.gz">
	afp-SuperCalc-2016-09-06.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Surprise_Paradox.html b/web/entries/Surprise_Paradox.html
	--- a/web/entries/Surprise_Paradox.html
	+++ b/web/entries/Surprise_Paradox.html
	@@ -1,189 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Surprise Paradox - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>urprise

	<font class="first">P</font>aradox

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Surprise Paradox</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Joachim Breitner (joachim /at/ cis /dot/ upenn /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-07-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	In 1964, Fitch showed that the paradox of the surprise hanging can be
	resolved by showing that the judge’s verdict is inconsistent. His
	formalization builds on Gödel’s coding of provability. In this
	theory, we reproduce his proof in Isabelle, building on Paulson’s
	formalisation of Gödel’s incompleteness theorems.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Surprise_Paradox-AFP,
	author = {Joachim Breitner},
	title = {Surprise Paradox},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Surprise_Paradox.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Incompleteness.html">Incompleteness</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Surprise_Paradox/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Surprise_Paradox/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Surprise_Paradox/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Surprise_Paradox-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Surprise_Paradox-2018-08-16.tar.gz">
	+ afp-Surprise_Paradox-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Surprise_Paradox-2017-10-10.tar.gz">
	afp-Surprise_Paradox-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Surprise_Paradox-2016-12-17.tar.gz">
	afp-Surprise_Paradox-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Surprise_Paradox-2016-07-17.tar.gz">
	afp-Surprise_Paradox-2016-07-17.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Symmetric_Polynomials.html b/web/entries/Symmetric_Polynomials.html
	--- a/web/entries/Symmetric_Polynomials.html
	+++ b/web/entries/Symmetric_Polynomials.html
	@@ -1,195 +1,201 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Symmetric Polynomials - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">S</font>ymmetric

	<font class="first">P</font>olynomials

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Symmetric Polynomials</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-09-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>A symmetric polynomial is a polynomial in variables
	<em>X</em><sub>1</sub>,…,<em>X</em><sub>n</sub>
	that does not discriminate between its variables, i. e. it
	is invariant under any permutation of them. These polynomials are
	important in the study of the relationship between the coefficients of
	a univariate polynomial and its roots in its algebraic
	closure.</p> <p>This article provides a definition of
	symmetric polynomials and the elementary symmetric polynomials
	e<sub>1</sub>,…,e<sub>n</sub> and
	proofs of their basic properties, including three notable
	ones:</p> <ul> <li> Vieta's formula, which
	gives an explicit expression for the <em>k</em>-th
	coefficient of a univariate monic polynomial in terms of its roots
	<em>x</em><sub>1</sub>,…,<em>x</em><sub>n</sub>,
	namely
	<em>c</em><sub><em>k</em></sub> = (-1)<sup><em>n</em>-<em>k</em></sup> e<sub><em>n</em>-<em>k</em></sub>(<em>x</em><sub>1</sub>,…,<em>x</em><sub>n</sub>).</li>
	<li>Second, the Fundamental Theorem of Symmetric Polynomials,
	which states that any symmetric polynomial is itself a uniquely
	determined polynomial combination of the elementary symmetric
	polynomials.</li> <li>Third, as a corollary of the
	previous two, that given a polynomial over some ring
	<em>R</em>, any symmetric polynomial combination of its
	roots is also in <em>R</em> even when the roots are not.
	</ul> <p> Both the symmetry property itself and the
	witness for the Fundamental Theorem are executable. </p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Symmetric_Polynomials-AFP,
	author = {Manuel Eberl},
	title = {Symmetric Polynomials},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Symmetric_Polynomials.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Polynomials.html">Polynomials</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Pi_Transcendental.html">Pi_Transcendental</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Symmetric_Polynomials/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Symmetric_Polynomials/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Symmetric_Polynomials/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Symmetric_Polynomials-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Symmetric_Polynomials-2018-09-26.tar.gz">
	+ afp-Symmetric_Polynomials-2018-09-26.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/TLA.html b/web/entries/TLA.html
	--- a/web/entries/TLA.html
	+++ b/web/entries/TLA.html
	@@ -1,251 +1,256 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Definitional Encoding of TLA* in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">D</font>efinitional

	<font class="first">E</font>ncoding

	of

	<font class="first">T</font>LA*

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Definitional Encoding of TLA* in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://homepages.inf.ed.ac.uk/ggrov">Gudmund Grov</a> and
	<a href="http://www.loria.fr/~merz">Stephan Merz</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-11-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We mechanise the logic TLA*
	<a href="http://www.springerlink.com/content/ax3qk557qkdyt7n6/">[Merz 1999]</a>,
	an extension of Lamport's Temporal Logic of Actions (TLA)
	<a href="http://dl.acm.org/citation.cfm?doid=177492.177726">[Lamport 1994]</a>
	for specifying and reasoning
	about concurrent and reactive systems. Aiming at a framework for mechanising] the verification of TLA (or TLA*) specifications, this contribution reuses
	some elements from a previous axiomatic encoding of TLA in Isabelle/HOL
	by the second author [Merz 1998], which has been part of the Isabelle
	distribution. In contrast to that previous work, we give here a shallow,
	definitional embedding, with the following highlights:
	<ul>
	<li>a theory of infinite sequences, including a formalisation of the concepts of stuttering invariance central to TLA and TLA*;
	<li>a definition of the semantics of TLA*, which extends TLA by a mutually-recursive definition of formulas and pre-formulas, generalising TLA action formulas;
	<li>a substantial set of derived proof rules, including the TLA* axioms and Lamport's proof rules for system verification;
	<li>a set of examples illustrating the usage of Isabelle/TLA* for reasoning about systems.
	</ul>
	Note that this work is unrelated to the ongoing development of a proof system
	for the specification language TLA+, which includes an encoding of TLA+ as a
	new Isabelle object logic <a href="http://www.springerlink.com/content/354026160p14j175/">[Chaudhuri et al 2010]</a>.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{TLA-AFP,
	author = {Gudmund Grov and Stephan Merz},
	title = {A Definitional Encoding of TLA* in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/TLA.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/TLA/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/TLA/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/TLA/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-TLA-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-TLA-2018-08-16.tar.gz">
	+ afp-TLA-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-TLA-2017-10-10.tar.gz">
	afp-TLA-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-TLA-2016-12-17.tar.gz">
	afp-TLA-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-TLA-2016-02-22.tar.gz">
	afp-TLA-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-TLA-2015-05-27.tar.gz">
	afp-TLA-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-TLA-2014-08-28.tar.gz">
	afp-TLA-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-TLA-2013-12-11.tar.gz">
	afp-TLA-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-TLA-2013-11-17.tar.gz">
	afp-TLA-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-TLA-2013-03-02.tar.gz">
	afp-TLA-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-TLA-2013-02-16.tar.gz">
	afp-TLA-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-TLA-2012-05-24.tar.gz">
	afp-TLA-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-TLA-2011-11-27.tar.gz">
	afp-TLA-2011-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Tail_Recursive_Functions.html b/web/entries/Tail_Recursive_Functions.html
	--- a/web/entries/Tail_Recursive_Functions.html
	+++ b/web/entries/Tail_Recursive_Functions.html
	@@ -1,234 +1,239 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A General Method for the Proof of Theorems on Tail-recursive Functions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">G</font>eneral

	<font class="first">M</font>ethod

	for

	the

	<font class="first">P</font>roof

	of

	<font class="first">T</font>heorems

	on

	<font class="first">T</font>ail-recursive

	<font class="first">F</font>unctions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A General Method for the Proof of Theorems on Tail-recursive Functions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Pasquale Noce (pasquale /dot/ noce /dot/ lavoro /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2013-12-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	Tail-recursive function definitions are sometimes more straightforward than
	alternatives, but proving theorems on them may be roundabout because of the
	peculiar form of the resulting recursion induction rules.
	</p><p>
	This paper describes a proof method that provides a general solution to
	this problem by means of suitable invariants over inductive sets, and
	illustrates the application of such method by examining two case studies.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Tail_Recursive_Functions-AFP,
	author = {Pasquale Noce},
	title = {A General Method for the Proof of Theorems on Tail-recursive Functions},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2013,
	note = {\url{http://isa-afp.org/entries/Tail_Recursive_Functions.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tail_Recursive_Functions/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Tail_Recursive_Functions/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tail_Recursive_Functions/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Tail_Recursive_Functions-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Tail_Recursive_Functions-2018-08-16.tar.gz">
	+ afp-Tail_Recursive_Functions-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Tail_Recursive_Functions-2017-10-10.tar.gz">
	afp-Tail_Recursive_Functions-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Tail_Recursive_Functions-2016-12-17.tar.gz">
	afp-Tail_Recursive_Functions-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Tail_Recursive_Functions-2016-02-22.tar.gz">
	afp-Tail_Recursive_Functions-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Tail_Recursive_Functions-2015-06-13.tar.gz">
	afp-Tail_Recursive_Functions-2015-06-13.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Tail_Recursive_Functions-2015-05-27.tar.gz">
	afp-Tail_Recursive_Functions-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Tail_Recursive_Functions-2014-08-28.tar.gz">
	afp-Tail_Recursive_Functions-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Tail_Recursive_Functions-2013-12-11.tar.gz">
	afp-Tail_Recursive_Functions-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Tail_Recursive_Functions-2013-12-02.tar.gz">
	afp-Tail_Recursive_Functions-2013-12-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Tarskis_Geometry.html b/web/entries/Tarskis_Geometry.html
	--- a/web/entries/Tarskis_Geometry.html
	+++ b/web/entries/Tarskis_Geometry.html
	@@ -1,237 +1,242 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The independence of Tarski's Euclidean axiom - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	independence

	of

	<font class="first">T</font>arski's

	<font class="first">E</font>uclidean

	axiom

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The independence of Tarski's Euclidean axiom</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	T. J. M. Makarios (tjm1983 /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-10-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Tarski's axioms of plane geometry are formalized and, using the standard
	real Cartesian model, shown to be consistent. A substantial theory of
	the projective plane is developed. Building on this theory, the
	Klein-Beltrami model of the hyperbolic plane is defined and shown to
	satisfy all of Tarski's axioms except his Euclidean axiom; thus Tarski's
	Euclidean axiom is shown to be independent of his other axioms of plane
	geometry.
	<p>
	An earlier version of this work was the subject of the author's
	<a href="http://researcharchive.vuw.ac.nz/handle/10063/2315">MSc thesis</a>,
	which contains natural-language explanations of some of the
	more interesting proofs.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Tarskis_Geometry-AFP,
	author = {T. J. M. Makarios},
	title = {The independence of Tarski's Euclidean axiom},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Tarskis_Geometry.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tarskis_Geometry/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Tarskis_Geometry/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tarskis_Geometry/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Tarskis_Geometry-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Tarskis_Geometry-2018-08-16.tar.gz">
	+ afp-Tarskis_Geometry-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Tarskis_Geometry-2017-10-10.tar.gz">
	afp-Tarskis_Geometry-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Tarskis_Geometry-2016-12-17.tar.gz">
	afp-Tarskis_Geometry-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Tarskis_Geometry-2016-02-22.tar.gz">
	afp-Tarskis_Geometry-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Tarskis_Geometry-2015-05-27.tar.gz">
	afp-Tarskis_Geometry-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Tarskis_Geometry-2014-08-28.tar.gz">
	afp-Tarskis_Geometry-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Tarskis_Geometry-2013-12-11.tar.gz">
	afp-Tarskis_Geometry-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Tarskis_Geometry-2013-11-17.tar.gz">
	afp-Tarskis_Geometry-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Tarskis_Geometry-2013-02-16.tar.gz">
	afp-Tarskis_Geometry-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Tarskis_Geometry-2012-11-09.tar.gz">
	afp-Tarskis_Geometry-2012-11-09.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Tarskis_Geometry-2012-11-08.tar.gz">
	afp-Tarskis_Geometry-2012-11-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Taylor_Models.html b/web/entries/Taylor_Models.html
	--- a/web/entries/Taylor_Models.html
	+++ b/web/entries/Taylor_Models.html
	@@ -1,184 +1,189 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Taylor Models - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>aylor

	<font class="first">M</font>odels

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Taylor Models</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christoph Traut and
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-01-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formally verified implementation of multivariate Taylor
	models. Taylor models are a form of rigorous polynomial approximation,
	consisting of an approximation polynomial based on Taylor expansions,
	combined with a rigorous bound on the approximation error. Taylor
	models were introduced as a tool to mitigate the dependency problem of
	interval arithmetic. Our implementation automatically computes Taylor
	models for the class of elementary functions, expressed by composition
	of arithmetic operations and basic functions like exp, sin, or square
	root.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Taylor_Models-AFP,
	author = {Christoph Traut and Fabian Immler},
	title = {Taylor Models},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Taylor_Models.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Affine_Arithmetic.html">Affine_Arithmetic</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Taylor_Models/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Taylor_Models/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Taylor_Models/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Taylor_Models-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Taylor_Models-2018-08-16.tar.gz">
	+ afp-Taylor_Models-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Taylor_Models-2018-01-08.tar.gz">
	afp-Taylor_Models-2018-01-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Timed_Automata.html b/web/entries/Timed_Automata.html
	--- a/web/entries/Timed_Automata.html
	+++ b/web/entries/Timed_Automata.html
	@@ -1,205 +1,210 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Timed Automata - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>imed

	<font class="first">A</font>utomata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Timed Automata</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-03-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Timed automata are a widely used formalism for modeling real-time
	systems, which is employed in a class of successful model checkers
	such as UPPAAL [LPY97], HyTech [HHWt97] or Kronos [Yov97]. This work
	formalizes the theory for the subclass of diagonal-free timed
	automata, which is sufficient to model many interesting problems. We
	first define the basic concepts and semantics of diagonal-free timed
	automata. Based on this, we prove two types of decidability results
	for the language emptiness problem. The first is the classic result
	of Alur and Dill [AD90, AD94], which uses a finite partitioning of
	the state space into so-called `regions`. Our second result focuses
	on an approach based on `Difference Bound Matrices (DBMs)`, which is
	practically used by model checkers. We prove the correctness of the
	basic forward analysis operations on DBMs. One of these operations is
	the Floyd-Warshall algorithm for the all-pairs shortest paths problem.
	To obtain a finite search space, a widening operation has to be used
	for this kind of analysis. We use Patricia Bouyer's [Bou04] approach
	to prove that this widening operation is correct in the sense that
	DBM-based forward analysis in combination with the widening operation
	also decides language emptiness. The interesting property of this
	proof is that the first decidability result is reused to obtain the
	second one.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Timed_Automata-AFP,
	author = {Simon Wimmer},
	title = {Timed Automata},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Timed_Automata.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Probabilistic_Timed_Automata.html">Probabilistic_Timed_Automata</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Timed_Automata/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Timed_Automata/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Timed_Automata/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Timed_Automata-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Timed_Automata-2018-08-16.tar.gz">
	+ afp-Timed_Automata-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Timed_Automata-2017-10-10.tar.gz">
	afp-Timed_Automata-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Timed_Automata-2016-12-17.tar.gz">
	afp-Timed_Automata-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Timed_Automata-2016-03-11.tar.gz">
	afp-Timed_Automata-2016-03-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Topology.html b/web/entries/Topology.html
	--- a/web/entries/Topology.html
	+++ b/web/entries/Topology.html
	@@ -1,267 +1,272 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Topology - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>opology

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Topology</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Stefan Friedrich
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-04-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This entry contains two theories. The first, <tt>Topology</tt>, develops the basic notions of general topology. The second, which can be viewed as a demonstration of the first, is called <tt>LList_Topology</tt>. It develops the topology of lazy lists.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Topology-AFP,
	author = {Stefan Friedrich},
	title = {Topology},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Topology.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Coinductive.html">Coinductive</a>, <a href="Lazy-Lists-II.html">Lazy-Lists-II</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Topology/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Topology/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Topology/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Topology-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Topology-2018-08-16.tar.gz">
	+ afp-Topology-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Topology-2017-10-10.tar.gz">
	afp-Topology-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Topology-2016-12-17.tar.gz">
	afp-Topology-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Topology-2016-02-22.tar.gz">
	afp-Topology-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Topology-2015-05-27.tar.gz">
	afp-Topology-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Topology-2014-08-28.tar.gz">
	afp-Topology-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Topology-2013-12-11.tar.gz">
	afp-Topology-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Topology-2013-11-17.tar.gz">
	afp-Topology-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Topology-2013-03-02.tar.gz">
	afp-Topology-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Topology-2013-02-16.tar.gz">
	afp-Topology-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Topology-2012-05-24.tar.gz">
	afp-Topology-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Topology-2011-10-11.tar.gz">
	afp-Topology-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Topology-2011-02-11.tar.gz">
	afp-Topology-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Topology-2010-07-01.tar.gz">
	afp-Topology-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Topology-2009-12-12.tar.gz">
	afp-Topology-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Topology-2009-04-29.tar.gz">
	afp-Topology-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Topology-2008-06-10.tar.gz">
	afp-Topology-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Topology-2007-11-27.tar.gz">
	afp-Topology-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Topology-2005-10-14.tar.gz">
	afp-Topology-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Topology-2004-05-21.tar.gz">
	afp-Topology-2004-05-21.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Topology-2004-04-27.tar.gz">
	afp-Topology-2004-04-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/TortoiseHare.html b/web/entries/TortoiseHare.html
	--- a/web/entries/TortoiseHare.html
	+++ b/web/entries/TortoiseHare.html
	@@ -1,188 +1,193 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Tortoise and Hare Algorithm - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">T</font>ortoise

	and

	<font class="first">H</font>are

	<font class="first">A</font>lgorithm

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Tortoise and Hare Algorithm</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-11-18</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We formalize the Tortoise and Hare cycle-finding algorithm ascribed to Floyd by Knuth, and an improved version due to Brent.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{TortoiseHare-AFP,
	author = {Peter Gammie},
	title = {The Tortoise and Hare Algorithm},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/TortoiseHare.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/TortoiseHare/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/TortoiseHare/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/TortoiseHare/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-TortoiseHare-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-TortoiseHare-2018-08-16.tar.gz">
	+ afp-TortoiseHare-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-TortoiseHare-2017-10-10.tar.gz">
	afp-TortoiseHare-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-TortoiseHare-2016-12-17.tar.gz">
	afp-TortoiseHare-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-TortoiseHare-2016-02-22.tar.gz">
	afp-TortoiseHare-2016-02-22.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Transcendence_Series_Hancl_Rucki.html b/web/entries/Transcendence_Series_Hancl_Rucki.html
	--- a/web/entries/Transcendence_Series_Hancl_Rucki.html
	+++ b/web/entries/Transcendence_Series_Hancl_Rucki.html
	@@ -1,183 +1,189 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Transcendence of Certain Infinite Series - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">T</font>ranscendence

	of

	<font class="first">C</font>ertain

	<font class="first">I</font>nfinite

	<font class="first">S</font>eries

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Transcendence of Certain Infinite Series</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~ak2110/">Angeliki Koutsoukou-Argyraki</a> and
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-03-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize the proofs of two transcendence criteria by J. Hančl
	and P. Rucki that assert the transcendence of the sums of certain
	infinite series built up by sequences that fulfil certain properties.
	Both proofs make use of Roth's celebrated theorem on diophantine
	approximations to algebraic numbers from 1955 which we implement as
	an assumption without having formalised its proof.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Transcendence_Series_Hancl_Rucki-AFP,
	author = {Angeliki Koutsoukou-Argyraki and Wenda Li},
	title = {The Transcendence of Certain Infinite Series},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Transcendence_Series_Hancl_Rucki.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Prime_Number_Theorem.html">Prime_Number_Theorem</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transcendence_Series_Hancl_Rucki/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Transcendence_Series_Hancl_Rucki/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transcendence_Series_Hancl_Rucki/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Transcendence_Series_Hancl_Rucki-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Transcendence_Series_Hancl_Rucki-2019-03-28.tar.gz">
	+ afp-Transcendence_Series_Hancl_Rucki-2019-03-28.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Transformer_Semantics.html b/web/entries/Transformer_Semantics.html
	--- a/web/entries/Transformer_Semantics.html
	+++ b/web/entries/Transformer_Semantics.html
	@@ -1,178 +1,184 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Transformer Semantics - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>ransformer

	<font class="first">S</font>emantics

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Transformer Semantics</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-12-11</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	These mathematical components formalise predicate transformer
	semantics for programs, yet currently only for partial correctness and
	in the absence of faults. A first part for isotone (or monotone),
	Sup-preserving and Inf-preserving transformers follows Back and von
	Wright's approach, with additional emphasis on the quantalic
	structure of algebras of transformers. The second part develops
	Sup-preserving and Inf-preserving predicate transformers from the
	powerset monad, via its Kleisli category and Eilenberg-Moore algebras,
	with emphasis on adjunctions and dualities, as well as isomorphisms
	between relations, state transformers and predicate transformers.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Transformer_Semantics-AFP,
	author = {Georg Struth},
	title = {Transformer Semantics},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Transformer_Semantics.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Order_Lattice_Props.html">Order_Lattice_Props</a>, <a href="Quantales.html">Quantales</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transformer_Semantics/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Transformer_Semantics/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transformer_Semantics/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Transformer_Semantics-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Transformer_Semantics-2018-12-19.tar.gz">
	+ afp-Transformer_Semantics-2018-12-19.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Transition_Systems_and_Automata.html b/web/entries/Transition_Systems_and_Automata.html
	--- a/web/entries/Transition_Systems_and_Automata.html
	+++ b/web/entries/Transition_Systems_and_Automata.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Transition Systems and Automata - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>ransition

	<font class="first">S</font>ystems

	and

	<font class="first">A</font>utomata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Transition Systems and Automata</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~brunnerj/">Julian Brunner</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-10-19</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides a very abstract theory of transition systems that
	can be instantiated to express various types of automata. A transition
	system is typically instantiated by providing a set of initial states,
	a predicate for enabled transitions, and a transition execution
	function. From this, it defines the concepts of finite and infinite
	paths as well as the set of reachable states, among other things. Many
	useful theorems, from basic path manipulation rules to coinduction and
	run construction rules, are proven in this abstract transition system
	context. The library comes with instantiations for DFAs, NFAs, and
	Büchi automata.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Transition_Systems_and_Automata-AFP,
	author = {Julian Brunner},
	title = {Transition Systems and Automata},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Transition_Systems_and_Automata.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="DFS_Framework.html">DFS_Framework</a>, <a href="Gabow_SCC.html">Gabow_SCC</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Buchi_Complementation.html">Buchi_Complementation</a>, <a href="LTL_Master_Theorem.html">LTL_Master_Theorem</a>, <a href="Partial_Order_Reduction.html">Partial_Order_Reduction</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transition_Systems_and_Automata/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Transition_Systems_and_Automata/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transition_Systems_and_Automata/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Transition_Systems_and_Automata-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Transition_Systems_and_Automata-2018-08-16.tar.gz">
	+ afp-Transition_Systems_and_Automata-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Transition_Systems_and_Automata-2017-10-27.tar.gz">
	afp-Transition_Systems_and_Automata-2017-10-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Transitive-Closure-II.html b/web/entries/Transitive-Closure-II.html
	--- a/web/entries/Transitive-Closure-II.html
	+++ b/web/entries/Transitive-Closure-II.html
	@@ -1,240 +1,245 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Executable Transitive Closures - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>xecutable

	<font class="first">T</font>ransitive

	<font class="first">C</font>losures

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Executable Transitive Closures</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-02-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	We provide a generic work-list algorithm to compute the
	(reflexive-)transitive closure of relations where only successors of newly
	detected states are generated.
	In contrast to our previous work, the relations do not have to be finite,
	but each element must only have finitely many (indirect) successors.
	Moreover, a subsumption relation can be used instead of pure equality.
	An executable variant of the algorithm is available where the generic operations
	are instantiated with list operations.
	</p><p>
	This formalization was performed as part of the IsaFoR/CeTA project,
	and it has been used to certify size-change
	termination proofs where large transitive closures have to be computed.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Transitive-Closure-II-AFP,
	author = {René Thiemann},
	title = {Executable Transitive Closures},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Transitive-Closure-II.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Regular-Sets.html">Regular-Sets</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transitive-Closure-II/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Transitive-Closure-II/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transitive-Closure-II/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Transitive-Closure-II-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Transitive-Closure-II-2018-08-16.tar.gz">
	+ afp-Transitive-Closure-II-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Transitive-Closure-II-2017-10-10.tar.gz">
	afp-Transitive-Closure-II-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Transitive-Closure-II-2016-12-17.tar.gz">
	afp-Transitive-Closure-II-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Transitive-Closure-II-2016-02-22.tar.gz">
	afp-Transitive-Closure-II-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Transitive-Closure-II-2015-05-27.tar.gz">
	afp-Transitive-Closure-II-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Transitive-Closure-II-2014-08-28.tar.gz">
	afp-Transitive-Closure-II-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Transitive-Closure-II-2013-12-11.tar.gz">
	afp-Transitive-Closure-II-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Transitive-Closure-II-2013-11-17.tar.gz">
	afp-Transitive-Closure-II-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Transitive-Closure-II-2013-02-16.tar.gz">
	afp-Transitive-Closure-II-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Transitive-Closure-II-2012-05-24.tar.gz">
	afp-Transitive-Closure-II-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Transitive-Closure-II-2012-03-15.tar.gz">
	afp-Transitive-Closure-II-2012-03-15.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Transitive-Closure-II-2012-02-29.tar.gz">
	afp-Transitive-Closure-II-2012-02-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Transitive-Closure.html b/web/entries/Transitive-Closure.html
	--- a/web/entries/Transitive-Closure.html
	+++ b/web/entries/Transitive-Closure.html
	@@ -1,244 +1,249 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Executable Transitive Closures of Finite Relations - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>xecutable

	<font class="first">T</font>ransitive

	<font class="first">C</font>losures

	of

	<font class="first">F</font>inite

	<font class="first">R</font>elations

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Executable Transitive Closures of Finite Relations</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2011-03-14</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">We provide a generic work-list algorithm to compute the transitive closure of finite relations where only successors of newly detected states are generated. This algorithm is then instantiated for lists over arbitrary carriers and red black trees (which are faster but require a linear order on the carrier), respectively. Our formalization was performed as part of the IsaFoR/CeTA project where reflexive transitive closures of large tree automata have to be computed.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2014-09-04] added example simprocs in Finite_Transitive_Closure_Simprocs</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Transitive-Closure-AFP,
	author = {Christian Sternagel and René Thiemann},
	title = {Executable Transitive Closures of Finite Relations},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2011,
	note = {\url{http://isa-afp.org/entries/Transitive-Closure.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE.LGPL">GNU Lesser General Public License (LGPL)</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="Matrix.html">Matrix</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="KBPs.html">KBPs</a>, <a href="Network_Security_Policy_Verification.html">Network_Security_Policy_Verification</a>, <a href="Planarity_Certificates.html">Planarity_Certificates</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transitive-Closure/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Transitive-Closure/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Transitive-Closure/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Transitive-Closure-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Transitive-Closure-2018-08-16.tar.gz">
	+ afp-Transitive-Closure-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Transitive-Closure-2017-10-10.tar.gz">
	afp-Transitive-Closure-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Transitive-Closure-2016-12-17.tar.gz">
	afp-Transitive-Closure-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Transitive-Closure-2016-02-22.tar.gz">
	afp-Transitive-Closure-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Transitive-Closure-2015-05-27.tar.gz">
	afp-Transitive-Closure-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Transitive-Closure-2014-08-28.tar.gz">
	afp-Transitive-Closure-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Transitive-Closure-2013-12-11.tar.gz">
	afp-Transitive-Closure-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Transitive-Closure-2013-11-17.tar.gz">
	afp-Transitive-Closure-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Transitive-Closure-2013-02-16.tar.gz">
	afp-Transitive-Closure-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Transitive-Closure-2012-05-24.tar.gz">
	afp-Transitive-Closure-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Transitive-Closure-2011-10-12.tar.gz">
	afp-Transitive-Closure-2011-10-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Transitive-Closure-2011-10-11.tar.gz">
	afp-Transitive-Closure-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Transitive-Closure-2011-03-14.tar.gz">
	afp-Transitive-Closure-2011-03-14.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Treaps.html b/web/entries/Treaps.html
	--- a/web/entries/Treaps.html
	+++ b/web/entries/Treaps.html
	@@ -1,195 +1,200 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Treaps - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>reaps

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Treaps</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://home.in.tum.de/~haslbecm">Maximilian Haslbeck</a>,
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-02-06</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p> A Treap is a binary tree whose nodes contain pairs
	consisting of some payload and an associated priority. It must have
	the search-tree property w.r.t. the payloads and the heap property
	w.r.t. the priorities. Treaps are an interesting data structure that
	is related to binary search trees (BSTs) in the following way: if one
	forgets all the priorities of a treap, the resulting BST is exactly
	the same as if one had inserted the elements into an empty BST in
	order of ascending priority. This means that a treap behaves like a
	BST where we can pretend the elements were inserted in a different
	order from the one in which they were actually inserted. </p>
	<p> In particular, by choosing these priorities at random upon
	insertion of an element, we can pretend that we inserted the elements
	in <em>random order</em>, so that the shape of the
	resulting tree is that of a random BST no matter in what order we
	insert the elements. This is the main result of this
	formalisation.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Treaps-AFP,
	author = {Maximilian Haslbeck and Manuel Eberl and Tobias Nipkow},
	title = {Treaps},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Treaps.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Comparison_Sort_Lower_Bound.html">Comparison_Sort_Lower_Bound</a>, <a href="Random_BSTs.html">Random_BSTs</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Treaps/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Treaps/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Treaps/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Treaps-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Treaps-2018-08-16.tar.gz">
	+ afp-Treaps-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Treaps-2018-02-07.tar.gz">
	afp-Treaps-2018-02-07.tar.gz
	</a>
	</li>
	<li>Isabelle 2017:
	<a href="../release/afp-Treaps-2018-02-06.tar.gz">
	afp-Treaps-2018-02-06.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Tree-Automata.html b/web/entries/Tree-Automata.html
	--- a/web/entries/Tree-Automata.html
	+++ b/web/entries/Tree-Automata.html
	@@ -1,259 +1,264 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Tree Automata - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>ree

	<font class="first">A</font>utomata

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Tree Automata</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-11-25</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Tree-Automata-AFP,
	author = {Peter Lammich},
	title = {Tree Automata},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/Tree-Automata.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Collections.html">Collections</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tree-Automata/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Tree-Automata/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tree-Automata/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Tree-Automata-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Tree-Automata-2018-08-16.tar.gz">
	+ afp-Tree-Automata-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Tree-Automata-2017-10-10.tar.gz">
	afp-Tree-Automata-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Tree-Automata-2016-12-17.tar.gz">
	afp-Tree-Automata-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Tree-Automata-2016-02-22.tar.gz">
	afp-Tree-Automata-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Tree-Automata-2015-05-27.tar.gz">
	afp-Tree-Automata-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Tree-Automata-2014-08-28.tar.gz">
	afp-Tree-Automata-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Tree-Automata-2013-12-11.tar.gz">
	afp-Tree-Automata-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Tree-Automata-2013-11-17.tar.gz">
	afp-Tree-Automata-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Tree-Automata-2013-03-02.tar.gz">
	afp-Tree-Automata-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Tree-Automata-2013-02-16.tar.gz">
	afp-Tree-Automata-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Tree-Automata-2012-05-24.tar.gz">
	afp-Tree-Automata-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Tree-Automata-2012-03-15.tar.gz">
	afp-Tree-Automata-2012-03-15.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Tree-Automata-2011-10-12.tar.gz">
	afp-Tree-Automata-2011-10-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Tree-Automata-2011-10-11.tar.gz">
	afp-Tree-Automata-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Tree-Automata-2011-02-11.tar.gz">
	afp-Tree-Automata-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Tree-Automata-2010-07-01.tar.gz">
	afp-Tree-Automata-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Tree-Automata-2009-12-13.tar.gz">
	afp-Tree-Automata-2009-12-13.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Tree-Automata-2009-12-12.tar.gz">
	afp-Tree-Automata-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Tree-Automata-2009-11-29.tar.gz">
	afp-Tree-Automata-2009-11-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Tree_Decomposition.html b/web/entries/Tree_Decomposition.html
	--- a/web/entries/Tree_Decomposition.html
	+++ b/web/entries/Tree_Decomposition.html
	@@ -1,192 +1,197 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Tree Decomposition - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>ree

	<font class="first">D</font>ecomposition

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Tree Decomposition</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://logic.las.tu-berlin.de/Members/Dittmann/">Christoph Dittmann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-05-31</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalize tree decompositions and tree width in Isabelle/HOL,
	proving that trees have treewidth 1. We also show that every edge of
	a tree decomposition is a separation of the underlying graph. As an
	application of this theorem we prove that complete graphs of size n
	have treewidth n-1.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Tree_Decomposition-AFP,
	author = {Christoph Dittmann},
	title = {Tree Decomposition},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Tree_Decomposition.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tree_Decomposition/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Tree_Decomposition/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tree_Decomposition/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Tree_Decomposition-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Tree_Decomposition-2018-08-16.tar.gz">
	+ afp-Tree_Decomposition-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Tree_Decomposition-2017-10-10.tar.gz">
	afp-Tree_Decomposition-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Tree_Decomposition-2016-12-17.tar.gz">
	afp-Tree_Decomposition-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Tree_Decomposition-2016-06-01.tar.gz">
	afp-Tree_Decomposition-2016-06-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Tree_Decomposition-2016-05-31.tar.gz">
	afp-Tree_Decomposition-2016-05-31.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Triangle.html b/web/entries/Triangle.html
	--- a/web/entries/Triangle.html
	+++ b/web/entries/Triangle.html
	@@ -1,206 +1,211 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Basic Geometric Properties of Triangles - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">B</font>asic

	<font class="first">G</font>eometric

	<font class="first">P</font>roperties

	of

	<font class="first">T</font>riangles

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Basic Geometric Properties of Triangles</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-12-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>
	This entry contains a definition of angles between vectors and between three
	points. Building on this, we prove basic geometric properties of triangles, such
	as the Isosceles Triangle Theorem, the Law of Sines and the Law of Cosines, that
	the sum of the angles of a triangle is π, and the congruence theorems for
	triangles.
	</p><p>
	The definitions and proofs were developed following those by John Harrison in
	HOL Light. However, due to Isabelle's type class system, all definitions and
	theorems in the Isabelle formalisation hold for all real inner product spaces.
	</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Triangle-AFP,
	author = {Manuel Eberl},
	title = {Basic Geometric Properties of Triangles},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Triangle.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Chord_Segments.html">Chord_Segments</a>, <a href="Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a>, <a href="Stewart_Apollonius.html">Stewart_Apollonius</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Triangle/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Triangle/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Triangle/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Triangle-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Triangle-2018-08-16.tar.gz">
	+ afp-Triangle-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Triangle-2017-10-10.tar.gz">
	afp-Triangle-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Triangle-2016-12-17.tar.gz">
	afp-Triangle-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Triangle-2016-02-22.tar.gz">
	afp-Triangle-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Triangle-2016-01-05.tar.gz">
	afp-Triangle-2016-01-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Trie.html b/web/entries/Trie.html
	--- a/web/entries/Trie.html
	+++ b/web/entries/Trie.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Trie - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>rie

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Trie</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a> and
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-03-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This article formalizes the ``trie'' data structure invented by
	Fredkin [CACM 1960]. It also provides a specialization where the entries
	in the trie are lists.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Origin:</td>
	<td class="abstract">This article was extracted from existing articles by the authors.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Trie-AFP,
	author = {Andreas Lochbihler and Tobias Nipkow},
	title = {Trie},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Trie.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Collections.html">Collections</a>, <a href="Containers.html">Containers</a>, <a href="Flyspeck-Tame.html">Flyspeck-Tame</a>, <a href="JinjaThreads.html">JinjaThreads</a>, <a href="KBPs.html">KBPs</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Trie/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Trie/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Trie/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Trie-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Trie-2018-08-16.tar.gz">
	+ afp-Trie-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Trie-2017-10-10.tar.gz">
	afp-Trie-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Trie-2016-12-17.tar.gz">
	afp-Trie-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Trie-2016-02-22.tar.gz">
	afp-Trie-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Trie-2015-05-27.tar.gz">
	afp-Trie-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Trie-2015-03-30.tar.gz">
	afp-Trie-2015-03-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Twelvefold_Way.html b/web/entries/Twelvefold_Way.html
	--- a/web/entries/Twelvefold_Way.html
	+++ b/web/entries/Twelvefold_Way.html
	@@ -1,190 +1,195 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Twelvefold Way - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">T</font>welvefold

	<font class="first">W</font>ay

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Twelvefold Way</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Lukas Bulwahn (lukas /dot/ bulwahn /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-12-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides all cardinality theorems of the Twelvefold Way.
	The Twelvefold Way systematically classifies twelve related
	combinatorial problems concerning two finite sets, which include
	counting permutations, combinations, multisets, set partitions and
	number partitions. This development builds upon the existing formal
	developments with cardinality theorems for those structures. It
	provides twelve bijections from the various structures to different
	equivalence classes on finite functions, and hence, proves cardinality
	formulae for these equivalence classes on finite functions.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Twelvefold_Way-AFP,
	author = {Lukas Bulwahn},
	title = {The Twelvefold Way},
	journal = {Archive of Formal Proofs},
	month = dec,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Twelvefold_Way.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Bell_Numbers_Spivey.html">Bell_Numbers_Spivey</a>, <a href="Card_Multisets.html">Card_Multisets</a>, <a href="Card_Number_Partitions.html">Card_Number_Partitions</a>, <a href="Card_Partitions.html">Card_Partitions</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Twelvefold_Way/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Twelvefold_Way/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Twelvefold_Way/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Twelvefold_Way-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Twelvefold_Way-2018-08-16.tar.gz">
	+ afp-Twelvefold_Way-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Twelvefold_Way-2017-10-10.tar.gz">
	afp-Twelvefold_Way-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Twelvefold_Way-2016-12-30.tar.gz">
	afp-Twelvefold_Way-2016-12-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Tycon.html b/web/entries/Tycon.html
	--- a/web/entries/Tycon.html
	+++ b/web/entries/Tycon.html
	@@ -1,232 +1,237 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Type Constructor Classes and Monad Transformers - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>ype

	<font class="first">C</font>onstructor

	<font class="first">C</font>lasses

	and

	<font class="first">M</font>onad

	<font class="first">T</font>ransformers

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Type Constructor Classes and Monad Transformers</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Brian Huffman
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-06-26</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	These theories contain a formalization of first class type constructors
	and axiomatic constructor classes for HOLCF. This work is described
	in detail in the ICFP 2012 paper <i>Formal Verification of Monad
	Transformers</i> by the author. The formalization is a revised and
	updated version of earlier joint work with Matthews and White.
	<P>
	Based on the hierarchy of type classes in Haskell, we define classes
	for functors, monads, monad-plus, etc. Each one includes all the
	standard laws as axioms. We also provide a new user command,
	tycondef, for defining new type constructors in HOLCF. Using tycondef,
	we instantiate the type class hierarchy with various monads and monad
	transformers.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Tycon-AFP,
	author = {Brian Huffman},
	title = {Type Constructor Classes and Monad Transformers},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Tycon.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tycon/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Tycon/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Tycon/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Tycon-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Tycon-2018-08-16.tar.gz">
	+ afp-Tycon-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Tycon-2017-10-10.tar.gz">
	afp-Tycon-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Tycon-2016-12-17.tar.gz">
	afp-Tycon-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Tycon-2016-02-22.tar.gz">
	afp-Tycon-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Tycon-2015-05-27.tar.gz">
	afp-Tycon-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Tycon-2014-08-28.tar.gz">
	afp-Tycon-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Tycon-2013-12-11.tar.gz">
	afp-Tycon-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Tycon-2013-11-17.tar.gz">
	afp-Tycon-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Tycon-2013-02-16.tar.gz">
	afp-Tycon-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Tycon-2012-06-28.tar.gz">
	afp-Tycon-2012-06-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Types_Tableaus_and_Goedels_God.html b/web/entries/Types_Tableaus_and_Goedels_God.html
	--- a/web/entries/Types_Tableaus_and_Goedels_God.html
	+++ b/web/entries/Types_Tableaus_and_Goedels_God.html
	@@ -1,199 +1,204 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Types, Tableaus and Gödel’s God in Isabelle/HOL - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>ypes,

	<font class="first">T</font>ableaus

	and

	<font class="first">G</font>ödel’s

	<font class="first">G</font>od

	in

	<font class="first">I</font>sabelle/HOL

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Types, Tableaus and Gödel’s God in Isabelle/HOL</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	David Fuenmayor (davfuenmayor /at/ gmail /dot/ com) and
	<a href="http://christoph-benzmueller.de">Christoph Benzmüller</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-05-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	A computer-formalisation of the essential parts of Fitting's
	textbook "Types, Tableaus and Gödel's God" in
	Isabelle/HOL is presented. In particular, Fitting's (and
	Anderson's) variant of the ontological argument is verified and
	confirmed. This variant avoids the modal collapse, which has been
	criticised as an undesirable side-effect of Kurt Gödel's (and
	Dana Scott's) versions of the ontological argument.
	Fitting's work is employing an intensional higher-order modal
	logic, which we shallowly embed here in classical higher-order logic.
	We then utilize the embedded logic for the formalisation of
	Fitting's argument. (See also the earlier AFP entry ``Gödel's God in Isabelle/HOL''.)</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Types_Tableaus_and_Goedels_God-AFP,
	author = {David Fuenmayor and Christoph Benzmüller},
	title = {Types, Tableaus and Gödel’s God in Isabelle/HOL},
	journal = {Archive of Formal Proofs},
	month = may,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Types_Tableaus_and_Goedels_God.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Types_Tableaus_and_Goedels_God/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Types_Tableaus_and_Goedels_God/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Types_Tableaus_and_Goedels_God/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Types_Tableaus_and_Goedels_God-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Types_Tableaus_and_Goedels_God-2018-08-16.tar.gz">
	+ afp-Types_Tableaus_and_Goedels_God-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Types_Tableaus_and_Goedels_God-2017-10-10.tar.gz">
	afp-Types_Tableaus_and_Goedels_God-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Types_Tableaus_and_Goedels_God-2017-05-02.tar.gz">
	afp-Types_Tableaus_and_Goedels_God-2017-05-02.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/UPF.html b/web/entries/UPF.html
	--- a/web/entries/UPF.html
	+++ b/web/entries/UPF.html
	@@ -1,218 +1,223 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Unified Policy Framework (UPF) - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">U</font>nified

	<font class="first">P</font>olicy

	<font class="first">F</font>ramework

	<font class="first">(</font>UPF)

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Unified Policy Framework (UPF)</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.brucker.ch/">Achim D. Brucker</a>,
	Lukas Brügger and
	Burkhart Wolff (wolff /at/ lri /dot/ fr)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-11-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present the Unified Policy Framework (UPF), a generic framework
	for modelling security (access-control) policies. UPF emphasizes
	the view that a policy is a policy decision function that grants or
	denies access to resources, permissions, etc. In other words,
	instead of modelling the relations of permitted or prohibited
	requests directly, we model the concrete function that implements
	the policy decision point in a system. In more detail, UPF is
	based on the following four principles: 1) Functional representation
	of policies, 2) No conflicts are possible, 3) Three-valued decision
	type (allow, deny, undefined), 4) Output type not containing the
	decision only.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{UPF-AFP,
	author = {Achim D. Brucker and Lukas Brügger and Burkhart Wolff},
	title = {The Unified Policy Framework (UPF)},
	journal = {Archive of Formal Proofs},
	month = nov,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/UPF.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="UPF_Firewall.html">UPF_Firewall</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/UPF/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/UPF/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/UPF/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-UPF-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-UPF-2018-08-16.tar.gz">
	+ afp-UPF-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-UPF-2017-10-10.tar.gz">
	afp-UPF-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-UPF-2016-12-17.tar.gz">
	afp-UPF-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-UPF-2016-02-22.tar.gz">
	afp-UPF-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-UPF-2015-05-27.tar.gz">
	afp-UPF-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-UPF-2015-01-28.tar.gz">
	afp-UPF-2015-01-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-UPF-2014-11-30.tar.gz">
	afp-UPF-2014-11-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/UPF_Firewall.html b/web/entries/UPF_Firewall.html
	--- a/web/entries/UPF_Firewall.html
	+++ b/web/entries/UPF_Firewall.html
	@@ -1,202 +1,207 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Formal Network Models and Their Application to Firewall Policies - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>ormal

	<font class="first">N</font>etwork

	<font class="first">M</font>odels

	and

	<font class="first">T</font>heir

	<font class="first">A</font>pplication

	to

	<font class="first">F</font>irewall

	<font class="first">P</font>olicies

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Formal Network Models and Their Application to Firewall Policies</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.brucker.ch/">Achim D. Brucker</a>,
	Lukas Brügger and
	Burkhart Wolff (wolff /at/ lri /dot/ fr)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-01-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We present a formal model of network protocols and their application
	to modeling firewall policies. The formalization is based on the
	Unified Policy Framework (UPF). The formalization was originally
	developed with for generating test cases for testing the security
	configuration actual firewall and router (middle-boxes) using
	HOL-TestGen. Our work focuses on modeling application level protocols
	on top of tcp/ip.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{UPF_Firewall-AFP,
	author = {Achim D. Brucker and Lukas Brügger and Burkhart Wolff},
	title = {Formal Network Models and Their Application to Firewall Policies},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/UPF_Firewall.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="UPF.html">UPF</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/UPF_Firewall/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/UPF_Firewall/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/UPF_Firewall/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-UPF_Firewall-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-UPF_Firewall-2018-08-16.tar.gz">
	+ afp-UPF_Firewall-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-UPF_Firewall-2017-10-10.tar.gz">
	afp-UPF_Firewall-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-UPF_Firewall-2017-01-11.tar.gz">
	afp-UPF_Firewall-2017-01-11.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/UTP.html b/web/entries/UTP.html
	--- a/web/entries/UTP.html
	+++ b/web/entries/UTP.html
	@@ -1,198 +1,204 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Isabelle/UTP: Mechanised Theory Engineering for Unifying Theories of Programming - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">I</font>sabelle/UTP:

	<font class="first">M</font>echanised

	<font class="first">T</font>heory

	<font class="first">E</font>ngineering

	for

	<font class="first">U</font>nifying

	<font class="first">T</font>heories

	of

	<font class="first">P</font>rogramming

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Isabelle/UTP: Mechanised Theory Engineering for Unifying Theories of Programming</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www-users.cs.york.ac.uk/~simonf/">Simon Foster</a>,
	Frank Zeyda,
	Yakoub Nemouchi (yakoub /dot/ nemouchi /at/ york /dot/ ac /dot/ uk),
	Pedro Ribeiro and
	Burkhart Wolff (wolff /at/ lri /dot/ fr)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-02-01</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	Isabelle/UTP is a mechanised theory engineering toolkit based on Hoare
	and He’s Unifying Theories of Programming (UTP). UTP enables the
	creation of denotational, algebraic, and operational semantics for
	different programming languages using an alphabetised relational
	calculus. We provide a semantic embedding of the alphabetised
	relational calculus in Isabelle/HOL, including new type definitions,
	relational constructors, automated proof tactics, and accompanying
	algebraic laws. Isabelle/UTP can be used to both capture laws of
	programming for different languages, and put these fundamental
	theorems to work in the creation of associated verification tools,
	using calculi like Hoare logics. This document describes the
	relational core of the UTP in Isabelle/HOL.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{UTP-AFP,
	author = {Simon Foster and Frank Zeyda and Yakoub Nemouchi and Pedro Ribeiro and Burkhart Wolff},
	title = {Isabelle/UTP: Mechanised Theory Engineering for Unifying Theories of Programming},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/UTP.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Optics.html">Optics</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/UTP/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/UTP/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/UTP/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-UTP-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-UTP-2019-02-06.tar.gz">
	+ afp-UTP-2019-02-06.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Universal_Turing_Machine.html b/web/entries/Universal_Turing_Machine.html
	--- a/web/entries/Universal_Turing_Machine.html
	+++ b/web/entries/Universal_Turing_Machine.html
	@@ -1,176 +1,182 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Universal Turing Machine - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">U</font>niversal

	<font class="first">T</font>uring

	<font class="first">M</font>achine

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Universal Turing Machine</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Jian Xu,
	Xingyuan Zhang,
	<a href="http://www.inf.kcl.ac.uk/staff/urbanc/">Christian Urban</a> and
	Sebastiaan J. C. Joosten
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2019-02-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	We formalise results from computability theory: recursive functions,
	undecidability of the halting problem, and the existence of a
	universal Turing machine. This formalisation is the AFP entry
	corresponding to the paper Mechanising Turing Machines and Computability Theory
	in Isabelle/HOL, ITP 2013.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Universal_Turing_Machine-AFP,
	author = {Jian Xu and Xingyuan Zhang and Christian Urban and Sebastiaan J. C. Joosten},
	title = {Universal Turing Machine},
	journal = {Archive of Formal Proofs},
	month = feb,
	year = 2019,
	note = {\url{http://isa-afp.org/entries/Universal_Turing_Machine.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Universal_Turing_Machine/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Universal_Turing_Machine/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Universal_Turing_Machine/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Universal_Turing_Machine-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	- None
	+ <ul>
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Universal_Turing_Machine-2019-02-12.tar.gz">
	+ afp-Universal_Turing_Machine-2019-02-12.tar.gz
	+ </a>
	+ </li>
	+ </ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/UpDown_Scheme.html b/web/entries/UpDown_Scheme.html
	--- a/web/entries/UpDown_Scheme.html
	+++ b/web/entries/UpDown_Scheme.html
	@@ -1,212 +1,217 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Verification of the UpDown Scheme - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erification

	of

	the

	<font class="first">U</font>pDown

	<font class="first">S</font>cheme

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Verification of the UpDown Scheme</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-01-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	The UpDown scheme is a recursive scheme used to compute the stiffness matrix
	on a special form of sparse grids. Usually, when discretizing a Euclidean
	space of dimension d we need O(n^d) points, for n points along each dimension.
	Sparse grids are a hierarchical representation where the number of points is
	reduced to O(n * log(n)^d). One disadvantage of such sparse grids is that the
	algorithm now operate recursively in the dimensions and levels of the sparse grid.
	<p>
	The UpDown scheme allows us to compute the stiffness matrix on such a sparse
	grid. The stiffness matrix represents the influence of each representation
	function on the L^2 scalar product. For a detailed description see
	Dirk Pflüger's PhD thesis. This formalization was developed as an
	interdisciplinary project (IDP) at the Technische Universität München.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{UpDown_Scheme-AFP,
	author = {Johannes Hölzl},
	title = {Verification of the UpDown Scheme},
	journal = {Archive of Formal Proofs},
	month = jan,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/UpDown_Scheme.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Automatic_Refinement.html">Automatic_Refinement</a>, <a href="Separation_Logic_Imperative_HOL.html">Separation_Logic_Imperative_HOL</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/UpDown_Scheme/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/UpDown_Scheme/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/UpDown_Scheme/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-UpDown_Scheme-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-UpDown_Scheme-2018-08-16.tar.gz">
	+ afp-UpDown_Scheme-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-UpDown_Scheme-2017-10-10.tar.gz">
	afp-UpDown_Scheme-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-UpDown_Scheme-2016-12-17.tar.gz">
	afp-UpDown_Scheme-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-UpDown_Scheme-2016-02-22.tar.gz">
	afp-UpDown_Scheme-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-UpDown_Scheme-2015-05-27.tar.gz">
	afp-UpDown_Scheme-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-UpDown_Scheme-2015-01-30.tar.gz">
	afp-UpDown_Scheme-2015-01-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Valuation.html b/web/entries/Valuation.html
	--- a/web/entries/Valuation.html
	+++ b/web/entries/Valuation.html
	@@ -1,271 +1,276 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Fundamental Properties of Valuation Theory and Hensel's Lemma - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>undamental

	<font class="first">P</font>roperties

	of

	<font class="first">V</font>aluation

	<font class="first">T</font>heory

	and

	<font class="first">H</font>ensel's

	<font class="first">L</font>emma

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Fundamental Properties of Valuation Theory and Hensel's Lemma</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Hidetsune Kobayashi
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2007-08-08</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Convergence with respect to a valuation is discussed as convergence of a Cauchy sequence. Cauchy sequences of polynomials are defined. They are used to formalize Hensel's lemma.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Valuation-AFP,
	author = {Hidetsune Kobayashi},
	title = {Fundamental Properties of Valuation Theory and Hensel's Lemma},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2007,
	note = {\url{http://isa-afp.org/entries/Valuation.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Group-Ring-Module.html">Group-Ring-Module</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Valuation/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Valuation/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Valuation/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Valuation-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Valuation-2018-08-16.tar.gz">
	+ afp-Valuation-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Valuation-2017-10-10.tar.gz">
	afp-Valuation-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Valuation-2016-12-17.tar.gz">
	afp-Valuation-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Valuation-2016-02-22.tar.gz">
	afp-Valuation-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Valuation-2015-05-27.tar.gz">
	afp-Valuation-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Valuation-2014-08-28.tar.gz">
	afp-Valuation-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Valuation-2013-12-11.tar.gz">
	afp-Valuation-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Valuation-2013-11-17.tar.gz">
	afp-Valuation-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Valuation-2013-03-08.tar.gz">
	afp-Valuation-2013-03-08.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Valuation-2013-02-16.tar.gz">
	afp-Valuation-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Valuation-2012-05-24.tar.gz">
	afp-Valuation-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Valuation-2011-10-11.tar.gz">
	afp-Valuation-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Valuation-2011-02-11.tar.gz">
	afp-Valuation-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Valuation-2010-07-01.tar.gz">
	afp-Valuation-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Valuation-2009-12-12.tar.gz">
	afp-Valuation-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Valuation-2009-04-30.tar.gz">
	afp-Valuation-2009-04-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Valuation-2009-04-29.tar.gz">
	afp-Valuation-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Valuation-2008-06-10.tar.gz">
	afp-Valuation-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Valuation-2007-11-27.tar.gz">
	afp-Valuation-2007-11-27.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/VectorSpace.html b/web/entries/VectorSpace.html
	--- a/web/entries/VectorSpace.html
	+++ b/web/entries/VectorSpace.html
	@@ -1,204 +1,209 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Vector Spaces - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>ector

	<font class="first">S</font>paces

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Vector Spaces</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Holden Lee (holdenl /at/ princeton /dot/ edu)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-08-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">This formalisation of basic linear algebra is based completely on locales, building off HOL-Algebra. It includes basic definitions: linear combinations, span, linear independence; linear transformations; interpretation of function spaces as vector spaces; the direct sum of vector spaces, sum of subspaces; the replacement theorem; existence of bases in finite-dimensional; vector spaces, definition of dimension; the rank-nullity theorem. Some concepts are actually defined and proved for modules as they also apply there. Infinite-dimensional vector spaces are supported, but dimension is only supported for finite-dimensional vector spaces. The proofs are standard; the proofs of the replacement theorem and rank-nullity theorem roughly follow the presentation in Linear Algebra by Friedberg, Insel, and Spence. The rank-nullity theorem generalises the existing development in the Archive of Formal Proof (originally using type classes, now using a mix of type classes and locales).</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{VectorSpace-AFP,
	author = {Holden Lee},
	title = {Vector Spaces},
	journal = {Archive of Formal Proofs},
	month = aug,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/VectorSpace.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Deep_Learning.html">Deep_Learning</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/VectorSpace/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/VectorSpace/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/VectorSpace/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-VectorSpace-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-VectorSpace-2018-08-16.tar.gz">
	+ afp-VectorSpace-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-VectorSpace-2017-10-10.tar.gz">
	afp-VectorSpace-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-VectorSpace-2016-12-17.tar.gz">
	afp-VectorSpace-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-VectorSpace-2016-02-22.tar.gz">
	afp-VectorSpace-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-VectorSpace-2015-05-27.tar.gz">
	afp-VectorSpace-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-VectorSpace-2014-09-07.tar.gz">
	afp-VectorSpace-2014-09-07.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-VectorSpace-2014-08-31.tar.gz">
	afp-VectorSpace-2014-08-31.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-VectorSpace-2014-08-29.tar.gz">
	afp-VectorSpace-2014-08-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Verified-Prover.html b/web/entries/Verified-Prover.html
	--- a/web/entries/Verified-Prover.html
	+++ b/web/entries/Verified-Prover.html
	@@ -1,284 +1,289 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Mechanically Verified, Efficient, Sound and Complete Theorem Prover For First Order Logic - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">M</font>echanically

	<font class="first">V</font>erified,

	<font class="first">E</font>fficient,

	<font class="first">S</font>ound

	and

	<font class="first">C</font>omplete

	<font class="first">T</font>heorem

	<font class="first">P</font>rover

	<font class="first">F</font>or

	<font class="first">F</font>irst

	<font class="first">O</font>rder

	<font class="first">L</font>ogic

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Mechanically Verified, Efficient, Sound and Complete Theorem Prover For First Order Logic</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Tom Ridge
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2004-09-28</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Soundness and completeness for a system of first order logic are formally proved, building on James Margetson's formalization of work by Wainer and Wallen. The completeness proofs naturally suggest an algorithm to derive proofs. This algorithm, which can be implemented tail recursively, is formalized in Isabelle/HOL. The algorithm can be executed via the rewriting tactics of Isabelle. Alternatively, the definitions can be exported to OCaml, yielding a directly executable program.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Verified-Prover-AFP,
	author = {Tom Ridge},
	title = {A Mechanically Verified, Efficient, Sound and Complete Theorem Prover For First Order Logic},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2004,
	note = {\url{http://isa-afp.org/entries/Verified-Prover.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Verified-Prover/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Verified-Prover/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Verified-Prover/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Verified-Prover-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Verified-Prover-2018-08-16.tar.gz">
	+ afp-Verified-Prover-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Verified-Prover-2017-10-10.tar.gz">
	afp-Verified-Prover-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Verified-Prover-2016-12-17.tar.gz">
	afp-Verified-Prover-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Verified-Prover-2016-02-22.tar.gz">
	afp-Verified-Prover-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Verified-Prover-2015-05-27.tar.gz">
	afp-Verified-Prover-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Verified-Prover-2014-08-28.tar.gz">
	afp-Verified-Prover-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Verified-Prover-2013-12-11.tar.gz">
	afp-Verified-Prover-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Verified-Prover-2013-11-17.tar.gz">
	afp-Verified-Prover-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Verified-Prover-2013-03-02.tar.gz">
	afp-Verified-Prover-2013-03-02.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Verified-Prover-2013-02-16.tar.gz">
	afp-Verified-Prover-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Verified-Prover-2012-05-24.tar.gz">
	afp-Verified-Prover-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-Verified-Prover-2011-10-11.tar.gz">
	afp-Verified-Prover-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-Verified-Prover-2011-02-11.tar.gz">
	afp-Verified-Prover-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-Verified-Prover-2010-07-01.tar.gz">
	afp-Verified-Prover-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-Verified-Prover-2009-12-12.tar.gz">
	afp-Verified-Prover-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-Verified-Prover-2009-04-29.tar.gz">
	afp-Verified-Prover-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-Verified-Prover-2008-06-10.tar.gz">
	afp-Verified-Prover-2008-06-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2007:
	<a href="../release/afp-Verified-Prover-2007-11-27.tar.gz">
	afp-Verified-Prover-2007-11-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2005:
	<a href="../release/afp-Verified-Prover-2005-10-14.tar.gz">
	afp-Verified-Prover-2005-10-14.tar.gz
	</a>
	</li>
	<li>Isabelle 2004:
	<a href="../release/afp-Verified-Prover-2004-09-28.tar.gz">
	afp-Verified-Prover-2004-09-28.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/VerifyThis2018.html b/web/entries/VerifyThis2018.html
	--- a/web/entries/VerifyThis2018.html
	+++ b/web/entries/VerifyThis2018.html
	@@ -1,189 +1,194 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>VerifyThis 2018 - Polished Isabelle Solutions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>erifyThis

	<font class="first">2</font>018

	<font class="first">-</font>

	<font class="first">P</font>olished

	<font class="first">I</font>sabelle

	<font class="first">S</font>olutions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">VerifyThis 2018 - Polished Isabelle Solutions</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a> and
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-04-27</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<a
	href="http://www.pm.inf.ethz.ch/research/verifythis.html">VerifyThis
	2018</a> was a program verification competition associated with
	ETAPS 2018. It was the 7th event in the VerifyThis competition series.
	In this entry, we present polished and completed versions of our
	solutions that we created during the competition.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{VerifyThis2018-AFP,
	author = {Peter Lammich and Simon Wimmer},
	title = {VerifyThis 2018 - Polished Isabelle Solutions},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/VerifyThis2018.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Refine_Imperative_HOL.html">Refine_Imperative_HOL</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/VerifyThis2018/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/VerifyThis2018/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/VerifyThis2018/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-VerifyThis2018-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-VerifyThis2018-2018-08-16.tar.gz">
	+ afp-VerifyThis2018-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-VerifyThis2018-2018-04-30.tar.gz">
	afp-VerifyThis2018-2018-04-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Vickrey_Clarke_Groves.html b/web/entries/Vickrey_Clarke_Groves.html
	--- a/web/entries/Vickrey_Clarke_Groves.html
	+++ b/web/entries/Vickrey_Clarke_Groves.html
	@@ -1,217 +1,222 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>VCG - Combinatorial Vickrey-Clarke-Groves Auctions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">V</font>CG

	<font class="first">-</font>

	<font class="first">C</font>ombinatorial

	<font class="first">V</font>ickrey-Clarke-Groves

	<font class="first">A</font>uctions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">VCG - Combinatorial Vickrey-Clarke-Groves Auctions</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Marco B. Caminati,
	<a href="http://www.cs.bham.ac.uk/~mmk">Manfred Kerber</a>,
	Christoph Lange (math /dot/ semantic /dot/ web /at/ gmail /dot/ com) and
	Colin Rowat (c /dot/ rowat /at/ bham /dot/ ac /dot/ uk)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2015-04-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	A VCG auction (named after their inventors Vickrey, Clarke, and
	Groves) is a generalization of the single-good, second price Vickrey
	auction to the case of a combinatorial auction (multiple goods, from
	which any participant can bid on each possible combination). We
	formalize in this entry VCG auctions, including tie-breaking and prove
	that the functions for the allocation and the price determination are
	well-defined. Furthermore we show that the allocation function
	allocates goods only to participants, only goods in the auction are
	allocated, and no good is allocated twice. We also show that the price
	function is non-negative. These properties also hold for the
	automatically extracted Scala code.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Vickrey_Clarke_Groves-AFP,
	author = {Marco B. Caminati and Manfred Kerber and Christoph Lange and Colin Rowat},
	title = {VCG - Combinatorial Vickrey-Clarke-Groves Auctions},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2015,
	note = {\url{http://isa-afp.org/entries/Vickrey_Clarke_Groves.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Vickrey_Clarke_Groves/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Vickrey_Clarke_Groves/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Vickrey_Clarke_Groves/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Vickrey_Clarke_Groves-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Vickrey_Clarke_Groves-2018-08-16.tar.gz">
	+ afp-Vickrey_Clarke_Groves-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Vickrey_Clarke_Groves-2017-10-10.tar.gz">
	afp-Vickrey_Clarke_Groves-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Vickrey_Clarke_Groves-2016-12-17.tar.gz">
	afp-Vickrey_Clarke_Groves-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Vickrey_Clarke_Groves-2016-02-22.tar.gz">
	afp-Vickrey_Clarke_Groves-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Vickrey_Clarke_Groves-2015-05-27.tar.gz">
	afp-Vickrey_Clarke_Groves-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Vickrey_Clarke_Groves-2015-05-09.tar.gz">
	afp-Vickrey_Clarke_Groves-2015-05-09.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Vickrey_Clarke_Groves-2015-04-30.tar.gz">
	afp-Vickrey_Clarke_Groves-2015-04-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/VolpanoSmith.html b/web/entries/VolpanoSmith.html
	--- a/web/entries/VolpanoSmith.html
	+++ b/web/entries/VolpanoSmith.html
	@@ -1,257 +1,262 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Correctness Proof for the Volpano/Smith Security Typing System - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">C</font>orrectness

	<font class="first">P</font>roof

	for

	the

	<font class="first">V</font>olpano/Smith

	<font class="first">S</font>ecurity

	<font class="first">T</font>yping

	<font class="first">S</font>ystem

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Correctness Proof for the Volpano/Smith Security Typing System</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="http://pp.info.uni-karlsruhe.de/personhp/gregor_snelting.php">Gregor Snelting</a> and
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2008-09-02</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">The Volpano/Smith/Irvine security type systems requires that variables are annotated as high (secret) or low (public), and provides typing rules which guarantee that secret values cannot leak to public output ports. This property of a program is called confidentiality. For a simple while-language without threads, our proof shows that typeability in the Volpano/Smith system guarantees noninterference. Noninterference means that if two initial states for program execution are low-equivalent, then the final states are low-equivalent as well. This indeed implies that secret values cannot leak to public ports. The proof defines an abstract syntax and operational semantics for programs, formalizes noninterference, and then proceeds by rule induction on the operational semantics. The mathematically most intricate part is the treatment of implicit flows. Note that the Volpano/Smith system is not flow-sensitive and thus quite unprecise, resulting in false alarms. However, due to the correctness property, all potential breaks of confidentiality are discovered.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{VolpanoSmith-AFP,
	author = {Gregor Snelting and Daniel Wasserrab},
	title = {A Correctness Proof for the Volpano/Smith Security Typing System},
	journal = {Archive of Formal Proofs},
	month = sep,
	year = 2008,
	note = {\url{http://isa-afp.org/entries/VolpanoSmith.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/VolpanoSmith/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/VolpanoSmith/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/VolpanoSmith/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-VolpanoSmith-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-VolpanoSmith-2018-08-16.tar.gz">
	+ afp-VolpanoSmith-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-VolpanoSmith-2017-10-10.tar.gz">
	afp-VolpanoSmith-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-VolpanoSmith-2016-12-17.tar.gz">
	afp-VolpanoSmith-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-VolpanoSmith-2016-02-22.tar.gz">
	afp-VolpanoSmith-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-VolpanoSmith-2015-05-27.tar.gz">
	afp-VolpanoSmith-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-VolpanoSmith-2014-08-28.tar.gz">
	afp-VolpanoSmith-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-VolpanoSmith-2013-12-11.tar.gz">
	afp-VolpanoSmith-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-VolpanoSmith-2013-11-17.tar.gz">
	afp-VolpanoSmith-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-VolpanoSmith-2013-02-16.tar.gz">
	afp-VolpanoSmith-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-VolpanoSmith-2012-05-24.tar.gz">
	afp-VolpanoSmith-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-VolpanoSmith-2011-10-11.tar.gz">
	afp-VolpanoSmith-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-VolpanoSmith-2011-02-11.tar.gz">
	afp-VolpanoSmith-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-VolpanoSmith-2010-07-01.tar.gz">
	afp-VolpanoSmith-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-VolpanoSmith-2009-12-12.tar.gz">
	afp-VolpanoSmith-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-VolpanoSmith-2009-04-29.tar.gz">
	afp-VolpanoSmith-2009-04-29.tar.gz
	</a>
	</li>
	<li>Isabelle 2008:
	<a href="../release/afp-VolpanoSmith-2008-09-05.tar.gz">
	afp-VolpanoSmith-2008-09-05.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/WHATandWHERE_Security.html b/web/entries/WHATandWHERE_Security.html
	--- a/web/entries/WHATandWHERE_Security.html
	+++ b/web/entries/WHATandWHERE_Security.html
	@@ -1,236 +1,241 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>A Formalization of Declassification with WHAT-and-WHERE-Security - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">A</font>

	<font class="first">F</font>ormalization

	of

	<font class="first">D</font>eclassification

	with

	<font class="first">W</font>HAT-and-WHERE-Security

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">A Formalization of Declassification with WHAT-and-WHERE-Security</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Sylvia Grewe (grewe /at/ st /dot/ informatik /dot/ tu-darmstadt /dot/ de),
	Alexander Lux (lux /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de),
	Heiko Mantel (mantel /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de) and
	Jens Sauer (sauer /at/ mais /dot/ informatik /dot/ tu-darmstadt /dot/ de)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-04-23</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Research in information-flow security aims at developing methods to
	identify undesired information leaks within programs from private
	sources to public sinks. Noninterference captures this intuition by
	requiring that no information whatsoever flows from private sources
	to public sinks. However, in practice this definition is often too
	strict: Depending on the intuitive desired security policy, the
	controlled declassification of certain private information (WHAT) at
	certain points in the program (WHERE) might not result in an
	undesired information leak.
	<p>
	We present an Isabelle/HOL formalization of such a security property
	for controlled declassification, namely WHAT&WHERE-security from
	"Scheduler-Independent Declassification" by Lux, Mantel, and Perner.
	The formalization includes
	compositionality proofs for and a soundness proof for a security
	type system that checks for programs in a simple while language with
	dynamic thread creation.
	<p>
	Our formalization of the security type system is abstract in the
	language for expressions and in the semantic side conditions for
	expressions. It can easily be instantiated with different syntactic
	approximations for these side conditions. The soundness proof of
	such an instantiation boils down to showing that these syntactic
	approximations imply the semantic side conditions.
	<p>
	This Isabelle/HOL formalization uses theories from the entry
	Strong Security.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{WHATandWHERE_Security-AFP,
	author = {Sylvia Grewe and Alexander Lux and Heiko Mantel and Jens Sauer},
	title = {A Formalization of Declassification with WHAT-and-WHERE-Security},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/WHATandWHERE_Security.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Strong_Security.html">Strong_Security</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/WHATandWHERE_Security/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/WHATandWHERE_Security/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/WHATandWHERE_Security/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-WHATandWHERE_Security-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-WHATandWHERE_Security-2018-08-16.tar.gz">
	+ afp-WHATandWHERE_Security-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-WHATandWHERE_Security-2017-10-10.tar.gz">
	afp-WHATandWHERE_Security-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-WHATandWHERE_Security-2016-12-17.tar.gz">
	afp-WHATandWHERE_Security-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-WHATandWHERE_Security-2016-02-22.tar.gz">
	afp-WHATandWHERE_Security-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-WHATandWHERE_Security-2015-05-27.tar.gz">
	afp-WHATandWHERE_Security-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-WHATandWHERE_Security-2014-08-28.tar.gz">
	afp-WHATandWHERE_Security-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-WHATandWHERE_Security-2014-04-24.tar.gz">
	afp-WHATandWHERE_Security-2014-04-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/WebAssembly.html b/web/entries/WebAssembly.html
	--- a/web/entries/WebAssembly.html
	+++ b/web/entries/WebAssembly.html
	@@ -1,183 +1,188 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>WebAssembly - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">W</font>ebAssembly

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">WebAssembly</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://www.cl.cam.ac.uk/~caw77/">Conrad Watt</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-04-29</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This is a mechanised specification of the WebAssembly language, drawn
	mainly from the previously published paper formalisation of Haas et
	al. Also included is a full proof of soundness of the type system,
	together with a verified type checker and interpreter. We include only
	a partial procedure for the extraction of the type checker and
	interpreter here. For more details, please see our paper in CPP 2018.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{WebAssembly-AFP,
	author = {Conrad Watt},
	title = {WebAssembly},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/WebAssembly.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Native_Word.html">Native_Word</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/WebAssembly/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/WebAssembly/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/WebAssembly/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-WebAssembly-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-WebAssembly-2018-08-16.tar.gz">
	+ afp-WebAssembly-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-WebAssembly-2018-04-30.tar.gz">
	afp-WebAssembly-2018-04-30.tar.gz
	</a>
	</li>
	<li>Isabelle 2017:
	<a href="../release/afp-WebAssembly-2018-04-29.tar.gz">
	afp-WebAssembly-2018-04-29.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Weight_Balanced_Trees.html b/web/entries/Weight_Balanced_Trees.html
	--- a/web/entries/Weight_Balanced_Trees.html
	+++ b/web/entries/Weight_Balanced_Trees.html
	@@ -1,181 +1,186 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Weight-Balanced Trees - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">W</font>eight-Balanced

	<font class="first">T</font>rees

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Weight-Balanced Trees</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a> and
	Stefan Dirix
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2018-03-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This theory provides a verified implementation of weight-balanced
	trees following the work of <a
	href="https://doi.org/10.1017/S0956796811000104">Hirai
	and Yamamoto</a> who proved that all parameters in a certain
	range are valid, i.e. guarantee that insertion and deletion preserve
	weight-balance. Instead of a general theorem we provide parameterized
	proofs of preservation of the invariant that work for many (all?)
	valid parameters.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Weight_Balanced_Trees-AFP,
	author = {Tobias Nipkow and Stefan Dirix},
	title = {Weight-Balanced Trees},
	journal = {Archive of Formal Proofs},
	month = mar,
	year = 2018,
	note = {\url{http://isa-afp.org/entries/Weight_Balanced_Trees.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Weight_Balanced_Trees/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Weight_Balanced_Trees/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Weight_Balanced_Trees/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Weight_Balanced_Trees-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Weight_Balanced_Trees-2018-08-16.tar.gz">
	+ afp-Weight_Balanced_Trees-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Weight_Balanced_Trees-2018-03-13.tar.gz">
	afp-Weight_Balanced_Trees-2018-03-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Well_Quasi_Orders.html b/web/entries/Well_Quasi_Orders.html
	--- a/web/entries/Well_Quasi_Orders.html
	+++ b/web/entries/Well_Quasi_Orders.html
	@@ -1,241 +1,246 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Well-Quasi-Orders - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">W</font>ell-Quasi-Orders

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Well-Quasi-Orders</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2012-04-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="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:
	<ul>
	<li>If the sets A and B are wqo then their Cartesian product is wqo.</li>
	<li>If the set A is wqo then the set of finite lists over A is wqo.</li>
	<li>If the set A is wqo then the set of finite trees over A is wqo.</li>
	</ul>
	The research was funded by the Austrian Science Fund (FWF): J3202.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Change history:</td>
	<td class="abstract">[2012-06-11]: Added Kruskal's Tree Theorem.<br>
	[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.<br>
	[2013-05-16]: Simplified construction of minimal bad sequences.<br>
	[2014-07-09]: Simplified proofs of Higman's lemma and Kruskal's tree theorem,
	based on homogeneous sequences.<br>
	[2016-01-03]: An alternative proof of Higman's lemma by open induction.<br>
	[2017-06-08]: Proved (classical) equivalence to inductive definition of
	almost-full relations according to the ITP 2012 paper "Stop When You Are
	Almost-Full" by Vytiniotis, Coquand, and Wahlstedt.</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Well_Quasi_Orders-AFP,
	author = {Christian Sternagel},
	title = {Well-Quasi-Orders},
	journal = {Archive of Formal Proofs},
	month = apr,
	year = 2012,
	note = {\url{http://isa-afp.org/entries/Well_Quasi_Orders.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Abstract-Rewriting.html">Abstract-Rewriting</a>, <a href="Open_Induction.html">Open_Induction</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Decreasing-Diagrams-II.html">Decreasing-Diagrams-II</a>, <a href="Myhill-Nerode.html">Myhill-Nerode</a>, <a href="Polynomials.html">Polynomials</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Well_Quasi_Orders/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Well_Quasi_Orders/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Well_Quasi_Orders/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Well_Quasi_Orders-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Well_Quasi_Orders-2018-08-16.tar.gz">
	+ afp-Well_Quasi_Orders-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Well_Quasi_Orders-2017-10-10.tar.gz">
	afp-Well_Quasi_Orders-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Well_Quasi_Orders-2016-12-17.tar.gz">
	afp-Well_Quasi_Orders-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Well_Quasi_Orders-2016-02-22.tar.gz">
	afp-Well_Quasi_Orders-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-Well_Quasi_Orders-2015-05-27.tar.gz">
	afp-Well_Quasi_Orders-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-Well_Quasi_Orders-2014-08-28.tar.gz">
	afp-Well_Quasi_Orders-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-Well_Quasi_Orders-2013-12-11.tar.gz">
	afp-Well_Quasi_Orders-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-Well_Quasi_Orders-2013-11-17.tar.gz">
	afp-Well_Quasi_Orders-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-Well_Quasi_Orders-2013-02-16.tar.gz">
	afp-Well_Quasi_Orders-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-Well_Quasi_Orders-2012-05-24.tar.gz">
	afp-Well_Quasi_Orders-2012-05-24.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Winding_Number_Eval.html b/web/entries/Winding_Number_Eval.html
	--- a/web/entries/Winding_Number_Eval.html
	+++ b/web/entries/Winding_Number_Eval.html
	@@ -1,191 +1,196 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Evaluate Winding Numbers through Cauchy Indices - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">E</font>valuate

	<font class="first">W</font>inding

	<font class="first">N</font>umbers

	through

	<font class="first">C</font>auchy

	<font class="first">I</font>ndices

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Evaluate Winding Numbers through Cauchy Indices</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-10-17</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	In complex analysis, the winding number measures the number of times a
	path (counterclockwise) winds around a point, while the Cauchy index
	can approximate how the path winds. This entry provides a
	formalisation of the Cauchy index, which is then shown to be related
	to the winding number. In addition, this entry also offers a tactic
	that enables users to evaluate the winding number by calculating
	Cauchy indices.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Winding_Number_Eval-AFP,
	author = {Wenda Li},
	title = {Evaluate Winding Numbers through Cauchy Indices},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Winding_Number_Eval.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Budan_Fourier.html">Budan_Fourier</a>, <a href="Sturm_Tarski.html">Sturm_Tarski</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Count_Complex_Roots.html">Count_Complex_Roots</a>, <a href="Zeta_Function.html">Zeta_Function</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Winding_Number_Eval/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Winding_Number_Eval/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Winding_Number_Eval/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Winding_Number_Eval-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Winding_Number_Eval-2018-08-16.tar.gz">
	+ afp-Winding_Number_Eval-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Winding_Number_Eval-2017-10-18.tar.gz">
	afp-Winding_Number_Eval-2017-10-18.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Word_Lib.html b/web/entries/Word_Lib.html
	--- a/web/entries/Word_Lib.html
	+++ b/web/entries/Word_Lib.html
	@@ -1,203 +1,208 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Finite Machine Word Library - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">F</font>inite

	<font class="first">M</font>achine

	<font class="first">W</font>ord

	<font class="first">L</font>ibrary

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">Finite Machine Word Library</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Joel Beeren,
	Matthew Fernandez,
	Xin Gao,
	<a href="http://www.cse.unsw.edu.au/~kleing/">Gerwin Klein</a>,
	Rafal Kolanski,
	Japheth Lim,
	Corey Lewis,
	Daniel Matichuk and
	Thomas Sewell
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2016-06-09</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry contains an extension to the Isabelle library for
	fixed-width machine words. In particular, the entry adds quickcheck setup
	for words, printing as hexadecimals, additional operations, reasoning
	about alignment, signed words, enumerations of words, normalisation of
	word numerals, and an extensive library of properties about generic
	fixed-width words, as well as an instantiation of many of these to the
	commonly used 32 and 64-bit bases.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Word_Lib-AFP,
	author = {Joel Beeren and Matthew Fernandez and Xin Gao and Gerwin Klein and Rafal Kolanski and Japheth Lim and Corey Lewis and Daniel Matichuk and Thomas Sewell},
	title = {Finite Machine Word Library},
	journal = {Archive of Formal Proofs},
	month = jun,
	year = 2016,
	note = {\url{http://isa-afp.org/entries/Word_Lib.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>



	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Complx.html">Complx</a>, <a href="IEEE_Floating_Point.html">IEEE_Floating_Point</a>, <a href="IP_Addresses.html">IP_Addresses</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Word_Lib/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Word_Lib/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Word_Lib/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Word_Lib-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Word_Lib-2018-08-16.tar.gz">
	+ afp-Word_Lib-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Word_Lib-2017-10-10.tar.gz">
	afp-Word_Lib-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-Word_Lib-2016-12-17.tar.gz">
	afp-Word_Lib-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-Word_Lib-2016-06-09.tar.gz">
	afp-Word_Lib-2016-06-09.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/WorkerWrapper.html b/web/entries/WorkerWrapper.html
	--- a/web/entries/WorkerWrapper.html
	+++ b/web/entries/WorkerWrapper.html
	@@ -1,244 +1,249 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Worker/Wrapper Transformation - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">W</font>orker/Wrapper

	<font class="first">T</font>ransformation

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Worker/Wrapper Transformation</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2009-10-30</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">Gill and Hutton formalise the worker/wrapper transformation, building on the work of Launchbury and Peyton-Jones who developed it as a way of changing the type at which a recursive function operates. This development establishes the soundness of the technique and several examples of its use.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{WorkerWrapper-AFP,
	author = {Peter Gammie},
	title = {The Worker/Wrapper Transformation},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2009,
	note = {\url{http://isa-afp.org/entries/WorkerWrapper.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/WorkerWrapper/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/WorkerWrapper/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/WorkerWrapper/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-WorkerWrapper-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-WorkerWrapper-2018-08-16.tar.gz">
	+ afp-WorkerWrapper-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-WorkerWrapper-2017-10-10.tar.gz">
	afp-WorkerWrapper-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-WorkerWrapper-2016-12-17.tar.gz">
	afp-WorkerWrapper-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-WorkerWrapper-2016-02-22.tar.gz">
	afp-WorkerWrapper-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-WorkerWrapper-2015-05-27.tar.gz">
	afp-WorkerWrapper-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-WorkerWrapper-2014-08-28.tar.gz">
	afp-WorkerWrapper-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-WorkerWrapper-2013-12-11.tar.gz">
	afp-WorkerWrapper-2013-12-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-1:
	<a href="../release/afp-WorkerWrapper-2013-11-17.tar.gz">
	afp-WorkerWrapper-2013-11-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2013:
	<a href="../release/afp-WorkerWrapper-2013-02-16.tar.gz">
	afp-WorkerWrapper-2013-02-16.tar.gz
	</a>
	</li>
	<li>Isabelle 2012:
	<a href="../release/afp-WorkerWrapper-2012-05-24.tar.gz">
	afp-WorkerWrapper-2012-05-24.tar.gz
	</a>
	</li>
	<li>Isabelle 2011-1:
	<a href="../release/afp-WorkerWrapper-2011-10-11.tar.gz">
	afp-WorkerWrapper-2011-10-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2011:
	<a href="../release/afp-WorkerWrapper-2011-02-11.tar.gz">
	afp-WorkerWrapper-2011-02-11.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-2:
	<a href="../release/afp-WorkerWrapper-2010-07-01.tar.gz">
	afp-WorkerWrapper-2010-07-01.tar.gz
	</a>
	</li>
	<li>Isabelle 2009-1:
	<a href="../release/afp-WorkerWrapper-2009-12-12.tar.gz">
	afp-WorkerWrapper-2009-12-12.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-WorkerWrapper-2009-10-31.tar.gz">
	afp-WorkerWrapper-2009-10-31.tar.gz
	</a>
	</li>
	<li>Isabelle 2009:
	<a href="../release/afp-WorkerWrapper-2009-10-30.tar.gz">
	afp-WorkerWrapper-2009-10-30.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/XML.html b/web/entries/XML.html
	--- a/web/entries/XML.html
	+++ b/web/entries/XML.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>XML - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">X</font>ML

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">XML</td>
	</tr>

	<tr>
	<td class="datahead">
	Authors:
	</td>
	<td class="data">
	Christian Sternagel (c /dot/ sternagel /at/ gmail /dot/ com) and
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-10-03</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	This entry provides an XML library for Isabelle/HOL. This includes parsing
	and pretty printing of XML trees as well as combinators for transforming XML
	trees into arbitrary user-defined data. The main contribution of this entry is
	an interface (fit for code generation) that allows for communication between
	verified programs formalized in Isabelle/HOL and the outside world via XML.
	This library was developed as part of the IsaFoR/CeTA project
	to which we refer for examples of its usage.</td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{XML-AFP,
	author = {Christian Sternagel and René Thiemann},
	title = {XML},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/XML.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Certification_Monads.html">Certification_Monads</a>, <a href="Show.html">Show</a> </td></tr>




	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/XML/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/XML/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/XML/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-XML-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-XML-2018-08-16.tar.gz">
	+ afp-XML-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-XML-2017-10-10.tar.gz">
	afp-XML-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-XML-2016-12-17.tar.gz">
	afp-XML-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-XML-2016-02-22.tar.gz">
	afp-XML-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-XML-2015-05-27.tar.gz">
	afp-XML-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-XML-2014-10-08.tar.gz">
	afp-XML-2014-10-08.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/Zeta_Function.html b/web/entries/Zeta_Function.html
	--- a/web/entries/Zeta_Function.html
	+++ b/web/entries/Zeta_Function.html
	@@ -1,200 +1,205 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>The Hurwitz and Riemann ζ Functions - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> <font class="first">T</font>he

	<font class="first">H</font>urwitz

	and

	<font class="first">R</font>iemann

	ζ

	<font class="first">F</font>unctions

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">The Hurwitz and Riemann ζ Functions</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2017-10-12</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p> This entry builds upon the results about formal and analytic
	Dirichlet series to define the Hurwitz ζ function and, based
	on that, the Riemann ζ function. This is done by first
	defining them for &real;(<i>z</i>) > 1 and then
	successively extending the domain to the left using the
	Euler–MacLaurin formula. </p> <p> Some basic
	results about these functions are also shown, such as their
	analyticity on ℂ∖{1}, that they
	have a simple pole with residue 1 at 1, their relation to the
	Γ function, and the special values at negative integers and
	positive even integers – including the famous ζ(-1)
	= -1/12 and ζ(2) = π²/6. </p> <p>
	Lastly, the entry also contains Euler's analytic proof of the
	infinitude of primes, based on the fact that
	ζ(<i>s</i>) has a pole at <i>s</i> =
	1. </p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{Zeta_Function-AFP,
	author = {Manuel Eberl},
	title = {The Hurwitz and Riemann ζ Functions},
	journal = {Archive of Formal Proofs},
	month = oct,
	year = 2017,
	note = {\url{http://isa-afp.org/entries/Zeta_Function.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>


	<tr><td class="datahead">Depends on:</td>
	<td class="data"><a href="Bernoulli.html">Bernoulli</a>, <a href="Dirichlet_Series.html">Dirichlet_Series</a>, <a href="Euler_MacLaurin.html">Euler_MacLaurin</a>, <a href="Winding_Number_Eval.html">Winding_Number_Eval</a> </td></tr>

	<tr><td class="datahead">Used by:</td>
	<td class="data"><a href="Dirichlet_L.html">Dirichlet_L</a>, <a href="Prime_Distribution_Elementary.html">Prime_Distribution_Elementary</a>, <a href="Prime_Number_Theorem.html">Prime_Number_Theorem</a> </td></tr>



	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Zeta_Function/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/Zeta_Function/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/Zeta_Function/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-Zeta_Function-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-Zeta_Function-2018-08-16.tar.gz">
	+ afp-Zeta_Function-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-Zeta_Function-2017-10-16.tar.gz">
	afp-Zeta_Function-2017-10-16.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/entries/pGCL.html b/web/entries/pGCL.html
	--- a/web/entries/pGCL.html
	+++ b/web/entries/pGCL.html
	@@ -1,207 +1,212 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>pGCL for Isabelle - Archive of Formal Proofs
	</title>
	<link rel="stylesheet" type="text/css" href="../front.css">
	<link rel="icon" href="../images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="../images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="../index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="../download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1> pGCL

	for

	<font class="first">I</font>sabelle

	</h1>
	<p> </p>

	<table width="80%" class="data">
	<tbody>
	<tr>
	<td class="datahead" width="20%">Title:</td>
	<td class="data" width="80%">pGCL for Isabelle</td>
	</tr>

	<tr>
	<td class="datahead">
	Author:
	</td>
	<td class="data">
	David Cock (david /dot/ cock /at/ nicta /dot/ com /dot/ au)
	</td>
	</tr>



	<tr>
	<td class="datahead">Submission date:</td>
	<td class="data">2014-07-13</td>
	</tr>

	<tr>
	<td class="datahead" valign="top">Abstract:</td>
	<td class="abstract">
	<p>pGCL is both a programming language and a specification language that
	incorporates both probabilistic and nondeterministic choice, in a unified
	manner. Program verification is by refinement or annotation (or both), using
	either Hoare triples, or weakest-precondition entailment, in the style of
	GCL.</p>
	<p> This package provides both a shallow embedding of the language
	primitives, and an annotation and refinement framework. The generated
	document includes a brief tutorial.</p></td>
	</tr>


	<tr>
	<td class="datahead" valign="top">BibTeX:</td>
	<td class="formatted">
	<pre>@article{pGCL-AFP,
	author = {David Cock},
	title = {pGCL for Isabelle},
	journal = {Archive of Formal Proofs},
	month = jul,
	year = 2014,
	note = {\url{http://isa-afp.org/entries/pGCL.html},
	Formal proof development},
	ISSN = {2150-914x},
	}</pre>
	</td>
	</tr>

	<tr><td class="datahead">License:</td>
	<td class="data"><a href="http://isa-afp.org/LICENSE">BSD License</a></td></tr>






	</tbody>
	</table>

	<p></p>

	<table class="links">
	<tbody>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/pGCL/outline.pdf">Proof outline</a><br>
	<a href="../browser_info/current/AFP/pGCL/document.pdf">Proof document</a>
	</td>
	</tr>
	<tr>
	<td class="links">
	<a href="../browser_info/current/AFP/pGCL/index.html">Browse theories</a>
	</td></tr>
	<tr>
	<td class="links">
	<a href="../release/afp-pGCL-current.tar.gz">Download this entry</a>
	</td>
	</tr>


	<tr><td class="links">Older releases:
	<ul>
	- <li>Isabelle 2017:
	+ <li>Isabelle 2018:
	+ <a href="../release/afp-pGCL-2018-08-16.tar.gz">
	+ afp-pGCL-2018-08-16.tar.gz
	+ </a>
	+ </li>
	+ <li>Isabelle 2017:
	<a href="../release/afp-pGCL-2017-10-10.tar.gz">
	afp-pGCL-2017-10-10.tar.gz
	</a>
	</li>
	<li>Isabelle 2016-1:
	<a href="../release/afp-pGCL-2016-12-17.tar.gz">
	afp-pGCL-2016-12-17.tar.gz
	</a>
	</li>
	<li>Isabelle 2016:
	<a href="../release/afp-pGCL-2016-02-22.tar.gz">
	afp-pGCL-2016-02-22.tar.gz
	</a>
	</li>
	<li>Isabelle 2015:
	<a href="../release/afp-pGCL-2015-05-27.tar.gz">
	afp-pGCL-2015-05-27.tar.gz
	</a>
	</li>
	<li>Isabelle 2014:
	<a href="../release/afp-pGCL-2014-08-28.tar.gz">
	afp-pGCL-2014-08-28.tar.gz
	</a>
	</li>
	<li>Isabelle 2013-2:
	<a href="../release/afp-pGCL-2014-07-13.tar.gz">
	afp-pGCL-2014-07-13.tar.gz
	</a>
	</li>
	</ul>
	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="../jquery.min.js"></script>
	<script src="../script.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/index.html b/web/index.html
	--- a/web/index.html
	+++ b/web/index.html
	@@ -1,4386 +1,4420 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Archive of Formal Proofs</title>
	<link rel="stylesheet" type="text/css" href="front.css">
	<link rel="icon" href="images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1><font class="first">A</font>rchive of
	<font class="first">F</font>ormal
	<font class="first">P</font>roofs</h1>
	</h1>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td>
	The Archive of Formal Proofs is a collection of proof libraries, examples, and larger scientific developments,
	mechanically checked in the theorem prover <a href="http://isabelle.in.tum.de/">Isabelle</a>. It is organized in the way
	of a scientific journal, is indexed by <a href="http://dblp.uni-trier.de/db/journals/afp/">dblp</a> and has an ISSN:
	2150-914x. Submissions are refereed. The preferred citation style is available <a href="citing.html">[here]</a>. We encourage companion AFP submissions to conference and journal publications.
	<br><br>A <a href="http://devel.isa-afp.org">development version</a> of the archive is available as well. </td>
	</tr>
	</tbody>
	</table>

	<p> </p>

	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2019</td>
	</tr>
	<tr>
	<td class="entry">
	+ 2019-06-21: <a href="entries/Linear_Inequalities.html">Linear Inequalities</a>
	+ <br>
	+ Authors:
	+ <a href="http://cl-informatik.uibk.ac.at/users/bottesch/">Ralph Bottesch</a>,
	+ Alban Reynaud
	+ and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	+ </td>
	+ </tr>
	+ <tr>
	+ <td class="entry">
	+ 2019-06-16: <a href="entries/Nullstellensatz.html">Hilbert's Nullstellensatz</a>
	+ <br>
	+ Author:
	+ <a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>
	+ </td>
	+ </tr>
	+ <tr>
	+ <td class="entry">
	+ 2019-06-15: <a href="entries/Groebner_Macaulay.html">Gröbner Bases, Macaulay Matrices and Dubé's Degree Bounds</a>
	+ <br>
	+ Author:
	+ <a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>
	+ </td>
	+ </tr>
	+ <tr>
	+ <td class="entry">
	+ 2019-06-13: <a href="entries/IMP2_Binary_Heap.html">Binary Heaps for IMP2</a>
	+ <br>
	+ Author:
	+ Simon Griebel
	+ </td>
	+ </tr>
	+ <tr>
	+ <td class="entry">
	2019-05-30: <a href="entries/KD_Tree.html">Multidimensional Binary Search Trees</a>
	<br>
	Author:
	Martin Rau
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-05-14: <a href="entries/LambdaAuth.html">Formalization of Generic Authenticated Data Structures</a>
	<br>
	Authors:
	Matthias Brun
	and <a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-05-09: <a href="entries/Multi_Party_Computation.html">Multi-Party Computation</a>
	<br>
	Authors:
	<a href="http://homepages.inf.ed.ac.uk/da/">David Aspinall</a>
	and David Butler
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-04-26: <a href="entries/HOL-CSP.html">HOL-CSP Version 2.0</a>
	<br>
	Authors:
	Safouan Taha,
	Lina Ye
	and Burkhart Wolff
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-04-16: <a href="entries/LTL_Master_Theorem.html">A Compositional and Unified Translation of LTL into ω-Automata</a>
	<br>
	Authors:
	Benedikt Seidl
	and Salomon Sickert
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-04-06: <a href="entries/Binding_Syntax_Theory.html">A General Theory of Syntax with Bindings</a>
	<br>
	Authors:
	Lorenzo Gheri
	and Andrei Popescu
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-03-27: <a href="entries/Transcendence_Series_Hancl_Rucki.html">The Transcendence of Certain Infinite Series</a>
	<br>
	Authors:
	<a href="https://www.cl.cam.ac.uk/~ak2110/">Angeliki Koutsoukou-Argyraki</a>
	and <a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-03-24: <a href="entries/QHLProver.html">Quantum Hoare Logic</a>
	<br>
	Authors:
	Junyi Liu,
	<a href="http://lcs.ios.ac.cn/~bzhan/">Bohua Zhan</a>,
	Shuling Wang,
	Shenggang Ying,
	Tao Liu,
	Yangjia Li,
	Mingsheng Ying
	and Naijun Zhan
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-03-09: <a href="entries/Safe_OCL.html">Safe OCL</a>
	<br>
	Author:
	Denis Nikiforov
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-02-21: <a href="entries/Prime_Distribution_Elementary.html">Elementary Facts About the Distribution of Primes</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-02-14: <a href="entries/Kruskal.html">Kruskal's Algorithm for Minimum Spanning Forest</a>
	<br>
	Authors:
	<a href="http://in.tum.de/~haslbema/">Maximilian P.L. Haslbeck</a>,
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and Julian Biendarra
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-02-11: <a href="entries/Probabilistic_Prime_Tests.html">Probabilistic Primality Testing</a>
	<br>
	Authors:
	Daniel Stüwe
	and <a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-02-08: <a href="entries/Universal_Turing_Machine.html">Universal Turing Machine</a>
	<br>
	Authors:
	Jian Xu,
	Xingyuan Zhang,
	<a href="http://www.inf.kcl.ac.uk/staff/urbanc/">Christian Urban</a>
	and Sebastiaan J. C. Joosten
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-02-01: <a href="entries/UTP.html">Isabelle/UTP: Mechanised Theory Engineering for Unifying Theories of Programming</a>
	<br>
	Authors:
	<a href="https://www-users.cs.york.ac.uk/~simonf/">Simon Foster</a>,
	Frank Zeyda,
	Yakoub Nemouchi,
	Pedro Ribeiro
	and Burkhart Wolff
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-02-01: <a href="entries/List_Inversions.html">The Inversions of a List</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-01-17: <a href="entries/Farkas.html">Farkas' Lemma and Motzkin's Transposition Theorem</a>
	<br>
	Authors:
	<a href="http://cl-informatik.uibk.ac.at/users/bottesch/">Ralph Bottesch</a>,
	<a href="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Max W. Haslbeck</a>
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-01-15: <a href="entries/IMP2.html">IMP2 – Simple Program Verification in Isabelle/HOL</a>
	<br>
	Authors:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and <a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-01-15: <a href="entries/Higher_Order_Terms.html">An Algebra for Higher-Order Terms</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2019-01-07: <a href="entries/Store_Buffer_Reduction.html">A Reduction Theorem for Store Buffers</a>
	<br>
	Authors:
	Ernie Cohen
	and Norbert Schirmer
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2018</td>
	</tr>
	<tr>
	<td class="entry">
	2018-12-26: <a href="entries/Core_DOM.html">A Formal Model of the Document Object Model</a>
	<br>
	Authors:
	<a href="https://www.brucker.ch/">Achim D. Brucker</a>
	and <a href="http://www.dcs.shef.ac.uk/cgi-bin/makeperson?M.Herzberg">Michael Herzberg</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-12-25: <a href="entries/Concurrent_Revisions.html">Formalization of Concurrent Revisions</a>
	<br>
	Author:
	Roy Overbeek
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-12-21: <a href="entries/Auto2_Imperative_HOL.html">Verifying Imperative Programs using Auto2</a>
	<br>
	Author:
	<a href="http://lcs.ios.ac.cn/~bzhan/">Bohua Zhan</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-12-17: <a href="entries/Constructive_Cryptography.html">Constructive Cryptography in HOL</a>
	<br>
	Authors:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	and S. Reza Sefidgar
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-12-11: <a href="entries/Transformer_Semantics.html">Transformer Semantics</a>
	<br>
	Author:
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-12-11: <a href="entries/Quantales.html">Quantales</a>
	<br>
	Author:
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-12-11: <a href="entries/Order_Lattice_Props.html">Properties of Orderings and Lattices</a>
	<br>
	Author:
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-11-23: <a href="entries/Graph_Saturation.html">Graph Saturation</a>
	<br>
	Author:
	Sebastiaan J. C. Joosten
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-11-23: <a href="entries/Functional_Ordered_Resolution_Prover.html">A Verified Functional Implementation of Bachmair and Ganzinger's Ordered Resolution Prover</a>
	<br>
	Authors:
	Anders Schlichtkrull,
	Jasmin Christian Blanchette
	and <a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-11-20: <a href="entries/Auto2_HOL.html">Auto2 Prover</a>
	<br>
	Author:
	<a href="http://lcs.ios.ac.cn/~bzhan/">Bohua Zhan</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-11-16: <a href="entries/Matroids.html">Matroids</a>
	<br>
	Author:
	Jonas Keinholz
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-11-06: <a href="entries/Generic_Deriving.html">Deriving generic class instances for datatypes</a>
	<br>
	Authors:
	Jonas Rädle
	and <a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-10-30: <a href="entries/GewirthPGCProof.html">Formalisation and Evaluation of Alan Gewirth's Proof for the Principle of Generic Consistency in Isabelle/HOL</a>
	<br>
	Authors:
	David Fuenmayor
	and <a href="http://christoph-benzmueller.de">Christoph Benzmüller</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-10-29: <a href="entries/Epistemic_Logic.html">Epistemic Logic</a>
	<br>
	Author:
	<a href="http://www.student.dtu.dk/~s144442/">Andreas Halkjær From</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-10-22: <a href="entries/Smooth_Manifolds.html">Smooth Manifolds</a>
	<br>
	Authors:
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
	and <a href="http://lcs.ios.ac.cn/~bzhan/">Bohua Zhan</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-10-19: <a href="entries/Randomised_BSTs.html">Randomised Binary Search Trees</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-10-19: <a href="entries/Lambda_Free_EPO.html">Formalization of the Embedding Path Order for Lambda-Free Higher-Order Terms</a>
	<br>
	Author:
	Alexander Bentkamp
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-10-12: <a href="entries/Factored_Transition_System_Bounding.html">Upper Bounding Diameters of State Spaces of Factored Transition Systems</a>
	<br>
	Authors:
	Friedrich Kurz
	and <a href="http://home.in.tum.de/~mansour/">Mohammad Abdulaziz</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-09-28: <a href="entries/Pi_Transcendental.html">The Transcendence of π</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-09-25: <a href="entries/Symmetric_Polynomials.html">Symmetric Polynomials</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-09-20: <a href="entries/Signature_Groebner.html">Signature-Based Gröbner Basis Algorithms</a>
	<br>
	Author:
	<a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-09-19: <a href="entries/Prime_Number_Theorem.html">The Prime Number Theorem</a>
	<br>
	Authors:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	and <a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-09-15: <a href="entries/Aggregation_Algebras.html">Aggregation Algebras</a>
	<br>
	Author:
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-09-14: <a href="entries/Octonions.html">Octonions</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~ak2110/">Angeliki Koutsoukou-Argyraki</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-09-05: <a href="entries/Quaternions.html">Quaternions</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-09-02: <a href="entries/Budan_Fourier.html">The Budan-Fourier Theorem and Counting Real Roots with Multiplicity</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-08-24: <a href="entries/Simplex.html">An Incremental Simplex Algorithm with Unsatisfiable Core Generation</a>
	<br>
	Authors:
	Filip Marić,
	Mirko Spasić
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-08-14: <a href="entries/Minsky_Machines.html">Minsky Machines</a>
	<br>
	Author:
	Bertram Felgenhauer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-07-16: <a href="entries/DiscretePricing.html">Pricing in discrete financial models</a>
	<br>
	Author:
	<a href="http://lig-membres.imag.fr/mechenim/">Mnacho Echenim</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-07-04: <a href="entries/Neumann_Morgenstern_Utility.html">Von-Neumann-Morgenstern Utility Theorem</a>
	<br>
	Authors:
	Julian Parsert
	and <a href="http://cl-informatik.uibk.ac.at/users/cek/">Cezary Kaliszyk</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-06-23: <a href="entries/Pell.html">Pell's Equation</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-06-14: <a href="entries/Projective_Geometry.html">Projective Geometry</a>
	<br>
	Author:
	<a href="https://sites.google.com/site/anthonybordg/">Anthony Bordg</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-06-14: <a href="entries/Localization_Ring.html">The Localization of a Commutative Ring</a>
	<br>
	Author:
	<a href="https://sites.google.com/site/anthonybordg/">Anthony Bordg</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-06-05: <a href="entries/Partial_Order_Reduction.html">Partial Order Reduction</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~brunnerj/">Julian Brunner</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-05-27: <a href="entries/Optimal_BST.html">Optimal Binary Search Trees</a>
	<br>
	Authors:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	and Dániel Somogyi
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-05-25: <a href="entries/Hidden_Markov_Models.html">Hidden Markov Models</a>
	<br>
	Author:
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-05-24: <a href="entries/Probabilistic_Timed_Automata.html">Probabilistic Timed Automata</a>
	<br>
	Authors:
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	and <a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-05-23: <a href="entries/Irrationality_J_Hancl.html">Irrational Rapidly Convergent Series</a>
	<br>
	Authors:
	<a href="https://www.cl.cam.ac.uk/~ak2110/">Angeliki Koutsoukou-Argyraki</a>
	and <a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-05-23: <a href="entries/AxiomaticCategoryTheory.html">Axiom Systems for Category Theory in Free Logic</a>
	<br>
	Authors:
	<a href="http://christoph-benzmueller.de">Christoph Benzmüller</a>
	and <a href="http://www.cs.cmu.edu/~scott/">Dana Scott</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-05-22: <a href="entries/Monad_Memo_DP.html">Monadification, Memoization and Dynamic Programming</a>
	<br>
	Authors:
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>,
	Shuwei Hu
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-05-10: <a href="entries/OpSets.html">OpSets: Sequential Specifications for Replicated Datatypes</a>
	<br>
	Authors:
	Martin Kleppmann,
	Victor B. F. Gomes,
	Dominic P. Mulligan
	and Alastair R. Beresford
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-05-07: <a href="entries/Modular_Assembly_Kit_Security.html">An Isabelle/HOL Formalization of the Modular Assembly Kit for Security Properties</a>
	<br>
	Authors:
	Oliver Bračevac,
	Richard Gay,
	Sylvia Grewe,
	Heiko Mantel,
	Henning Sudbrock
	and Markus Tasch
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-04-29: <a href="entries/WebAssembly.html">WebAssembly</a>
	<br>
	Author:
	<a href="http://www.cl.cam.ac.uk/~caw77/">Conrad Watt</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-04-27: <a href="entries/VerifyThis2018.html">VerifyThis 2018 - Polished Isabelle Solutions</a>
	<br>
	Authors:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and <a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-04-24: <a href="entries/BNF_CC.html">Bounded Natural Functors with Covariance and Contravariance</a>
	<br>
	Authors:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	and Joshua Schneider
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-03-22: <a href="entries/Fishburn_Impossibility.html">The Incompatibility of Fishburn-Strategyproofness and Pareto-Efficiency</a>
	<br>
	Authors:
	<a href="http://dss.in.tum.de/staff/brandt.html">Felix Brandt</a>,
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>,
	<a href="http://dss.in.tum.de/staff/christian-saile.html">Christian Saile</a>
	and <a href="http://dss.in.tum.de/staff/christian-stricker.html">Christian Stricker</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-03-13: <a href="entries/Weight_Balanced_Trees.html">Weight-Balanced Trees</a>
	<br>
	Authors:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	and Stefan Dirix
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-03-12: <a href="entries/CakeML.html">CakeML</a>
	<br>
	Authors:
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	and Yu Zhang
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-03-01: <a href="entries/Architectural_Design_Patterns.html">A Theory of Architectural Design Patterns</a>
	<br>
	Author:
	<a href="http://marmsoler.com">Diego Marmsoler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-02-26: <a href="entries/Hoare_Time.html">Hoare Logics for Time Bounds</a>
	<br>
	Authors:
	<a href="http://www.in.tum.de/~haslbema">Maximilian P. L. Haslbeck</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-02-06: <a href="entries/Treaps.html">Treaps</a>
	<br>
	Authors:
	<a href="https://home.in.tum.de/~haslbecm">Maximilian Haslbeck</a>,
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-02-06: <a href="entries/LLL_Factorization.html">A verified factorization algorithm for integer polynomials with polynomial complexity</a>
	<br>
	Authors:
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
	<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	and Akihisa Yamada
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-02-06: <a href="entries/First_Order_Terms.html">First-Order Terms</a>
	<br>
	Authors:
	Christian Sternagel
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-02-06: <a href="entries/Error_Function.html">The Error Function</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-02-02: <a href="entries/LLL_Basis_Reduction.html">A verified LLL algorithm</a>
	<br>
	Authors:
	<a href="http://cl-informatik.uibk.ac.at/users/bottesch/">Ralph Bottesch</a>,
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
	<a href="https://home.in.tum.de/~haslbecm">Maximilian Haslbeck</a>,
	<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	and Akihisa Yamada
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-01-18: <a href="entries/Ordered_Resolution_Prover.html">Formalization of Bachmair and Ganzinger's Ordered Resolution Prover</a>
	<br>
	Authors:
	Anders Schlichtkrull,
	Jasmin Christian Blanchette,
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	and Uwe Waldmann
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-01-16: <a href="entries/Gromov_Hyperbolicity.html">Gromov Hyperbolicity</a>
	<br>
	Author:
	Sebastien Gouezel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-01-11: <a href="entries/Green.html">An Isabelle/HOL formalisation of Green's Theorem</a>
	<br>
	Authors:
	<a href="http://home.in.tum.de/~mansour/">Mohammad Abdulaziz</a>
	and <a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2018-01-08: <a href="entries/Taylor_Models.html">Taylor Models</a>
	<br>
	Authors:
	Christoph Traut
	and <a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2017</td>
	</tr>
	<tr>
	<td class="entry">
	2017-12-22: <a href="entries/Falling_Factorial_Sum.html">The Falling Factorial of a Sum</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-12-21: <a href="entries/Median_Of_Medians_Selection.html">The Median-of-Medians Selection Algorithm</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-12-21: <a href="entries/Mason_Stothers.html">The Mason–Stothers Theorem</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-12-21: <a href="entries/Dirichlet_L.html">Dirichlet L-Functions and Dirichlet's Theorem</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-12-19: <a href="entries/BNF_Operations.html">Operations on Bounded Natural Functors</a>
	<br>
	Authors:
	Jasmin Christian Blanchette,
	Andrei Popescu
	and <a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-12-18: <a href="entries/Knuth_Morris_Pratt.html">The string search algorithm by Knuth, Morris and Pratt</a>
	<br>
	Authors:
	Fabian Hellauer
	and <a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-11-22: <a href="entries/Stochastic_Matrices.html">Stochastic Matrices and the Perron-Frobenius Theorem</a>
	<br>
	Author:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-11-09: <a href="entries/IMAP-CRDT.html">The IMAP CmRDT</a>
	<br>
	Authors:
	Tim Jungnickel,
	Lennart Oldenburg
	and Matthias Loibl
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-11-06: <a href="entries/Hybrid_Multi_Lane_Spatial_Logic.html">Hybrid Multi-Lane Spatial Logic</a>
	<br>
	Author:
	Sven Linker
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-10-26: <a href="entries/Kuratowski_Closure_Complement.html">The Kuratowski Closure-Complement Theorem</a>
	<br>
	Authors:
	<a href="http://peteg.org">Peter Gammie</a>
	and Gianpaolo Gioiosa
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-10-19: <a href="entries/Transition_Systems_and_Automata.html">Transition Systems and Automata</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~brunnerj/">Julian Brunner</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-10-19: <a href="entries/Buchi_Complementation.html">Büchi Complementation</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~brunnerj/">Julian Brunner</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-10-17: <a href="entries/Winding_Number_Eval.html">Evaluate Winding Numbers through Cauchy Indices</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-10-17: <a href="entries/Count_Complex_Roots.html">Count the Number of Complex Roots</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-10-14: <a href="entries/Diophantine_Eqns_Lin_Hom.html">Homogeneous Linear Diophantine Equations</a>
	<br>
	Authors:
	Florian Messner,
	Julian Parsert,
	Jonas Schöpf
	and Christian Sternagel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-10-12: <a href="entries/Zeta_Function.html">The Hurwitz and Riemann ζ Functions</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-10-12: <a href="entries/Linear_Recurrences.html">Linear Recurrences</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-10-12: <a href="entries/Dirichlet_Series.html">Dirichlet Series</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-09-21: <a href="entries/Lowe_Ontological_Argument.html">Computer-assisted Reconstruction and Assessment of E. J. Lowe's Modal Ontological Argument</a>
	<br>
	Authors:
	David Fuenmayor
	and <a href="http://christoph-benzmueller.de">Christoph Benzmüller</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-09-17: <a href="entries/PLM.html">Representation and Partial Automation of the Principia Logico-Metaphysica in Isabelle/HOL</a>
	<br>
	Author:
	Daniel Kirchner
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-09-06: <a href="entries/AnselmGod.html">Anselm's God in Isabelle/HOL</a>
	<br>
	Author:
	<a href="https://philpapers.org/profile/805">Ben Blumson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-09-01: <a href="entries/First_Welfare_Theorem.html">Microeconomics and the First Welfare Theorem</a>
	<br>
	Authors:
	Julian Parsert
	and <a href="http://cl-informatik.uibk.ac.at/users/cek/">Cezary Kaliszyk</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-08-20: <a href="entries/Root_Balanced_Tree.html">Root-Balanced Tree</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-08-20: <a href="entries/Orbit_Stabiliser.html">Orbit-Stabiliser Theorem with Application to Rotational Symmetries</a>
	<br>
	Author:
	Jonas Rädle
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-08-16: <a href="entries/LambdaMu.html">The LambdaMu-calculus</a>
	<br>
	Authors:
	Cristina Matache,
	Victor B. F. Gomes
	and Dominic P. Mulligan
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-07-31: <a href="entries/Stewart_Apollonius.html">Stewart's Theorem and Apollonius' Theorem</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-07-28: <a href="entries/DynamicArchitectures.html">Dynamic Architectures</a>
	<br>
	Author:
	<a href="http://marmsoler.com">Diego Marmsoler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-07-21: <a href="entries/Decl_Sem_Fun_PL.html">Declarative Semantics for Functional Languages</a>
	<br>
	Author:
	<a href="http://homes.soic.indiana.edu/jsiek/">Jeremy Siek</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-07-15: <a href="entries/HOLCF-Prelude.html">HOLCF-Prelude</a>
	<br>
	Authors:
	Joachim Breitner,
	Brian Huffman,
	Neil Mitchell
	and Christian Sternagel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-07-13: <a href="entries/Minkowskis_Theorem.html">Minkowski's Theorem</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-07-09: <a href="entries/Name_Carrying_Type_Inference.html">Verified Metatheory and Type Inference for a Name-Carrying Simply-Typed Lambda Calculus</a>
	<br>
	Author:
	Michael Rawson
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-07-07: <a href="entries/CRDT.html">A framework for establishing Strong Eventual Consistency for Conflict-free Replicated Datatypes</a>
	<br>
	Authors:
	Victor B. F. Gomes,
	Martin Kleppmann,
	Dominic P. Mulligan
	and Alastair R. Beresford
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-07-06: <a href="entries/Stone_Kleene_Relation_Algebras.html">Stone-Kleene Relation Algebras</a>
	<br>
	Author:
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-06-21: <a href="entries/Propositional_Proof_Systems.html">Propositional Proof Systems</a>
	<br>
	Authors:
	<a href="http://liftm.de">Julius Michaelis</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-06-13: <a href="entries/PSemigroupsConvolution.html">Partial Semigroups and Convolution Algebras</a>
	<br>
	Authors:
	Brijesh Dongol,
	Victor B. F. Gomes,
	Ian J. Hayes
	and <a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-06-06: <a href="entries/Buffons_Needle.html">Buffon's Needle Problem</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-06-01: <a href="entries/Prpu_Maxflow.html">Formalizing Push-Relabel Algorithms</a>
	<br>
	Authors:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and S. Reza Sefidgar
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-06-01: <a href="entries/Flow_Networks.html">Flow Networks and the Min-Cut-Max-Flow Theorem</a>
	<br>
	Authors:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and S. Reza Sefidgar
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-25: <a href="entries/Optics.html">Optics</a>
	<br>
	Authors:
	<a href="https://www-users.cs.york.ac.uk/~simonf/">Simon Foster</a>
	and Frank Zeyda
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-24: <a href="entries/Security_Protocol_Refinement.html">Developing Security Protocols by Refinement</a>
	<br>
	Authors:
	Christoph Sprenger
	and Ivano Somaini
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-24: <a href="entries/Dict_Construction.html">Dictionary Construction</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-08: <a href="entries/Floyd_Warshall.html">The Floyd-Warshall Algorithm for Shortest Paths</a>
	<br>
	Authors:
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	and <a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-05: <a href="entries/Probabilistic_While.html">Probabilistic while loop</a>
	<br>
	Author:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-05: <a href="entries/Monomorphic_Monad.html">Effect polymorphism in higher-order logic</a>
	<br>
	Author:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-05: <a href="entries/Monad_Normalisation.html">Monad normalisation</a>
	<br>
	Authors:
	Joshua Schneider,
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	and <a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-05: <a href="entries/Game_Based_Crypto.html">Game-based cryptography in HOL</a>
	<br>
	Authors:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>,
	S. Reza Sefidgar
	and Bhargav Bhatt
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-05: <a href="entries/CryptHOL.html">CryptHOL</a>
	<br>
	Author:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-04: <a href="entries/MonoidalCategory.html">Monoidal Categories</a>
	<br>
	Author:
	Eugene W. Stark
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-05-01: <a href="entries/Types_Tableaus_and_Goedels_God.html">Types, Tableaus and Gödel’s God in Isabelle/HOL</a>
	<br>
	Authors:
	David Fuenmayor
	and <a href="http://christoph-benzmueller.de">Christoph Benzmüller</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-04-28: <a href="entries/LocalLexing.html">Local Lexing</a>
	<br>
	Author:
	Steven Obua
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-04-19: <a href="entries/Constructor_Funs.html">Constructor Functions</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-04-18: <a href="entries/Lazy_Case.html">Lazifying case constants</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-04-06: <a href="entries/Subresultants.html">Subresultants</a>
	<br>
	Authors:
	<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	and Akihisa Yamada
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-04-04: <a href="entries/Random_BSTs.html">Expected Shape of Random Binary Search Trees</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-03-15: <a href="entries/Quick_Sort_Cost.html">The number of comparisons in QuickSort</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-03-15: <a href="entries/Comparison_Sort_Lower_Bound.html">Lower bound on comparison-based sorting algorithms</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-03-10: <a href="entries/Euler_MacLaurin.html">The Euler–MacLaurin Formula</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-02-28: <a href="entries/Elliptic_Curves_Group_Law.html">The Group Law for Elliptic Curves</a>
	<br>
	Author:
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-02-26: <a href="entries/Menger.html">Menger's Theorem</a>
	<br>
	Author:
	<a href="http://logic.las.tu-berlin.de/Members/Dittmann/">Christoph Dittmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-02-13: <a href="entries/Differential_Dynamic_Logic.html">Differential Dynamic Logic</a>
	<br>
	Author:
	Brandon Bohrer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-02-10: <a href="entries/Abstract_Soundness.html">Abstract Soundness</a>
	<br>
	Authors:
	Jasmin Christian Blanchette,
	Andrei Popescu
	and <a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-02-07: <a href="entries/Stone_Relation_Algebras.html">Stone Relation Algebras</a>
	<br>
	Author:
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-01-31: <a href="entries/Key_Agreement_Strong_Adversaries.html">Refining Authenticated Key Agreement with Strong Adversaries</a>
	<br>
	Authors:
	Joseph Lallemand
	and Christoph Sprenger
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-01-24: <a href="entries/Bernoulli.html">Bernoulli Numbers</a>
	<br>
	Authors:
	Lukas Bulwahn
	and <a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-01-17: <a href="entries/Minimal_SSA.html">Minimal Static Single Assignment Form</a>
	<br>
	Authors:
	Max Wagner
	and <a href="http://pp.ipd.kit.edu/person.php?id=88">Denis Lohner</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-01-17: <a href="entries/Bertrands_Postulate.html">Bertrand's postulate</a>
	<br>
	Authors:
	Julian Biendarra
	and <a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-01-12: <a href="entries/E_Transcendental.html">The Transcendence of e</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-01-08: <a href="entries/UPF_Firewall.html">Formal Network Models and Their Application to Firewall Policies</a>
	<br>
	Authors:
	<a href="https://www.brucker.ch/">Achim D. Brucker</a>,
	Lukas Brügger
	and Burkhart Wolff
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-01-03: <a href="entries/Password_Authentication_Protocol.html">Verification of a Diffie-Hellman Password-based Authentication Protocol by Extending the Inductive Method</a>
	<br>
	Author:
	Pasquale Noce
	</td>
	</tr>
	<tr>
	<td class="entry">
	2017-01-01: <a href="entries/FOL_Harrison.html">First-Order Logic According to Harrison</a>
	<br>
	Authors:
	<a href="https://people.compute.dtu.dk/aleje/">Alexander Birch Jensen</a>,
	Anders Schlichtkrull
	and <a href="https://people.compute.dtu.dk/jovi/">Jørgen Villadsen</a>
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2016</td>
	</tr>
	<tr>
	<td class="entry">
	2016-12-30: <a href="entries/Concurrent_Ref_Alg.html">Concurrent Refinement Algebra and Rely Quotients</a>
	<br>
	Authors:
	Julian Fell,
	Ian J. Hayes
	and <a href="http://andrius.velykis.lt">Andrius Velykis</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-12-29: <a href="entries/Twelvefold_Way.html">The Twelvefold Way</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-12-20: <a href="entries/Proof_Strategy_Language.html">Proof Strategy Language</a>
	<br>
	Author:
	Yutaka Nagashima
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-12-07: <a href="entries/Paraconsistency.html">Paraconsistency</a>
	<br>
	Authors:
	Anders Schlichtkrull
	and <a href="https://people.compute.dtu.dk/jovi/">Jørgen Villadsen</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-11-29: <a href="entries/Complx.html">COMPLX: A Verification Framework for Concurrent Imperative Programs</a>
	<br>
	Authors:
	Sidney Amani,
	June Andronick,
	Maksym Bortin,
	Corey Lewis,
	Christine Rizkallah
	and Joseph Tuong
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-11-23: <a href="entries/Abs_Int_ITP2012.html">Abstract Interpretation of Annotated Commands</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-11-16: <a href="entries/Separata.html">Separata: Isabelle tactics for Separation Algebra</a>
	<br>
	Authors:
	Zhe Hou,
	David Sanan,
	Alwen Tiu,
	Rajeev Gore
	and Ranald Clouston
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-11-12: <a href="entries/Nested_Multisets_Ordinals.html">Formalization of Nested Multisets, Hereditary Multisets, and Syntactic Ordinals</a>
	<br>
	Authors:
	Jasmin Christian Blanchette,
	Mathias Fleury
	and <a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-11-12: <a href="entries/Lambda_Free_KBOs.html">Formalization of Knuth–Bendix Orders for Lambda-Free Higher-Order Terms</a>
	<br>
	Authors:
	Heiko Becker,
	Jasmin Christian Blanchette,
	Uwe Waldmann
	and Daniel Wand
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-11-10: <a href="entries/Deep_Learning.html">Expressiveness of Deep Learning</a>
	<br>
	Author:
	Alexander Bentkamp
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-10-25: <a href="entries/Modal_Logics_for_NTS.html">Modal Logics for Nominal Transition Systems</a>
	<br>
	Authors:
	Tjark Weber,
	Lars-Henrik Eriksson,
	Joachim Parrow,
	Johannes Borgström
	and Ramunas Gutkovas
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-10-24: <a href="entries/Stable_Matching.html">Stable Matching</a>
	<br>
	Author:
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-10-21: <a href="entries/LOFT.html">LOFT — Verified Migration of Linux Firewalls to SDN</a>
	<br>
	Authors:
	<a href="http://liftm.de">Julius Michaelis</a>
	and <a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-10-19: <a href="entries/Source_Coding_Theorem.html">Source Coding Theorem</a>
	<br>
	Authors:
	Quentin Hibon
	and <a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-10-19: <a href="entries/SPARCv8.html">A formal model for the SPARCv8 ISA and a proof of non-interference for the LEON3 processor</a>
	<br>
	Authors:
	Zhe Hou,
	David Sanan,
	Alwen Tiu
	and Yang Liu
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-10-14: <a href="entries/Berlekamp_Zassenhaus.html">The Factorization Algorithm of Berlekamp and Zassenhaus</a>
	<br>
	Authors:
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
	<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	and Akihisa Yamada
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-10-11: <a href="entries/Chord_Segments.html">Intersecting Chords Theorem</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-10-05: <a href="entries/Lp.html">Lp spaces</a>
	<br>
	Author:
	Sebastien Gouezel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-09-30: <a href="entries/Fisher_Yates.html">Fisher–Yates shuffle</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-09-29: <a href="entries/Allen_Calculus.html">Allen's Interval Calculus</a>
	<br>
	Author:
	Fadoua Ghourabi
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-09-23: <a href="entries/Lambda_Free_RPOs.html">Formalization of Recursive Path Orders for Lambda-Free Higher-Order Terms</a>
	<br>
	Authors:
	Jasmin Christian Blanchette,
	Uwe Waldmann
	and Daniel Wand
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-09-09: <a href="entries/Iptables_Semantics.html">Iptables Semantics</a>
	<br>
	Authors:
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>
	and <a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-09-06: <a href="entries/SuperCalc.html">A Variant of the Superposition Calculus</a>
	<br>
	Author:
	<a href="http://membres-lig.imag.fr/peltier/">Nicolas Peltier</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-09-06: <a href="entries/Stone_Algebras.html">Stone Algebras</a>
	<br>
	Author:
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-09-01: <a href="entries/Stirling_Formula.html">Stirling's formula</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-08-31: <a href="entries/Routing.html">Routing</a>
	<br>
	Authors:
	<a href="http://liftm.de">Julius Michaelis</a>
	and <a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-08-24: <a href="entries/Simple_Firewall.html">Simple Firewall</a>
	<br>
	Authors:
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>,
	<a href="http://liftm.de">Julius Michaelis</a>
	and <a href="https://home.in.tum.de/~haslbecm">Maximilian Haslbeck</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-08-18: <a href="entries/InfPathElimination.html">Infeasible Paths Elimination by Symbolic Execution Techniques: Proof of Correctness and Preservation of Paths</a>
	<br>
	Authors:
	Romain Aissat,
	Frederic Voisin
	and Burkhart Wolff
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-08-12: <a href="entries/EdmondsKarp_Maxflow.html">Formalizing the Edmonds-Karp Algorithm</a>
	<br>
	Authors:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and S. Reza Sefidgar
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-08-08: <a href="entries/Refine_Imperative_HOL.html">The Imperative Refinement Framework</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-08-07: <a href="entries/Ptolemys_Theorem.html">Ptolemy's Theorem</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-07-17: <a href="entries/Surprise_Paradox.html">Surprise Paradox</a>
	<br>
	Author:
	Joachim Breitner
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-07-14: <a href="entries/Pairing_Heap.html">Pairing Heap</a>
	<br>
	Authors:
	Hauke Brinkop
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-07-05: <a href="entries/DFS_Framework.html">A Framework for Verifying Depth-First Search Algorithms</a>
	<br>
	Authors:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and René Neumann
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-07-01: <a href="entries/Buildings.html">Chamber Complexes, Coxeter Systems, and Buildings</a>
	<br>
	Author:
	<a href="http://ualberta.ca/~jsylvest/">Jeremy Sylvestre</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-30: <a href="entries/Rewriting_Z.html">The Z Property</a>
	<br>
	Authors:
	Bertram Felgenhauer,
	Julian Nagele,
	Vincent van Oostrom
	and Christian Sternagel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-30: <a href="entries/Resolution_FOL.html">The Resolution Calculus for First-Order Logic</a>
	<br>
	Author:
	Anders Schlichtkrull
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-28: <a href="entries/IP_Addresses.html">IP Addresses</a>
	<br>
	Authors:
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>,
	<a href="http://liftm.de">Julius Michaelis</a>
	and <a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-28: <a href="entries/Dependent_SIFUM_Refinement.html">Compositional Security-Preserving Refinement for Concurrent Imperative Programs</a>
	<br>
	Authors:
	<a href="http://people.eng.unimelb.edu.au/tobym/">Toby Murray</a>,
	Robert Sison,
	Edward Pierzchalski
	and Christine Rizkallah
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-26: <a href="entries/Category3.html">Category Theory with Adjunctions and Limits</a>
	<br>
	Author:
	Eugene W. Stark
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-26: <a href="entries/Card_Multisets.html">Cardinality of Multisets</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-25: <a href="entries/Dependent_SIFUM_Type_Systems.html">A Dependent Security Type System for Concurrent Imperative Programs</a>
	<br>
	Authors:
	<a href="http://people.eng.unimelb.edu.au/tobym/">Toby Murray</a>,
	Robert Sison,
	Edward Pierzchalski
	and Christine Rizkallah
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-21: <a href="entries/Catalan_Numbers.html">Catalan Numbers</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-18: <a href="entries/Algebraic_VCs.html">Program Construction and Verification Components Based on Kleene Algebra</a>
	<br>
	Authors:
	Victor B. F. Gomes
	and <a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-13: <a href="entries/Noninterference_Concurrent_Composition.html">Conservation of CSP Noninterference Security under Concurrent Composition</a>
	<br>
	Author:
	Pasquale Noce
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-06-09: <a href="entries/Word_Lib.html">Finite Machine Word Library</a>
	<br>
	Authors:
	Joel Beeren,
	Matthew Fernandez,
	Xin Gao,
	<a href="http://www.cse.unsw.edu.au/~kleing/">Gerwin Klein</a>,
	Rafal Kolanski,
	Japheth Lim,
	Corey Lewis,
	Daniel Matichuk
	and Thomas Sewell
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-31: <a href="entries/Tree_Decomposition.html">Tree Decomposition</a>
	<br>
	Author:
	<a href="http://logic.las.tu-berlin.de/Members/Dittmann/">Christoph Dittmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-24: <a href="entries/Posix-Lexing.html">POSIX Lexing with Derivatives of Regular Expressions</a>
	<br>
	Authors:
	<a href="http://kcl.academia.edu/FahadAusaf">Fahad Ausaf</a>,
	<a href="https://rd.host.cs.st-andrews.ac.uk">Roy Dyckhoff</a>
	and <a href="http://www.inf.kcl.ac.uk/staff/urbanc/">Christian Urban</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-24: <a href="entries/Card_Equiv_Relations.html">Cardinality of Equivalence Relations</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-20: <a href="entries/Perron_Frobenius.html">Perron-Frobenius Theorem for Spectral Radius Analysis</a>
	<br>
	Authors:
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
	<a href="http://www21.in.tum.de/~kuncar/">Ondřej Kunčar</a>,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	and Akihisa Yamada
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-20: <a href="entries/Incredible_Proof_Machine.html">The meta theory of the Incredible Proof Machine</a>
	<br>
	Authors:
	Joachim Breitner
	and <a href="http://pp.ipd.kit.edu/person.php?id=88">Denis Lohner</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-18: <a href="entries/FLP.html">A Constructive Proof for FLP</a>
	<br>
	Authors:
	Benjamin Bisping,
	Paul-David Brodmann,
	Tim Jungnickel,
	Christina Rickmann,
	Henning Seidler,
	Anke Stüber,
	Arno Wilhelm-Weidner,
	Kirstin Peters
	and <a href="https://www.mtv.tu-berlin.de/nestmann/">Uwe Nestmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-09: <a href="entries/MFMC_Countable.html">A Formal Proof of the Max-Flow Min-Cut Theorem for Countable Networks</a>
	<br>
	Author:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-05: <a href="entries/Randomised_Social_Choice.html">Randomised Social Choice Theory</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-04: <a href="entries/SDS_Impossibility.html">The Incompatibility of SD-Efficiency and SD-Strategy-Proofness</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-04: <a href="entries/Bell_Numbers_Spivey.html">Spivey's Generalized Recurrence for Bell Numbers</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-05-02: <a href="entries/Groebner_Bases.html">Gröbner Bases Theory</a>
	<br>
	Authors:
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
	and <a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-04-28: <a href="entries/No_FTL_observers.html">No Faster-Than-Light Observers</a>
	<br>
	Authors:
	Mike Stannett
	and <a href="http://www.renyi.hu/~nemeti/">István Németi</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-04-27: <a href="entries/ROBDD.html">Algorithms for Reduced Ordered Binary Decision Diagrams</a>
	<br>
	Authors:
	<a href="http://liftm.de">Julius Michaelis</a>,
	<a href="https://home.in.tum.de/~haslbecm">Maximilian Haslbeck</a>,
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and <a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-04-27: <a href="entries/CYK.html">A formalisation of the Cocke-Younger-Kasami algorithm</a>
	<br>
	Author:
	Maksym Bortin
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-04-26: <a href="entries/Noninterference_Sequential_Composition.html">Conservation of CSP Noninterference Security under Sequential Composition</a>
	<br>
	Author:
	Pasquale Noce
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-04-12: <a href="entries/KAD.html">Kleene Algebras with Domain</a>
	<br>
	Authors:
	Victor B. F. Gomes,
	<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>,
	<a href="http://www.hoefner-online.de/">Peter Höfner</a>,
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	and Tjark Weber
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-03-11: <a href="entries/PropResPI.html">Propositional Resolution and Prime Implicates Generation</a>
	<br>
	Author:
	<a href="http://membres-lig.imag.fr/peltier/">Nicolas Peltier</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-03-08: <a href="entries/Timed_Automata.html">Timed Automata</a>
	<br>
	Author:
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-03-08: <a href="entries/Cartan_FP.html">The Cartan Fixed Point Theorems</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-03-01: <a href="entries/LTL.html">Linear Temporal Logic</a>
	<br>
	Author:
	Salomon Sickert
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-02-17: <a href="entries/List_Update.html">Analysis of List Update Algorithms</a>
	<br>
	Authors:
	<a href="http://in.tum.de/~haslbema/">Maximilian P.L. Haslbeck</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-02-05: <a href="entries/Formal_SSA.html">Verified Construction of Static Single Assignment Form</a>
	<br>
	Authors:
	Sebastian Ullrich
	and <a href="http://pp.ipd.kit.edu/person.php?id=88">Denis Lohner</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-01-29: <a href="entries/Polynomial_Interpolation.html">Polynomial Interpolation</a>
	<br>
	Authors:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	and Akihisa Yamada
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-01-29: <a href="entries/Polynomial_Factorization.html">Polynomial Factorization</a>
	<br>
	Authors:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	and Akihisa Yamada
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-01-20: <a href="entries/Knot_Theory.html">Knot Theory</a>
	<br>
	Author:
	T.V.H. Prathamesh
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-01-18: <a href="entries/Matrix_Tensor.html">Tensor Product of Matrices</a>
	<br>
	Author:
	T.V.H. Prathamesh
	</td>
	</tr>
	<tr>
	<td class="entry">
	2016-01-14: <a href="entries/Card_Number_Partitions.html">Cardinality of Number Partitions</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2015</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-28: <a href="entries/Triangle.html">Basic Geometric Properties of Triangles</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-28: <a href="entries/Prime_Harmonic_Series.html">The Divergence of the Prime Harmonic Series</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-28: <a href="entries/Liouville_Numbers.html">Liouville numbers</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-28: <a href="entries/Descartes_Sign_Rule.html">Descartes' Rule of Signs</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-22: <a href="entries/Stern_Brocot.html">The Stern-Brocot Tree</a>
	<br>
	Authors:
	<a href="http://peteg.org">Peter Gammie</a>
	and <a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-22: <a href="entries/Applicative_Lifting.html">Applicative Lifting</a>
	<br>
	Authors:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	and Joshua Schneider
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-22: <a href="entries/Algebraic_Numbers.html">Algebraic Numbers in Isabelle/HOL</a>
	<br>
	Authors:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>,
	Akihisa Yamada
	and <a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-12: <a href="entries/Card_Partitions.html">Cardinality of Set Partitions</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-02: <a href="entries/Latin_Square.html">Latin Square</a>
	<br>
	Author:
	Alexander Bentkamp
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-12-01: <a href="entries/Ergodic_Theory.html">Ergodic Theory</a>
	<br>
	Author:
	Sebastien Gouezel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-11-19: <a href="entries/Euler_Partition.html">Euler's Partition Theorem</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-11-18: <a href="entries/TortoiseHare.html">The Tortoise and Hare Algorithm</a>
	<br>
	Author:
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-11-11: <a href="entries/Planarity_Certificates.html">Planarity Certificates</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-11-02: <a href="entries/Parity_Game.html">Positional Determinacy of Parity Games</a>
	<br>
	Author:
	<a href="http://logic.las.tu-berlin.de/Members/Dittmann/">Christoph Dittmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-09-16: <a href="entries/Isabelle_Meta_Model.html">A Meta-Model for the Isabelle API</a>
	<br>
	Authors:
	Frédéric Tuong
	and Burkhart Wolff
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-09-04: <a href="entries/LTL_to_DRA.html">Converting Linear Temporal Logic to Deterministic (Generalized) Rabin Automata</a>
	<br>
	Author:
	Salomon Sickert
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-08-21: <a href="entries/Jordan_Normal_Form.html">Matrices, Jordan Normal Forms, and Spectral Radius Theory</a>
	<br>
	Authors:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	and Akihisa Yamada
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-08-20: <a href="entries/Decreasing-Diagrams-II.html">Decreasing Diagrams II</a>
	<br>
	Author:
	Bertram Felgenhauer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-08-18: <a href="entries/Noninterference_Inductive_Unwinding.html">The Inductive Unwinding Theorem for CSP Noninterference Security</a>
	<br>
	Author:
	Pasquale Noce
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-08-12: <a href="entries/Rep_Fin_Groups.html">Representations of Finite Groups</a>
	<br>
	Author:
	<a href="http://ualberta.ca/~jsylvest/">Jeremy Sylvestre</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-08-10: <a href="entries/Encodability_Process_Calculi.html">Analysing and Comparing Encodability Criteria for Process Calculi</a>
	<br>
	Authors:
	Kirstin Peters
	and <a href="http://theory.stanford.edu/~rvg/">Rob van Glabbeek</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-07-21: <a href="entries/Case_Labeling.html">Generating Cases from Labeled Subgoals</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-07-14: <a href="entries/Landau_Symbols.html">Landau Symbols</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-07-14: <a href="entries/Akra_Bazzi.html">The Akra-Bazzi theorem and the Master theorem</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-07-07: <a href="entries/Hermite.html">Hermite Normal Form</a>
	<br>
	Authors:
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>
	and <a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-06-27: <a href="entries/Derangements.html">Derangements Formula</a>
	<br>
	Author:
	Lukas Bulwahn
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-06-11: <a href="entries/Noninterference_Ipurge_Unwinding.html">The Ipurge Unwinding Theorem for CSP Noninterference Security</a>
	<br>
	Author:
	Pasquale Noce
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-06-11: <a href="entries/Noninterference_Generic_Unwinding.html">The Generic Unwinding Theorem for CSP Noninterference Security</a>
	<br>
	Author:
	Pasquale Noce
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-06-11: <a href="entries/Multirelations.html">Binary Multirelations</a>
	<br>
	Authors:
	<a href="http://www.sci.kagoshima-u.ac.jp/~furusawa/">Hitoshi Furusawa</a>
	and <a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-06-11: <a href="entries/List_Interleaving.html">Reasoning about Lists via List Interleaving</a>
	<br>
	Author:
	Pasquale Noce
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-06-07: <a href="entries/Dynamic_Tables.html">Parameterized Dynamic Tables</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-05-28: <a href="entries/Formula_Derivatives.html">Derivatives of Logical Formulas</a>
	<br>
	Author:
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-05-27: <a href="entries/Probabilistic_System_Zoo.html">A Zoo of Probabilistic Systems</a>
	<br>
	Authors:
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>,
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	and <a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-04-30: <a href="entries/Vickrey_Clarke_Groves.html">VCG - Combinatorial Vickrey-Clarke-Groves Auctions</a>
	<br>
	Authors:
	Marco B. Caminati,
	<a href="http://www.cs.bham.ac.uk/~mmk">Manfred Kerber</a>,
	Christoph Lange
	and Colin Rowat
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-04-15: <a href="entries/Residuated_Lattices.html">Residuated Lattices</a>
	<br>
	Authors:
	Victor B. F. Gomes
	and <a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-04-13: <a href="entries/ConcurrentIMP.html">Concurrent IMP</a>
	<br>
	Author:
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-04-13: <a href="entries/ConcurrentGC.html">Relaxing Safely: Verified On-the-Fly Garbage Collection for x86-TSO</a>
	<br>
	Authors:
	<a href="http://peteg.org">Peter Gammie</a>,
	<a href="https://www.cs.purdue.edu/homes/hosking/">Tony Hosking</a>
	and Kai Engelhardt
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-03-30: <a href="entries/Trie.html">Trie</a>
	<br>
	Authors:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-03-18: <a href="entries/Consensus_Refined.html">Consensus Refined</a>
	<br>
	Authors:
	Ognjen Maric
	and Christoph Sprenger
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-03-11: <a href="entries/Deriving.html">Deriving class instances for datatypes</a>
	<br>
	Authors:
	Christian Sternagel
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-02-20: <a href="entries/Call_Arity.html">The Safety of Call Arity</a>
	<br>
	Author:
	Joachim Breitner
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-02-12: <a href="entries/QR_Decomposition.html">QR Decomposition</a>
	<br>
	Authors:
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>
	and <a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-02-12: <a href="entries/Echelon_Form.html">Echelon Form</a>
	<br>
	Authors:
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>
	and <a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-02-05: <a href="entries/Finite_Automata_HF.html">Finite Automata in Hereditarily Finite Set Theory</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2015-01-28: <a href="entries/UpDown_Scheme.html">Verification of the UpDown Scheme</a>
	<br>
	Author:
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2014</td>
	</tr>
	<tr>
	<td class="entry">
	2014-11-28: <a href="entries/UPF.html">The Unified Policy Framework (UPF)</a>
	<br>
	Authors:
	<a href="https://www.brucker.ch/">Achim D. Brucker</a>,
	Lukas Brügger
	and Burkhart Wolff
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-10-23: <a href="entries/AODV.html">Loop freedom of the (untimed) AODV routing protocol</a>
	<br>
	Authors:
	<a href="http://www.tbrk.org">Timothy Bourke</a>
	and <a href="http://www.hoefner-online.de/">Peter Höfner</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-10-13: <a href="entries/Lifting_Definition_Option.html">Lifting Definition Option</a>
	<br>
	Author:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-10-10: <a href="entries/Stream_Fusion_Code.html">Stream Fusion in HOL with Code Generation</a>
	<br>
	Authors:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	and Alexandra Maximova
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-10-09: <a href="entries/Density_Compiler.html">A Verified Compiler for Probability Density Functions</a>
	<br>
	Authors:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>,
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-10-08: <a href="entries/RefinementReactive.html">Formalization of Refinement Calculus for Reactive Systems</a>
	<br>
	Author:
	Viorel Preoteasa
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-10-03: <a href="entries/XML.html">XML</a>
	<br>
	Authors:
	Christian Sternagel
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-10-03: <a href="entries/Certification_Monads.html">Certification Monads</a>
	<br>
	Authors:
	Christian Sternagel
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-09-25: <a href="entries/Imperative_Insertion_Sort.html">Imperative Insertion Sort</a>
	<br>
	Author:
	Christian Sternagel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-09-19: <a href="entries/Sturm_Tarski.html">The Sturm-Tarski Theorem</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-09-15: <a href="entries/Cayley_Hamilton.html">The Cayley-Hamilton Theorem</a>
	<br>
	Authors:
	<a href="http://nm.wu.ac.at/nm/sadelsbe">Stephan Adelsberger</a>,
	<a href="http://www.logic.at/people/hetzl/">Stefan Hetzl</a>
	and Florian Pollak
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-09-09: <a href="entries/Jordan_Hoelder.html">The Jordan-Hölder Theorem</a>
	<br>
	Author:
	Jakob von Raumer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-09-04: <a href="entries/Priority_Queue_Braun.html">Priority Queues Based on Braun Trees</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-09-03: <a href="entries/Gauss_Jordan.html">Gauss-Jordan Algorithm and Its Applications</a>
	<br>
	Authors:
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>
	and <a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-08-29: <a href="entries/VectorSpace.html">Vector Spaces</a>
	<br>
	Author:
	Holden Lee
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-08-29: <a href="entries/Special_Function_Bounds.html">Real-Valued Special Functions: Upper and Lower Bounds</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-08-13: <a href="entries/Skew_Heap.html">Skew Heap</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-08-12: <a href="entries/Splay_Tree.html">Splay Tree</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-07-29: <a href="entries/Show.html">Haskell's Show Class in Isabelle/HOL</a>
	<br>
	Authors:
	Christian Sternagel
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-07-18: <a href="entries/CISC-Kernel.html">Formal Specification of a Generic Separation Kernel</a>
	<br>
	Authors:
	Freek Verbeek,
	Sergey Tverdyshev,
	Oto Havle,
	Holger Blasum,
	Bruno Langenstein,
	Werner Stephan,
	Yakoub Nemouchi,
	Abderrahmane Feliachi,
	Burkhart Wolff
	and Julien Schmaltz
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-07-13: <a href="entries/pGCL.html">pGCL for Isabelle</a>
	<br>
	Author:
	David Cock
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-07-07: <a href="entries/Amortized_Complexity.html">Amortized Complexity Verified</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-07-04: <a href="entries/Network_Security_Policy_Verification.html">Network Security Policy Verification</a>
	<br>
	Author:
	<a href="http://net.in.tum.de/~diekmann">Cornelius Diekmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-07-03: <a href="entries/Pop_Refinement.html">Pop-Refinement</a>
	<br>
	Author:
	<a href="http://www.kestrel.edu/~coglio">Alessandro Coglio</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-06-12: <a href="entries/MSO_Regex_Equivalence.html">Decision Procedures for MSO on Words Based on Derivatives of Regular Expressions</a>
	<br>
	Authors:
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-06-08: <a href="entries/Boolean_Expression_Checkers.html">Boolean Expression Checkers</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-05-28: <a href="entries/Promela.html">Promela Formalization</a>
	<br>
	Author:
	René Neumann
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-05-28: <a href="entries/LTL_to_GBA.html">Converting Linear-Time Temporal Logic to Generalized Büchi Automata</a>
	<br>
	Authors:
	Alexander Schimpf
	and <a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-05-28: <a href="entries/Gabow_SCC.html">Verified Efficient Implementation of Gabow's Strongly Connected Components Algorithm</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-05-28: <a href="entries/CAVA_LTL_Modelchecker.html">A Fully Verified Executable LTL Model Checker</a>
	<br>
	Authors:
	<a href="https://www7.in.tum.de/~esparza/">Javier Esparza</a>,
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>,
	René Neumann,
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>,
	Alexander Schimpf
	and <a href="http://www.irit.fr/~Jan-Georg.Smaus">Jan-Georg Smaus</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-05-28: <a href="entries/CAVA_Automata.html">The CAVA Automata Library</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-05-23: <a href="entries/Roy_Floyd_Warshall.html">Transitive closure according to Roy-Floyd-Warshall</a>
	<br>
	Author:
	Makarius Wenzel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-05-23: <a href="entries/Noninterference_CSP.html">Noninterference Security in Communicating Sequential Processes</a>
	<br>
	Author:
	Pasquale Noce
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-05-21: <a href="entries/Regular_Algebras.html">Regular Algebras</a>
	<br>
	Authors:
	<a href="https://www-users.cs.york.ac.uk/~simonf/">Simon Foster</a>
	and <a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-04-28: <a href="entries/ComponentDependencies.html">Formalisation and Analysis of Component Dependencies</a>
	<br>
	Author:
	Maria Spichkova
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-04-23: <a href="entries/WHATandWHERE_Security.html">A Formalization of Declassification with WHAT-and-WHERE-Security</a>
	<br>
	Authors:
	Sylvia Grewe,
	Alexander Lux,
	Heiko Mantel
	and Jens Sauer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-04-23: <a href="entries/Strong_Security.html">A Formalization of Strong Security</a>
	<br>
	Authors:
	Sylvia Grewe,
	Alexander Lux,
	Heiko Mantel
	and Jens Sauer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-04-23: <a href="entries/SIFUM_Type_Systems.html">A Formalization of Assumptions and Guarantees for Compositional Noninterference</a>
	<br>
	Authors:
	Sylvia Grewe,
	Heiko Mantel
	and Daniel Schoepe
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-04-22: <a href="entries/Bounded_Deducibility_Security.html">Bounded-Deducibility Security</a>
	<br>
	Authors:
	Andrei Popescu
	and <a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-04-16: <a href="entries/HyperCTL.html">A shallow embedding of HyperCTL*</a>
	<br>
	Authors:
	<a href="http://www.react.uni-saarland.de/people/rabe.html">Markus N. Rabe</a>,
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and Andrei Popescu
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-04-16: <a href="entries/Abstract_Completeness.html">Abstract Completeness</a>
	<br>
	Authors:
	Jasmin Christian Blanchette,
	Andrei Popescu
	and <a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-04-13: <a href="entries/Discrete_Summation.html">Discrete Summation</a>
	<br>
	Author:
	<a href="http://isabelle.in.tum.de/~haftmann">Florian Haftmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-04-03: <a href="entries/GPU_Kernel_PL.html">Syntax and semantics of a GPU kernel programming language</a>
	<br>
	Author:
	John Wickerson
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-03-11: <a href="entries/Probabilistic_Noninterference.html">Probabilistic Noninterference</a>
	<br>
	Authors:
	Andrei Popescu
	and <a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-03-08: <a href="entries/AWN.html">Mechanization of the Algebra for Wireless Networks (AWN)</a>
	<br>
	Author:
	<a href="http://www.tbrk.org">Timothy Bourke</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-02-18: <a href="entries/Partial_Function_MR.html">Mutually Recursive Partial Functions</a>
	<br>
	Author:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-02-13: <a href="entries/Random_Graph_Subgraph_Threshold.html">Properties of Random Graphs -- Subgraph Containment</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-02-11: <a href="entries/Selection_Heap_Sort.html">Verification of Selection and Heap Sort Using Locales</a>
	<br>
	Author:
	<a href="http://www.matf.bg.ac.rs/~danijela">Danijela Petrovic</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-02-07: <a href="entries/Affine_Arithmetic.html">Affine Arithmetic</a>
	<br>
	Author:
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-02-06: <a href="entries/Real_Impl.html">Implementing field extensions of the form Q[sqrt(b)]</a>
	<br>
	Author:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-01-30: <a href="entries/Regex_Equivalence.html">Unified Decision Procedures for Regular Expression Equivalence</a>
	<br>
	Authors:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	and <a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-01-28: <a href="entries/Secondary_Sylow.html">Secondary Sylow Theorems</a>
	<br>
	Author:
	Jakob von Raumer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-01-25: <a href="entries/Relation_Algebra.html">Relation Algebra</a>
	<br>
	Authors:
	Alasdair Armstrong,
	<a href="https://www-users.cs.york.ac.uk/~simonf/">Simon Foster</a>,
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	and Tjark Weber
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-01-23: <a href="entries/KAT_and_DRA.html">Kleene Algebra with Tests and Demonic Refinement Algebras</a>
	<br>
	Authors:
	Alasdair Armstrong,
	Victor B. F. Gomes
	and <a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-01-16: <a href="entries/Featherweight_OCL.html">Featherweight OCL: A Proposal for a Machine-Checked Formal Semantics for OCL 2.5</a>
	<br>
	Authors:
	<a href="https://www.brucker.ch/">Achim D. Brucker</a>,
	Frédéric Tuong
	and Burkhart Wolff
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-01-11: <a href="entries/Sturm_Sequences.html">Sturm's Theorem</a>
	<br>
	Author:
	<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2014-01-11: <a href="entries/CryptoBasedCompositionalProperties.html">Compositional Properties of Crypto-Based Components</a>
	<br>
	Author:
	Maria Spichkova
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2013</td>
	</tr>
	<tr>
	<td class="entry">
	2013-12-01: <a href="entries/Tail_Recursive_Functions.html">A General Method for the Proof of Theorems on Tail-recursive Functions</a>
	<br>
	Author:
	Pasquale Noce
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-11-17: <a href="entries/Incompleteness.html">Gödel's Incompleteness Theorems</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-11-17: <a href="entries/HereditarilyFinite.html">The Hereditarily Finite Sets</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-11-15: <a href="entries/Coinductive_Languages.html">A Codatatype of Formal Languages</a>
	<br>
	Author:
	<a href="http://people.inf.ethz.ch/trayteld/">Dmitriy Traytel</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-11-14: <a href="entries/FocusStreamsCaseStudies.html">Stream Processing Components: Isabelle/HOL Formalisation and Case Studies</a>
	<br>
	Author:
	Maria Spichkova
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-11-12: <a href="entries/GoedelGod.html">Gödel's God in Isabelle/HOL</a>
	<br>
	Authors:
	<a href="http://christoph-benzmueller.de">Christoph Benzmüller</a>
	and <a href="http://www.logic.at/staff/bruno/">Bruno Woltzenlogel Paleo</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-11-01: <a href="entries/Decreasing-Diagrams.html">Decreasing Diagrams</a>
	<br>
	Author:
	<a href="http://cl-informatik.uibk.ac.at/users/hzankl">Harald Zankl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-10-02: <a href="entries/Automatic_Refinement.html">Automatic Data Refinement</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-09-17: <a href="entries/Native_Word.html">Native Word</a>
	<br>
	Author:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-07-27: <a href="entries/IEEE_Floating_Point.html">A Formal Model of IEEE Floating Point Arithmetic</a>
	<br>
	Author:
	Lei Yu
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-07-22: <a href="entries/Pratt_Certificate.html">Pratt's Primality Certificates</a>
	<br>
	Authors:
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	and <a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-07-22: <a href="entries/Lehmer.html">Lehmer's Theorem</a>
	<br>
	Authors:
	<a href="http://in.tum.de/~wimmers">Simon Wimmer</a>
	and <a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-07-19: <a href="entries/Koenigsberg_Friendship.html">The Königsberg Bridge Problem and the Friendship Theorem</a>
	<br>
	Author:
	<a href="https://www.cl.cam.ac.uk/~wl302/">Wenda Li</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-06-27: <a href="entries/Sort_Encodings.html">Sound and Complete Sort Encodings for First-Order Logic</a>
	<br>
	Authors:
	Jasmin Christian Blanchette
	and Andrei Popescu
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-05-22: <a href="entries/ShortestPath.html">An Axiomatic Characterization of the Single-Source Shortest Path Problem</a>
	<br>
	Author:
	Christine Rizkallah
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-04-28: <a href="entries/Graph_Theory.html">Graph Theory</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-04-15: <a href="entries/Containers.html">Light-weight Containers</a>
	<br>
	Author:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-02-21: <a href="entries/Nominal2.html">Nominal 2</a>
	<br>
	Authors:
	<a href="http://www.inf.kcl.ac.uk/staff/urbanc/">Christian Urban</a>,
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a>
	and <a href="http://cl-informatik.uibk.ac.at/users/cek/">Cezary Kaliszyk</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-01-31: <a href="entries/Launchbury.html">The Correctness of Launchbury's Natural Semantics for Lazy Evaluation</a>
	<br>
	Author:
	Joachim Breitner
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-01-19: <a href="entries/Ribbon_Proofs.html">Ribbon Proofs</a>
	<br>
	Author:
	John Wickerson
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-01-16: <a href="entries/Rank_Nullity_Theorem.html">Rank-Nullity Theorem in Linear Algebra</a>
	<br>
	Authors:
	<a href="http://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>
	and <a href="http://www.unirioja.es/cu/jearansa">Jesús Aransay</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-01-15: <a href="entries/Kleene_Algebra.html">Kleene Algebra</a>
	<br>
	Authors:
	Alasdair Armstrong,
	<a href="http://staffwww.dcs.shef.ac.uk/people/G.Struth/">Georg Struth</a>
	and Tjark Weber
	</td>
	</tr>
	<tr>
	<td class="entry">
	2013-01-03: <a href="entries/Sqrt_Babylonian.html">Computing N-th Roots using the Babylonian Method</a>
	<br>
	Author:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2012</td>
	</tr>
	<tr>
	<td class="entry">
	2012-11-14: <a href="entries/Separation_Logic_Imperative_HOL.html">A Separation Logic Framework for Imperative HOL</a>
	<br>
	Authors:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and Rene Meis
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-11-02: <a href="entries/Open_Induction.html">Open Induction</a>
	<br>
	Authors:
	Mizuhito Ogawa
	and Christian Sternagel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-10-30: <a href="entries/Tarskis_Geometry.html">The independence of Tarski's Euclidean axiom</a>
	<br>
	Author:
	T. J. M. Makarios
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-10-27: <a href="entries/Bondy.html">Bondy's Theorem</a>
	<br>
	Authors:
	<a href="http://www.andrew.cmu.edu/user/avigad/">Jeremy Avigad</a>
	and <a href="http://www.logic.at/people/hetzl/">Stefan Hetzl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-09-10: <a href="entries/Possibilistic_Noninterference.html">Possibilistic Noninterference</a>
	<br>
	Authors:
	Andrei Popescu
	and <a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-08-07: <a href="entries/Datatype_Order_Generator.html">Generating linear orders for datatypes</a>
	<br>
	Author:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-08-05: <a href="entries/Impossible_Geometry.html">Proving the Impossibility of Trisecting an Angle and Doubling the Cube</a>
	<br>
	Authors:
	Ralph Romanos
	and <a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-07-27: <a href="entries/Heard_Of.html">Verifying Fault-Tolerant Distributed Algorithms in the Heard-Of Model</a>
	<br>
	Authors:
	Henri Debrat
	and <a href="http://www.loria.fr/~merz">Stephan Merz</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-07-01: <a href="entries/PCF.html">Logical Relations for PCF</a>
	<br>
	Author:
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-06-26: <a href="entries/Tycon.html">Type Constructor Classes and Monad Transformers</a>
	<br>
	Author:
	Brian Huffman
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-05-29: <a href="entries/Psi_Calculi.html">Psi-calculi in Isabelle</a>
	<br>
	Author:
	<a href="http://www.itu.dk/people/jebe">Jesper Bengtson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-05-29: <a href="entries/Pi_Calculus.html">The pi-calculus in nominal logic</a>
	<br>
	Author:
	<a href="http://www.itu.dk/people/jebe">Jesper Bengtson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-05-29: <a href="entries/CCS.html">CCS in nominal logic</a>
	<br>
	Author:
	<a href="http://www.itu.dk/people/jebe">Jesper Bengtson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-05-27: <a href="entries/Circus.html">Isabelle/Circus</a>
	<br>
	Authors:
	Abderrahmane Feliachi,
	Burkhart Wolff
	and Marie-Claude Gaudel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-05-11: <a href="entries/Separation_Algebra.html">Separation Algebra</a>
	<br>
	Authors:
	<a href="http://www.cse.unsw.edu.au/~kleing/">Gerwin Klein</a>,
	Rafal Kolanski
	and Andrew Boyton
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-05-07: <a href="entries/Stuttering_Equivalence.html">Stuttering Equivalence</a>
	<br>
	Author:
	<a href="http://www.loria.fr/~merz">Stephan Merz</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-05-02: <a href="entries/Inductive_Confidentiality.html">Inductive Study of Confidentiality</a>
	<br>
	Author:
	<a href="http://www.dmi.unict.it/~giamp/">Giampaolo Bella</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-04-26: <a href="entries/Ordinary_Differential_Equations.html">Ordinary Differential Equations</a>
	<br>
	Authors:
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
	and <a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-04-13: <a href="entries/Well_Quasi_Orders.html">Well-Quasi-Orders</a>
	<br>
	Author:
	Christian Sternagel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-03-01: <a href="entries/Abortable_Linearizable_Modules.html">Abortable Linearizable Modules</a>
	<br>
	Authors:
	Rachid Guerraoui,
	<a href="http://lara.epfl.ch/~kuncak/">Viktor Kuncak</a>
	and Giuliano Losa
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-02-29: <a href="entries/Transitive-Closure-II.html">Executable Transitive Closures</a>
	<br>
	Author:
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-02-06: <a href="entries/Girth_Chromatic.html">A Probabilistic Proof of the Girth-Chromatic Number Theorem</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~noschinl/">Lars Noschinski</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-01-30: <a href="entries/Refine_Monadic.html">Refinement for Monadic Programs</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-01-30: <a href="entries/Dijkstra_Shortest_Path.html">Dijkstra's Shortest Path Algorithm</a>
	<br>
	Authors:
	Benedikt Nordhoff
	and <a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2012-01-03: <a href="entries/Markov_Models.html">Markov Models</a>
	<br>
	Authors:
	<a href="http://in.tum.de/~hoelzl">Johannes Hölzl</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2011</td>
	</tr>
	<tr>
	<td class="entry">
	2011-11-19: <a href="entries/TLA.html">A Definitional Encoding of TLA* in Isabelle/HOL</a>
	<br>
	Authors:
	<a href="http://homepages.inf.ed.ac.uk/ggrov">Gudmund Grov</a>
	and <a href="http://www.loria.fr/~merz">Stephan Merz</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-11-09: <a href="entries/Efficient-Mergesort.html">Efficient Mergesort</a>
	<br>
	Author:
	Christian Sternagel
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-09-22: <a href="entries/PseudoHoops.html">Pseudo Hoops</a>
	<br>
	Authors:
	George Georgescu,
	Laurentiu Leustean
	and Viorel Preoteasa
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-09-22: <a href="entries/MonoBoolTranAlgebra.html">Algebra of Monotonic Boolean Transformers</a>
	<br>
	Author:
	Viorel Preoteasa
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-09-22: <a href="entries/LatticeProperties.html">Lattice Properties</a>
	<br>
	Author:
	Viorel Preoteasa
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-08-26: <a href="entries/Myhill-Nerode.html">The Myhill-Nerode Theorem Based on Regular Expressions</a>
	<br>
	Authors:
	Chunhan Wu,
	Xingyuan Zhang
	and <a href="http://www.inf.kcl.ac.uk/staff/urbanc/">Christian Urban</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-08-19: <a href="entries/Gauss-Jordan-Elim-Fun.html">Gauss-Jordan Elimination for Matrices Represented as Functions</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-07-21: <a href="entries/Max-Card-Matching.html">Maximum Cardinality Matching</a>
	<br>
	Author:
	Christine Rizkallah
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-05-17: <a href="entries/KBPs.html">Knowledge-based programs</a>
	<br>
	Author:
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-04-01: <a href="entries/General-Triangle.html">The General Triangle Is Unique</a>
	<br>
	Author:
	Joachim Breitner
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-03-14: <a href="entries/Transitive-Closure.html">Executable Transitive Closures of Finite Relations</a>
	<br>
	Authors:
	Christian Sternagel
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-02-23: <a href="entries/Nat-Interval-Logic.html">Interval Temporal Logic on Natural Numbers</a>
	<br>
	Author:
	David Trachtenherz
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-02-23: <a href="entries/List-Infinite.html">Infinite Lists</a>
	<br>
	Author:
	David Trachtenherz
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-02-23: <a href="entries/AutoFocus-Stream.html">AutoFocus Stream Processing for Single-Clocking and Multi-Clocking Semantics</a>
	<br>
	Author:
	David Trachtenherz
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-02-07: <a href="entries/LightweightJava.html">Lightweight Java</a>
	<br>
	Authors:
	<a href="http://rok.strnisa.com/lj/">Rok Strniša</a>
	and <a href="http://research.microsoft.com/people/mattpark/">Matthew Parkinson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-01-10: <a href="entries/RIPEMD-160-SPARK.html">RIPEMD-160</a>
	<br>
	Author:
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2011-01-08: <a href="entries/Lower_Semicontinuous.html">Lower Semicontinuous Functions</a>
	<br>
	Author:
	Bogdan Grechuk
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2010</td>
	</tr>
	<tr>
	<td class="entry">
	2010-12-17: <a href="entries/Marriage.html">Hall's Marriage Theorem</a>
	<br>
	Authors:
	Dongchen Jiang
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-11-16: <a href="entries/Shivers-CFA.html">Shivers' Control Flow Analysis</a>
	<br>
	Author:
	Joachim Breitner
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-10-28: <a href="entries/Finger-Trees.html">Finger Trees</a>
	<br>
	Authors:
	Benedikt Nordhoff,
	Stefan Körner
	and <a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-10-28: <a href="entries/Binomial-Queues.html">Functional Binomial Queues</a>
	<br>
	Author:
	René Neumann
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-10-28: <a href="entries/Binomial-Heaps.html">Binomial Heaps and Skew Binomial Heaps</a>
	<br>
	Authors:
	Rene Meis,
	Finn Nielsen
	and <a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-08-29: <a href="entries/Lam-ml-Normalization.html">Strong Normalization of Moggis's Computational Metalanguage</a>
	<br>
	Author:
	Christian Doczkal
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-08-10: <a href="entries/Polynomials.html">Executable Multivariate Polynomials</a>
	<br>
	Authors:
	Christian Sternagel,
	<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>,
	<a href="https://risc.jku.at/m/alexander-maletzky/">Alexander Maletzky</a>,
	<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>,
	<a href="http://isabelle.in.tum.de/~haftmann">Florian Haftmann</a>,
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	and Alexander Bentkamp
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-08-08: <a href="entries/Statecharts.html">Formalizing Statecharts using Hierarchical Automata</a>
	<br>
	Authors:
	Steffen Helke
	and Florian Kammüller
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-06-24: <a href="entries/Free-Groups.html">Free Groups</a>
	<br>
	Author:
	Joachim Breitner
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-06-20: <a href="entries/Category2.html">Category Theory</a>
	<br>
	Author:
	Alexander Katovsky
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-06-17: <a href="entries/Matrix.html">Executable Matrix Operations on Matrices of Arbitrary Dimensions</a>
	<br>
	Authors:
	Christian Sternagel
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-06-14: <a href="entries/Abstract-Rewriting.html">Abstract Rewriting</a>
	<br>
	Authors:
	Christian Sternagel
	and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-05-28: <a href="entries/GraphMarkingIBP.html">Verification of the Deutsch-Schorr-Waite Graph Marking Algorithm using Data Refinement</a>
	<br>
	Authors:
	Viorel Preoteasa
	and <a href="http://users.abo.fi/Ralph-Johan.Back/">Ralph-Johan Back</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-05-28: <a href="entries/DataRefinementIBP.html">Semantics and Data Refinement of Invariant Based Programs</a>
	<br>
	Authors:
	Viorel Preoteasa
	and <a href="http://users.abo.fi/Ralph-Johan.Back/">Ralph-Johan Back</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-05-22: <a href="entries/Robbins-Conjecture.html">A Complete Proof of the Robbins Conjecture</a>
	<br>
	Author:
	Matthew Wampler-Doty
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-05-12: <a href="entries/Regular-Sets.html">Regular Sets and Expressions</a>
	<br>
	Authors:
	<a href="http://www.in.tum.de/~krauss">Alexander Krauss</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-04-30: <a href="entries/Locally-Nameless-Sigma.html">Locally Nameless Sigma Calculus</a>
	<br>
	Authors:
	Ludovic Henrio,
	Florian Kammüller,
	Bianca Lutz
	and Henry Sudhof
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-03-29: <a href="entries/Free-Boolean-Algebra.html">Free Boolean Algebra</a>
	<br>
	Author:
	Brian Huffman
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-03-23: <a href="entries/InformationFlowSlicing_Inter.html">Inter-Procedural Information Flow Noninterference via Slicing</a>
	<br>
	Author:
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-03-23: <a href="entries/InformationFlowSlicing.html">Information Flow Noninterference via Slicing</a>
	<br>
	Author:
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-02-20: <a href="entries/List-Index.html">List Index</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2010-02-12: <a href="entries/Coinductive.html">Coinductive</a>
	<br>
	Author:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2009</td>
	</tr>
	<tr>
	<td class="entry">
	2009-12-09: <a href="entries/DPT-SAT-Solver.html">A Fast SAT Solver for Isabelle in Standard ML</a>
	<br>
	Author:
	Armin Heller
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-12-03: <a href="entries/Presburger-Automata.html">Formalizing the Logic-Automaton Connection</a>
	<br>
	Authors:
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a>
	and Markus Reiter
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-11-25: <a href="entries/Tree-Automata.html">Tree Automata</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-11-25: <a href="entries/Collections.html">Collections Framework</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-11-22: <a href="entries/Perfect-Number-Thm.html">Perfect Number Theorem</a>
	<br>
	Author:
	Mark Ijbema
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-11-13: <a href="entries/HRB-Slicing.html">Backing up Slicing: Verifying the Interprocedural Two-Phase Horwitz-Reps-Binkley Slicer</a>
	<br>
	Author:
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-10-30: <a href="entries/WorkerWrapper.html">The Worker/Wrapper Transformation</a>
	<br>
	Author:
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-09-01: <a href="entries/Ordinals_and_Cardinals.html">Ordinals and Cardinals</a>
	<br>
	Author:
	Andrei Popescu
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-08-28: <a href="entries/SequentInvertibility.html">Invertibility in Sequent Calculi</a>
	<br>
	Author:
	Peter Chapman
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-08-04: <a href="entries/CofGroups.html">An Example of a Cofinitary Group in Isabelle/HOL</a>
	<br>
	Author:
	<a href="http://kasterma.net">Bart Kastermans</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-05-06: <a href="entries/FinFun.html">Code Generation for Functions as Data</a>
	<br>
	Author:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2009-04-29: <a href="entries/Stream-Fusion.html">Stream Fusion</a>
	<br>
	Author:
	Brian Huffman
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2008</td>
	</tr>
	<tr>
	<td class="entry">
	2008-12-12: <a href="entries/BytecodeLogicJmlTypes.html">A Bytecode Logic for JML and Types</a>
	<br>
	Authors:
	Lennart Beringer
	and <a href="http://www.tcs.informatik.uni-muenchen.de/~mhofmann">Martin Hofmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-11-10: <a href="entries/SIFPL.html">Secure information flow and program logics</a>
	<br>
	Authors:
	Lennart Beringer
	and <a href="http://www.tcs.informatik.uni-muenchen.de/~mhofmann">Martin Hofmann</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-11-09: <a href="entries/SenSocialChoice.html">Some classical results in Social Choice Theory</a>
	<br>
	Author:
	<a href="http://peteg.org">Peter Gammie</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-11-07: <a href="entries/FunWithTilings.html">Fun With Tilings</a>
	<br>
	Authors:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	and <a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-10-15: <a href="entries/Huffman.html">The Textbook Proof of Huffman's Algorithm</a>
	<br>
	Author:
	Jasmin Christian Blanchette
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-09-16: <a href="entries/Slicing.html">Towards Certified Slicing</a>
	<br>
	Author:
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-09-02: <a href="entries/VolpanoSmith.html">A Correctness Proof for the Volpano/Smith Security Typing System</a>
	<br>
	Authors:
	<a href="http://pp.info.uni-karlsruhe.de/personhp/gregor_snelting.php">Gregor Snelting</a>
	and <a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-09-01: <a href="entries/ArrowImpossibilityGS.html">Arrow and Gibbard-Satterthwaite</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-08-26: <a href="entries/FunWithFunctions.html">Fun With Functions</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-07-23: <a href="entries/SATSolverVerification.html">Formal Verification of Modern SAT Solvers</a>
	<br>
	Author:
	<a href="http://poincare.matf.bg.ac.rs/~filip/">Filip Maric</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-04-05: <a href="entries/Recursion-Theory-I.html">Recursion Theory I</a>
	<br>
	Author:
	Michael Nedzelsky
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-02-29: <a href="entries/Simpl.html">A Sequential Imperative Programming Language Syntax, Semantics, Hoare Logics and Verification Environment</a>
	<br>
	Author:
	Norbert Schirmer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-02-29: <a href="entries/BDD.html">BDD Normalisation</a>
	<br>
	Authors:
	Veronika Ortner
	and Norbert Schirmer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-02-18: <a href="entries/NormByEval.html">Normalization by Evaluation</a>
	<br>
	Authors:
	<a href="http://www.linta.de/~aehlig/">Klaus Aehlig</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2008-01-11: <a href="entries/LinearQuantifierElim.html">Quantifier Elimination for Linear Arithmetic</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2007</td>
	</tr>
	<tr>
	<td class="entry">
	2007-12-14: <a href="entries/Program-Conflict-Analysis.html">Formalization of Conflict Analysis of Programs with Procedures, Thread Creation, and Monitors</a>
	<br>
	Authors:
	<a href="http://www21.in.tum.de/~lammich">Peter Lammich</a>
	and <a href="http://cs.uni-muenster.de/u/mmo/">Markus Müller-Olm</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2007-12-03: <a href="entries/JinjaThreads.html">Jinja with Threads</a>
	<br>
	Author:
	<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2007-11-06: <a href="entries/MuchAdoAboutTwo.html">Much Ado About Two</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~boehmes/">Sascha Böhme</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2007-08-12: <a href="entries/SumSquares.html">Sums of Two and Four Squares</a>
	<br>
	Author:
	Roelof Oosterhuis
	</td>
	</tr>
	<tr>
	<td class="entry">
	2007-08-12: <a href="entries/Fermat3_4.html">Fermat's Last Theorem for Exponents 3 and 4 and the Parametrisation of Pythagorean Triples</a>
	<br>
	Author:
	Roelof Oosterhuis
	</td>
	</tr>
	<tr>
	<td class="entry">
	2007-08-08: <a href="entries/Valuation.html">Fundamental Properties of Valuation Theory and Hensel's Lemma</a>
	<br>
	Author:
	Hidetsune Kobayashi
	</td>
	</tr>
	<tr>
	<td class="entry">
	2007-08-02: <a href="entries/POPLmark-deBruijn.html">POPLmark Challenge Via de Bruijn Indices</a>
	<br>
	Author:
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2007-08-02: <a href="entries/FOL-Fitting.html">First-Order Logic According to Fitting</a>
	<br>
	Author:
	<a href="http://www.in.tum.de/~berghofe">Stefan Berghofer</a>
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2006</td>
	</tr>
	<tr>
	<td class="entry">
	2006-09-09: <a href="entries/HotelKeyCards.html">Hotel Key Card System</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2006-08-08: <a href="entries/Abstract-Hoare-Logics.html">Abstract Hoare Logics</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2006-05-22: <a href="entries/Flyspeck-Tame.html">Flyspeck I: Tame Graphs</a>
	<br>
	Authors:
	Gertrud Bauer
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2006-05-15: <a href="entries/CoreC++.html">CoreC++</a>
	<br>
	Author:
	<a href="http://pp.info.uni-karlsruhe.de/personhp/daniel_wasserrab.php">Daniel Wasserrab</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2006-03-31: <a href="entries/FeatherweightJava.html">A Theory of Featherweight Java in Isabelle/HOL</a>
	<br>
	Authors:
	<a href="http://www.cs.cornell.edu/~jnfoster/">J. Nathan Foster</a>
	and <a href="http://research.microsoft.com/en-us/people/dimitris/">Dimitrios Vytiniotis</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2006-03-15: <a href="entries/ClockSynchInst.html">Instances of Schneider's generalized protocol of clock synchronization</a>
	<br>
	Author:
	<a href="http://www.cs.famaf.unc.edu.ar/~damian/">Damián Barsotti</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2006-03-14: <a href="entries/Cauchy.html">Cauchy's Mean Theorem and the Cauchy-Schwarz Inequality</a>
	<br>
	Author:
	Benjamin Porter
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2005</td>
	</tr>
	<tr>
	<td class="entry">
	2005-11-11: <a href="entries/Ordinal.html">Countable Ordinals</a>
	<br>
	Author:
	Brian Huffman
	</td>
	</tr>
	<tr>
	<td class="entry">
	2005-10-12: <a href="entries/FFT.html">Fast Fourier Transform</a>
	<br>
	Author:
	<a href="http://www21.in.tum.de/~ballarin/">Clemens Ballarin</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2005-06-24: <a href="entries/GenClock.html">Formalization of a Generalized Protocol for Clock Synchronization</a>
	<br>
	Author:
	Alwen Tiu
	</td>
	</tr>
	<tr>
	<td class="entry">
	2005-06-22: <a href="entries/DiskPaxos.html">Proving the Correctness of Disk Paxos</a>
	<br>
	Authors:
	<a href="http://www.fceia.unr.edu.ar/~mauro/">Mauro Jaskelioff</a>
	and <a href="http://www.loria.fr/~merz">Stephan Merz</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2005-06-20: <a href="entries/JiveDataStoreModel.html">Jive Data and Store Model</a>
	<br>
	Authors:
	Nicole Rauch
	and Norbert Schirmer
	</td>
	</tr>
	<tr>
	<td class="entry">
	2005-06-01: <a href="entries/Jinja.html">Jinja is not Java</a>
	<br>
	Authors:
	<a href="http://www.cse.unsw.edu.au/~kleing/">Gerwin Klein</a>
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2005-05-02: <a href="entries/RSAPSS.html">SHA1, RSA, PSS and more</a>
	<br>
	Authors:
	Christina Lindenberg
	and Kai Wirt
	</td>
	</tr>
	<tr>
	<td class="entry">
	2005-04-21: <a href="entries/Category.html">Category Theory to Yoneda's Lemma</a>
	<br>
	Author:
	<a href="http://users.rsise.anu.edu.au/~okeefe/">Greg O'Keefe</a>
	</td>
	</tr>
	</tbody>
	</table>
	<p> </p>

	<table width="80%" class="entries">
	<tbody>
	<tr>
	<td class="head">2004</td>
	</tr>
	<tr>
	<td class="entry">
	2004-12-09: <a href="entries/FileRefinement.html">File Refinement</a>
	<br>
	Authors:
	<a href="http://www.mit.edu/~kkz/">Karen Zee</a>
	and <a href="http://lara.epfl.ch/~kuncak/">Viktor Kuncak</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-11-19: <a href="entries/Integration.html">Integration theory and random variables</a>
	<br>
	Author:
	<a href="http://www-lti.informatik.rwth-aachen.de/~richter/">Stefan Richter</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-09-28: <a href="entries/Verified-Prover.html">A Mechanically Verified, Efficient, Sound and Complete Theorem Prover For First Order Logic</a>
	<br>
	Author:
	Tom Ridge
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-09-20: <a href="entries/Ramsey-Infinite.html">Ramsey's theorem, infinitary version</a>
	<br>
	Author:
	Tom Ridge
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-09-20: <a href="entries/Completeness.html">Completeness theorem</a>
	<br>
	Authors:
	James Margetson
	and Tom Ridge
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-07-09: <a href="entries/Compiling-Exceptions-Correctly.html">Compiling Exceptions Correctly</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-06-24: <a href="entries/Depth-First-Search.html">Depth First Search</a>
	<br>
	Authors:
	Toshiaki Nishihara
	and Yasuhiko Minamide
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-05-18: <a href="entries/Group-Ring-Module.html">Groups, Rings and Modules</a>
	<br>
	Authors:
	Hidetsune Kobayashi,
	L. Chen
	and H. Murao
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-04-26: <a href="entries/Topology.html">Topology</a>
	<br>
	Author:
	Stefan Friedrich
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-04-26: <a href="entries/Lazy-Lists-II.html">Lazy Lists II</a>
	<br>
	Author:
	Stefan Friedrich
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-04-05: <a href="entries/BinarySearchTree.html">Binary Search Trees</a>
	<br>
	Author:
	<a href="http://lara.epfl.ch/~kuncak/">Viktor Kuncak</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-03-30: <a href="entries/Functional-Automata.html">Functional Automata</a>
	<br>
	Author:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-03-19: <a href="entries/MiniML.html">Mini ML</a>
	<br>
	Authors:
	Wolfgang Naraschewski
	and <a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	</td>
	</tr>
	<tr>
	<td class="entry">
	2004-03-19: <a href="entries/AVL-Trees.html">AVL Trees</a>
	<br>
	Authors:
	<a href="https://www.in.tum.de/~nipkow">Tobias Nipkow</a>
	and Cornelia Pusch
	</td>
	</tr>
	</tbody>
	</table>


	</div>
	</td>

	</tr>
	</tbody>
	</table>


	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/rss.xml b/web/rss.xml
	--- a/web/rss.xml
	+++ b/web/rss.xml
	@@ -1,570 +1,586 @@
	<?xml version="1.0" encoding="UTF-8" ?>
	<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
	<channel>
	<atom:link href="https://www.isa-afp.org/rss.xml" rel="self" type="application/rss+xml" />
	<title>Archive of Formal Proofs</title>
	<link>https://www.isa-afp.org</link>
	<description>
	The Archive of Formal Proofs is a collection of proof libraries, examples,
	and larger scientific developments, mechanically checked
	in the theorem prover Isabelle.
	</description>
	- <pubDate>30 May 2019 00:00:00 +0000</pubDate>
	+ <pubDate>21 Jun 2019 00:00:00 +0000</pubDate>
	+ <item>
	+ <title>Linear Inequalities</title>
	+ <link>https://www.isa-afp.org/entries/Linear_Inequalities.html</link>
	+ <guid>https://www.isa-afp.org/entries/Linear_Inequalities.html</guid>
	+ <dc:creator> Ralph Bottesch, Alban Reynaud, René Thiemann </dc:creator>
	+ <pubDate>21 Jun 2019 00:00:00 +0000</pubDate>
	+ <description>
	+We formalize results about linear inqualities, mainly from
	+Schrijver's book. The main results are the proof of the
	+fundamental theorem on linear inequalities, Farkas' lemma,
	+Carathéodory's theorem, the Farkas-Minkowsky-Weyl theorem, the
	+decomposition theorem of polyhedra, and Meyer's result that the
	+integer hull of a polyhedron is a polyhedron itself. Several theorems
	+include bounds on the appearing numbers, and in particular we provide
	+an a-priori bound on mixed-integer solutions of linear inequalities.</description>
	+ </item>
	+ <item>
	+ <title>Hilbert's Nullstellensatz</title>
	+ <link>https://www.isa-afp.org/entries/Nullstellensatz.html</link>
	+ <guid>https://www.isa-afp.org/entries/Nullstellensatz.html</guid>
	+ <dc:creator> Alexander Maletzky </dc:creator>
	+ <pubDate>16 Jun 2019 00:00:00 +0000</pubDate>
	+ <description>
	+This entry formalizes Hilbert's Nullstellensatz, an important
	+theorem in algebraic geometry that can be viewed as the generalization
	+of the Fundamental Theorem of Algebra to multivariate polynomials: If
	+a set of (multivariate) polynomials over an algebraically closed field
	+has no common zero, then the ideal it generates is the entire
	+polynomial ring. The formalization proves several equivalent versions
	+of this celebrated theorem: the weak Nullstellensatz, the strong
	+Nullstellensatz (connecting algebraic varieties and radical ideals),
	+and the field-theoretic Nullstellensatz. The formalization follows
	+Chapter 4.1. of <a
	+href="https://link.springer.com/book/10.1007/978-0-387-35651-8">Ideals,
	+Varieties, and Algorithms</a> by Cox, Little and O'Shea.</description>
	+ </item>
	+ <item>
	+ <title>Gröbner Bases, Macaulay Matrices and Dubé's Degree Bounds</title>
	+ <link>https://www.isa-afp.org/entries/Groebner_Macaulay.html</link>
	+ <guid>https://www.isa-afp.org/entries/Groebner_Macaulay.html</guid>
	+ <dc:creator> Alexander Maletzky </dc:creator>
	+ <pubDate>15 Jun 2019 00:00:00 +0000</pubDate>
	+ <description>
	+This entry formalizes the connection between Gröbner bases and
	+Macaulay matrices (sometimes also referred to as `generalized
	+Sylvester matrices'). In particular, it contains a method for
	+computing Gröbner bases, which proceeds by first constructing some
	+Macaulay matrix of the initial set of polynomials, then row-reducing
	+this matrix, and finally converting the result back into a set of
	+polynomials. The output is shown to be a Gröbner basis if the Macaulay
	+matrix constructed in the first step is sufficiently large. In order
	+to obtain concrete upper bounds on the size of the matrix (and hence
	+turn the method into an effectively executable algorithm), Dubé's
	+degree bounds on Gröbner bases are utilized; consequently, they are
	+also part of the formalization.</description>
	+ </item>
	+ <item>
	+ <title>Binary Heaps for IMP2</title>
	+ <link>https://www.isa-afp.org/entries/IMP2_Binary_Heap.html</link>
	+ <guid>https://www.isa-afp.org/entries/IMP2_Binary_Heap.html</guid>
	+ <dc:creator> Simon Griebel </dc:creator>
	+ <pubDate>13 Jun 2019 00:00:00 +0000</pubDate>
	+ <description>
	+In this submission array-based binary minimum heaps are formalized.
	+The correctness of the following heap operations is proved: insert,
	+get-min, delete-min and make-heap. These are then used to verify an
	+in-place heapsort. The formalization is based on IMP2, an imperative
	+program verification framework implemented in Isabelle/HOL. The
	+verified heap functions are iterative versions of the partly recursive
	+functions found in "Algorithms and Data Structures – The Basic
	+Toolbox" by K. Mehlhorn and P. Sanders and "Introduction to
	+Algorithms" by T. H. Cormen, C. E. Leiserson, R. L. Rivest and C.
	+Stein.</description>
	+ </item>
	<item>
	<title>Multidimensional Binary Search Trees</title>
	<link>https://www.isa-afp.org/entries/KD_Tree.html</link>
	<guid>https://www.isa-afp.org/entries/KD_Tree.html</guid>
	<dc:creator> Martin Rau </dc:creator>
	<pubDate>30 May 2019 00:00:00 +0000</pubDate>
	<description>
	This entry provides a formalization of multidimensional binary trees,
	also known as k-d trees. It includes a balanced build algorithm as
	well as the nearest neighbor algorithm and the range search algorithm.
	It is based on the papers <a
	href="https://dl.acm.org/citation.cfm?doid=361002.361007">Multidimensional
	binary search trees used for associative searching</a> and <a
	href="https://dl.acm.org/citation.cfm?doid=355744.355745">
	An Algorithm for Finding Best Matches in Logarithmic Expected
	Time</a>.</description>
	</item>
	<item>
	<title>Formalization of Generic Authenticated Data Structures</title>
	<link>https://www.isa-afp.org/entries/LambdaAuth.html</link>
	<guid>https://www.isa-afp.org/entries/LambdaAuth.html</guid>
	<dc:creator> Matthias Brun, Dmitriy Traytel </dc:creator>
	<pubDate>14 May 2019 00:00:00 +0000</pubDate>
	<description>
	Authenticated data structures are a technique for outsourcing data
	storage and maintenance to an untrusted server. The server is required
	to produce an efficiently checkable and cryptographically secure proof
	that it carried out precisely the requested computation. <a
	href="https://doi.org/10.1145/2535838.2535851">Miller et
	al.</a> introduced &lambda;&bull; (pronounced
	<i>lambda auth</i>)&mdash;a functional programming
	language with a built-in primitive authentication construct, which
	supports a wide range of user-specified authenticated data structures
	while guaranteeing certain correctness and security properties for all
	well-typed programs. We formalize &lambda;&bull; and prove its
	correctness and security properties. With Isabelle's help, we
	uncover and repair several mistakes in the informal proofs and lemma
	statements. Our findings are summarized in a <a
	href="http://people.inf.ethz.ch/trayteld/papers/lambdaauth/lambdaauth.pdf">paper
	draft</a>.</description>
	</item>
	<item>
	<title>Multi-Party Computation</title>
	<link>https://www.isa-afp.org/entries/Multi_Party_Computation.html</link>
	<guid>https://www.isa-afp.org/entries/Multi_Party_Computation.html</guid>
	<dc:creator> David Aspinall, David Butler </dc:creator>
	<pubDate>09 May 2019 00:00:00 +0000</pubDate>
	<description>
	We use CryptHOL to consider Multi-Party Computation (MPC) protocols.
	MPC was first considered by Yao in 1983 and recent advances in
	efficiency and an increased demand mean it is now deployed in the real
	world. Security is considered using the real/ideal world paradigm. We
	first define security in the semi-honest security setting where
	parties are assumed not to deviate from the protocol transcript. In
	this setting we prove multiple Oblivious Transfer (OT) protocols
	secure and then show security for the gates of the GMW protocol. We
	then define malicious security, this is a stronger notion of security
	where parties are assumed to be fully corrupted by an adversary. In
	this setting we again consider OT, as it is a fundamental building
	block of almost all MPC protocols.</description>
	</item>
	<item>
	<title>HOL-CSP Version 2.0</title>
	<link>https://www.isa-afp.org/entries/HOL-CSP.html</link>
	<guid>https://www.isa-afp.org/entries/HOL-CSP.html</guid>
	<dc:creator> Safouan Taha, Lina Ye, Burkhart Wolff </dc:creator>
	<pubDate>26 Apr 2019 00:00:00 +0000</pubDate>
	<description>
	This is a complete formalization of the work of Hoare and Roscoe on
	the denotational semantics of the Failure/Divergence Model of CSP. It
	follows essentially the presentation of CSP in Roscoe’s Book ”Theory
	and Practice of Concurrency” [8] and the semantic details in a joint
	Paper of Roscoe and Brooks ”An improved failures model for
	communicating processes". The present work is based on a prior
	formalization attempt, called HOL-CSP 1.0, done in 1997 by H. Tej and
	B. Wolff with the Isabelle proof technology available at that time.
	This work revealed minor, but omnipresent foundational errors in key
	concepts like the process invariant. The present version HOL-CSP
	profits from substantially improved libraries (notably HOLCF),
	improved automated proof techniques, and structured proof techniques
	in Isar and is substantially shorter but more complete.</description>
	</item>
	<item>
	<title>A Compositional and Unified Translation of LTL into ω-Automata</title>
	<link>https://www.isa-afp.org/entries/LTL_Master_Theorem.html</link>
	<guid>https://www.isa-afp.org/entries/LTL_Master_Theorem.html</guid>
	<dc:creator> Benedikt Seidl, Salomon Sickert </dc:creator>
	<pubDate>16 Apr 2019 00:00:00 +0000</pubDate>
	<description>
	We present a formalisation of the unified translation approach of
	linear temporal logic (LTL) into ω-automata from [1]. This approach
	decomposes LTL formulas into ``simple'' languages and allows
	a clear separation of concerns: first, we formalise the purely logical
	result yielding this decomposition; second, we instantiate this
	generic theory to obtain a construction for deterministic
	(state-based) Rabin automata (DRA). We extract from this particular
	instantiation an executable tool translating LTL to DRAs. To the best
	of our knowledge this is the first verified translation from LTL to
	DRAs that is proven to be double exponential in the worst case which
	asymptotically matches the known lower bound.
	<p>
	[1] Javier Esparza, Jan Kretínský, Salomon Sickert. One Theorem to Rule Them All:
	A Unified Translation of LTL into ω-Automata. LICS 2018</description>
	</item>
	<item>
	<title>A General Theory of Syntax with Bindings</title>
	<link>https://www.isa-afp.org/entries/Binding_Syntax_Theory.html</link>
	<guid>https://www.isa-afp.org/entries/Binding_Syntax_Theory.html</guid>
	<dc:creator> Lorenzo Gheri, Andrei Popescu </dc:creator>
	<pubDate>06 Apr 2019 00:00:00 +0000</pubDate>
	<description>
	We formalize a theory of syntax with bindings that has been developed
	and refined over the last decade to support several large
	formalization efforts. Terms are defined for an arbitrary number of
	constructors of varying numbers of inputs, quotiented to
	alpha-equivalence and sorted according to a binding signature. The
	theory includes many properties of the standard operators on terms:
	substitution, swapping and freshness. It also includes bindings-aware
	induction and recursion principles and support for semantic
	interpretation. This work has been presented in the ITP 2017 paper “A
	Formalized General Theory of Syntax with Bindings”.</description>
	</item>
	<item>
	<title>The Transcendence of Certain Infinite Series</title>
	<link>https://www.isa-afp.org/entries/Transcendence_Series_Hancl_Rucki.html</link>
	<guid>https://www.isa-afp.org/entries/Transcendence_Series_Hancl_Rucki.html</guid>
	<dc:creator> Angeliki Koutsoukou-Argyraki, Wenda Li </dc:creator>
	<pubDate>27 Mar 2019 00:00:00 +0000</pubDate>
	<description>
	We formalize the proofs of two transcendence criteria by J. Hančl
	and P. Rucki that assert the transcendence of the sums of certain
	infinite series built up by sequences that fulfil certain properties.
	Both proofs make use of Roth's celebrated theorem on diophantine
	approximations to algebraic numbers from 1955 which we implement as
	an assumption without having formalised its proof.</description>
	</item>
	<item>
	<title>Quantum Hoare Logic</title>
	<link>https://www.isa-afp.org/entries/QHLProver.html</link>
	<guid>https://www.isa-afp.org/entries/QHLProver.html</guid>
	<dc:creator> Junyi Liu, Bohua Zhan, Shuling Wang, Shenggang Ying, Tao Liu, Yangjia Li, Mingsheng Ying, Naijun Zhan </dc:creator>
	<pubDate>24 Mar 2019 00:00:00 +0000</pubDate>
	<description>
	We formalize quantum Hoare logic as given in [1]. In particular, we
	specify the syntax and denotational semantics of a simple model of
	quantum programs. Then, we write down the rules of quantum Hoare logic
	for partial correctness, and show the soundness and completeness of
	the resulting proof system. As an application, we verify the
	correctness of Grover’s algorithm.</description>
	</item>
	<item>
	<title>Safe OCL</title>
	<link>https://www.isa-afp.org/entries/Safe_OCL.html</link>
	<guid>https://www.isa-afp.org/entries/Safe_OCL.html</guid>
	<dc:creator> Denis Nikiforov </dc:creator>
	<pubDate>09 Mar 2019 00:00:00 +0000</pubDate>
	<description>
	<p>The theory is a formalization of the
	<a href="https://www.omg.org/spec/OCL/">OCL</a> type system, its abstract
	syntax and expression typing rules. The theory does not define a concrete
	syntax and a semantics. In contrast to
	<a href="https://www.isa-afp.org/entries/Featherweight_OCL.html">Featherweight OCL</a>,
	it is based on a deep embedding approach. The type system is defined from scratch,
	it is not based on the Isabelle HOL type system.</p>
	<p>The Safe OCL distincts nullable and non-nullable types. Also the theory gives a
	formal definition of <a href="http://ceur-ws.org/Vol-1512/paper07.pdf">safe
	navigation operations</a>. The Safe OCL typing rules are much stricter than rules
	given in the OCL specification. It allows one to catch more errors on a type
	checking phase.</p>
	<p>The type theory presented is four-layered: classes, basic types, generic types,
	errorable types. We introduce the following new types: non-nullable types (T[1]),
	nullable types (T[?]), OclSuper. OclSuper is a supertype of all other types (basic
	types, collections, tuples). This type allows us to define a total supremum function,
	so types form an upper semilattice. It allows us to define rich expression typing
	rules in an elegant manner.</p>
	<p>The Preliminaries Chapter of the theory defines a number of helper lemmas for
	transitive closures and tuples. It defines also a generic object model independent
	from OCL. It allows one to use the theory as a reference for formalization of analogous languages.</p></description>
	</item>
	<item>
	<title>Elementary Facts About the Distribution of Primes</title>
	<link>https://www.isa-afp.org/entries/Prime_Distribution_Elementary.html</link>
	<guid>https://www.isa-afp.org/entries/Prime_Distribution_Elementary.html</guid>
	<dc:creator> Manuel Eberl </dc:creator>
	<pubDate>21 Feb 2019 00:00:00 +0000</pubDate>
	<description>
	<p>This entry is a formalisation of Chapter 4 (and parts of
	Chapter 3) of Apostol's <a
	href="https://www.springer.com/de/book/9780387901633"><em>Introduction
	to Analytic Number Theory</em></a>. The main topics that
	are addressed are properties of the distribution of prime numbers that
	can be shown in an elementary way (i.&thinsp;e. without the Prime
	Number Theorem), the various equivalent forms of the PNT (which imply
	each other in elementary ways), and consequences that follow from the
	PNT in elementary ways. The latter include, most notably, asymptotic
	bounds for the number of distinct prime factors of
	<em>n</em>, the divisor function
	<em>d(n)</em>, Euler's totient function
	<em>&phi;(n)</em>, and
	lcm(1,&hellip;,<em>n</em>).</p></description>
	</item>
	<item>
	<title>Kruskal's Algorithm for Minimum Spanning Forest</title>
	<link>https://www.isa-afp.org/entries/Kruskal.html</link>
	<guid>https://www.isa-afp.org/entries/Kruskal.html</guid>
	<dc:creator> Maximilian P.L. Haslbeck, Peter Lammich, Julian Biendarra </dc:creator>
	<pubDate>14 Feb 2019 00:00:00 +0000</pubDate>
	<description>
	This Isabelle/HOL formalization defines a greedy algorithm for finding
	a minimum weight basis on a weighted matroid and proves its
	correctness. This algorithm is an abstract version of Kruskal's
	algorithm. We interpret the abstract algorithm for the cycle matroid
	(i.e. forests in a graph) and refine it to imperative executable code
	using an efficient union-find data structure. Our formalization can
	be instantiated for different graph representations. We provide
	instantiations for undirected graphs and symmetric directed graphs.</description>
	</item>
	<item>
	<title>Probabilistic Primality Testing</title>
	<link>https://www.isa-afp.org/entries/Probabilistic_Prime_Tests.html</link>
	<guid>https://www.isa-afp.org/entries/Probabilistic_Prime_Tests.html</guid>
	<dc:creator> Daniel Stüwe, Manuel Eberl </dc:creator>
	<pubDate>11 Feb 2019 00:00:00 +0000</pubDate>
	<description>
	<p>The most efficient known primality tests are
	<em>probabilistic</em> in the sense that they use
	randomness and may, with some probability, mistakenly classify a
	composite number as prime &ndash; but never a prime number as
	composite. Examples of this are the Miller&ndash;Rabin test, the
	Solovay&ndash;Strassen test, and (in most cases) Fermat's
	test.</p> <p>This entry defines these three tests and
	proves their correctness. It also develops some of the
	number-theoretic foundations, such as Carmichael numbers and the
	Jacobi symbol with an efficient executable algorithm to compute
	it.</p></description>
	</item>
	<item>
	<title>Universal Turing Machine</title>
	<link>https://www.isa-afp.org/entries/Universal_Turing_Machine.html</link>
	<guid>https://www.isa-afp.org/entries/Universal_Turing_Machine.html</guid>
	<dc:creator> Jian Xu, Xingyuan Zhang, Christian Urban, Sebastiaan J. C. Joosten </dc:creator>
	<pubDate>08 Feb 2019 00:00:00 +0000</pubDate>
	<description>
	We formalise results from computability theory: recursive functions,
	undecidability of the halting problem, and the existence of a
	universal Turing machine. This formalisation is the AFP entry
	corresponding to the paper Mechanising Turing Machines and Computability Theory
	in Isabelle/HOL, ITP 2013.</description>
	</item>
	<item>
	<title>Isabelle/UTP: Mechanised Theory Engineering for Unifying Theories of Programming</title>
	<link>https://www.isa-afp.org/entries/UTP.html</link>
	<guid>https://www.isa-afp.org/entries/UTP.html</guid>
	<dc:creator> Simon Foster, Frank Zeyda, Yakoub Nemouchi, Pedro Ribeiro, Burkhart Wolff </dc:creator>
	<pubDate>01 Feb 2019 00:00:00 +0000</pubDate>
	<description>
	Isabelle/UTP is a mechanised theory engineering toolkit based on Hoare
	and He’s Unifying Theories of Programming (UTP). UTP enables the
	creation of denotational, algebraic, and operational semantics for
	different programming languages using an alphabetised relational
	calculus. We provide a semantic embedding of the alphabetised
	relational calculus in Isabelle/HOL, including new type definitions,
	relational constructors, automated proof tactics, and accompanying
	algebraic laws. Isabelle/UTP can be used to both capture laws of
	programming for different languages, and put these fundamental
	theorems to work in the creation of associated verification tools,
	using calculi like Hoare logics. This document describes the
	relational core of the UTP in Isabelle/HOL.</description>
	</item>
	<item>
	<title>The Inversions of a List</title>
	<link>https://www.isa-afp.org/entries/List_Inversions.html</link>
	<guid>https://www.isa-afp.org/entries/List_Inversions.html</guid>
	<dc:creator> Manuel Eberl </dc:creator>
	<pubDate>01 Feb 2019 00:00:00 +0000</pubDate>
	<description>
	<p>This entry defines the set of <em>inversions</em>
	of a list, i.e. the pairs of indices that violate sortedness. It also
	proves the correctness of the well-known
	<em>O</em>(<em>n log n</em>)
	divide-and-conquer algorithm to compute the number of
	inversions.</p></description>
	</item>
	<item>
	<title>Farkas' Lemma and Motzkin's Transposition Theorem</title>
	<link>https://www.isa-afp.org/entries/Farkas.html</link>
	<guid>https://www.isa-afp.org/entries/Farkas.html</guid>
	<dc:creator> Ralph Bottesch, Max W. Haslbeck, René Thiemann </dc:creator>
	<pubDate>17 Jan 2019 00:00:00 +0000</pubDate>
	<description>
	We formalize a proof of Motzkin's transposition theorem and
	Farkas' lemma in Isabelle/HOL. Our proof is based on the
	formalization of the simplex algorithm which, given a set of linear
	constraints, either returns a satisfying assignment to the problem or
	detects unsatisfiability. By reusing facts about the simplex algorithm
	we show that a set of linear constraints is unsatisfiable if and only
	if there is a linear combination of the constraints which evaluates to
	a trivially unsatisfiable inequality.</description>
	</item>
	<item>
	<title>IMP2 – Simple Program Verification in Isabelle/HOL</title>
	<link>https://www.isa-afp.org/entries/IMP2.html</link>
	<guid>https://www.isa-afp.org/entries/IMP2.html</guid>
	<dc:creator> Peter Lammich, Simon Wimmer </dc:creator>
	<pubDate>15 Jan 2019 00:00:00 +0000</pubDate>
	<description>
	IMP2 is a simple imperative language together with Isabelle tooling to
	create a program verification environment in Isabelle/HOL. The tools
	include a C-like syntax, a verification condition generator, and
	Isabelle commands for the specification of programs. The framework is
	modular, i.e., it allows easy reuse of already proved programs within
	larger programs. This entry comes with a quickstart guide and a large
	collection of examples, spanning basic algorithms with simple proofs
	to more advanced algorithms and proof techniques like data refinement.
	Some highlights from the examples are: <ul> <li>Bisection
	Square Root, </li> <li>Extended Euclid, </li>
	<li>Exponentiation by Squaring, </li> <li>Binary
	Search, </li> <li>Insertion Sort, </li>
	<li>Quicksort, </li> <li>Depth First Search.
	</li> </ul> The abstract syntax and semantics are very
	simple and well-documented. They are suitable to be used in a course,
	as extension to the IMP language which comes with the Isabelle
	distribution. While this entry is limited to a simple imperative
	language, the ideas could be extended to more sophisticated languages.</description>
	</item>
	<item>
	<title>An Algebra for Higher-Order Terms</title>
	<link>https://www.isa-afp.org/entries/Higher_Order_Terms.html</link>
	<guid>https://www.isa-afp.org/entries/Higher_Order_Terms.html</guid>
	<dc:creator> Lars Hupel </dc:creator>
	<pubDate>15 Jan 2019 00:00:00 +0000</pubDate>
	<description>
	In this formalization, I introduce a higher-order term algebra,
	generalizing the notions of free variables, matching, and
	substitution. The need arose from the work on a <a
	href="http://dx.doi.org/10.1007/978-3-319-89884-1_35">verified
	compiler from Isabelle to CakeML</a>. Terms can be thought of as
	consisting of a generic (free variables, constants, application) and
	a specific part. As example applications, this entry provides
	instantiations for de-Bruijn terms, terms with named variables, and
	<a
	href="https://www.isa-afp.org/entries/Lambda_Free_RPOs.html">Blanchette’s
	&lambda;-free higher-order terms</a>. Furthermore, I
	implement translation functions between de-Bruijn terms and named
	terms and prove their correctness.</description>
	</item>
	<item>
	<title>A Reduction Theorem for Store Buffers</title>
	<link>https://www.isa-afp.org/entries/Store_Buffer_Reduction.html</link>
	<guid>https://www.isa-afp.org/entries/Store_Buffer_Reduction.html</guid>
	<dc:creator> Ernie Cohen, Norbert Schirmer </dc:creator>
	<pubDate>07 Jan 2019 00:00:00 +0000</pubDate>
	<description>
	When verifying a concurrent program, it is usual to assume that memory
	is sequentially consistent. However, most modern multiprocessors
	depend on store buffering for efficiency, and provide native
	sequential consistency only at a substantial performance penalty. To
	regain sequential consistency, a programmer has to follow an
	appropriate programming discipline. However, na&iuml;ve disciplines,
	such as protecting all shared accesses with locks, are not flexible
	enough for building high-performance multiprocessor software. We
	present a new discipline for concurrent programming under TSO (total
	store order, with store buffer forwarding). It does not depend on
	concurrency primitives, such as locks. Instead, threads use ghost
	operations to acquire and release ownership of memory addresses. A
	thread can write to an address only if no other thread owns it, and
	can read from an address only if it owns it or it is shared and the
	thread has flushed its store buffer since it last wrote to an address
	it did not own. This discipline covers both coarse-grained concurrency
	(where data is protected by locks) as well as fine-grained concurrency
	(where atomic operations race to memory). We formalize this
	discipline in Isabelle/HOL, and prove that if every execution of a
	program in a system without store buffers follows the discipline, then
	every execution of the program with store buffers is sequentially
	consistent. Thus, we can show sequential consistency under TSO by
	ordinary assertional reasoning about the program, without having to
	consider store buffers at all.</description>
	</item>
	<item>
	<title>A Formal Model of the Document Object Model</title>
	<link>https://www.isa-afp.org/entries/Core_DOM.html</link>
	<guid>https://www.isa-afp.org/entries/Core_DOM.html</guid>
	<dc:creator> Achim D. Brucker, Michael Herzberg </dc:creator>
	<pubDate>26 Dec 2018 00:00:00 +0000</pubDate>
	<description>
	In this AFP entry, we formalize the core of the Document Object Model
	(DOM). At its core, the DOM defines a tree-like data structure for
	representing documents in general and HTML documents in particular. It
	is the heart of any modern web browser. Formalizing the key concepts
	of the DOM is a prerequisite for the formal reasoning over client-side
	JavaScript programs and for the analysis of security concepts in
	modern web browsers. We present a formalization of the core DOM, with
	focus on the node-tree and the operations defined on node-trees, in
	Isabelle/HOL. We use the formalization to verify the functional
	correctness of the most important functions defined in the DOM
	standard. Moreover, our formalization is 1) extensible, i.e., can be
	extended without the need of re-proving already proven properties and
	2) executable, i.e., we can generate executable code from our
	specification.</description>
	</item>
	<item>
	<title>Formalization of Concurrent Revisions</title>
	<link>https://www.isa-afp.org/entries/Concurrent_Revisions.html</link>
	<guid>https://www.isa-afp.org/entries/Concurrent_Revisions.html</guid>
	<dc:creator> Roy Overbeek </dc:creator>
	<pubDate>25 Dec 2018 00:00:00 +0000</pubDate>
	<description>
	Concurrent revisions is a concurrency control model developed by
	Microsoft Research. It has many interesting properties that
	distinguish it from other well-known models such as transactional
	memory. One of these properties is <em>determinacy</em>:
	programs written within the model always produce the same outcome,
	independent of scheduling activity. The concurrent revisions model has
	an operational semantics, with an informal proof of determinacy. This
	document contains an Isabelle/HOL formalization of this semantics and
	the proof of determinacy.</description>
	</item>
	<item>
	<title>Verifying Imperative Programs using Auto2</title>
	<link>https://www.isa-afp.org/entries/Auto2_Imperative_HOL.html</link>
	<guid>https://www.isa-afp.org/entries/Auto2_Imperative_HOL.html</guid>
	<dc:creator> Bohua Zhan </dc:creator>
	<pubDate>21 Dec 2018 00:00:00 +0000</pubDate>
	<description>
	This entry contains the application of auto2 to verifying functional
	and imperative programs. Algorithms and data structures that are
	verified include linked lists, binary search trees, red-black trees,
	interval trees, priority queue, quicksort, union-find, Dijkstra's
	algorithm, and a sweep-line algorithm for detecting rectangle
	intersection. The imperative verification is based on Imperative HOL
	and its separation logic framework. A major goal of this work is to
	set up automation in order to reduce the length of proof that the user
	needs to provide, both for verifying functional programs and for
	working with separation logic.</description>
	</item>
	<item>
	<title>Constructive Cryptography in HOL</title>
	<link>https://www.isa-afp.org/entries/Constructive_Cryptography.html</link>
	<guid>https://www.isa-afp.org/entries/Constructive_Cryptography.html</guid>
	<dc:creator> Andreas Lochbihler, S. Reza Sefidgar </dc:creator>
	<pubDate>17 Dec 2018 00:00:00 +0000</pubDate>
	<description>
	Inspired by Abstract Cryptography, we extend CryptHOL, a framework for
	formalizing game-based proofs, with an abstract model of Random
	Systems and provide proof rules about their composition and equality.
	This foundation facilitates the formalization of Constructive
	Cryptography proofs, where the security of a cryptographic scheme is
	realized as a special form of construction in which a complex random
	system is built from simpler ones. This is a first step towards a
	fully-featured compositional framework, similar to Universal
	Composability framework, that supports formalization of
	simulation-based proofs.</description>
	</item>
	<item>
	<title>Transformer Semantics</title>
	<link>https://www.isa-afp.org/entries/Transformer_Semantics.html</link>
	<guid>https://www.isa-afp.org/entries/Transformer_Semantics.html</guid>
	<dc:creator> Georg Struth </dc:creator>
	<pubDate>11 Dec 2018 00:00:00 +0000</pubDate>
	<description>
	These mathematical components formalise predicate transformer
	semantics for programs, yet currently only for partial correctness and
	in the absence of faults. A first part for isotone (or monotone),
	Sup-preserving and Inf-preserving transformers follows Back and von
	Wright's approach, with additional emphasis on the quantalic
	structure of algebras of transformers. The second part develops
	Sup-preserving and Inf-preserving predicate transformers from the
	powerset monad, via its Kleisli category and Eilenberg-Moore algebras,
	with emphasis on adjunctions and dualities, as well as isomorphisms
	between relations, state transformers and predicate transformers.</description>
	</item>
	<item>
	<title>Quantales</title>
	<link>https://www.isa-afp.org/entries/Quantales.html</link>
	<guid>https://www.isa-afp.org/entries/Quantales.html</guid>
	<dc:creator> Georg Struth </dc:creator>
	<pubDate>11 Dec 2018 00:00:00 +0000</pubDate>
	<description>
	These mathematical components formalise basic properties of quantales,
	together with some important models, constructions, and concepts,
	including quantic nuclei and conuclei.</description>
	</item>
	<item>
	<title>Properties of Orderings and Lattices</title>
	<link>https://www.isa-afp.org/entries/Order_Lattice_Props.html</link>
	<guid>https://www.isa-afp.org/entries/Order_Lattice_Props.html</guid>
	<dc:creator> Georg Struth </dc:creator>
	<pubDate>11 Dec 2018 00:00:00 +0000</pubDate>
	<description>
	These components add further fundamental order and lattice-theoretic
	concepts and properties to Isabelle's libraries. They follow by
	and large the introductory sections of the Compendium of Continuous
	Lattices, covering directed and filtered sets, down-closed and
	up-closed sets, ideals and filters, Galois connections, closure and
	co-closure operators. Some emphasis is on duality and morphisms
	between structures, as in the Compendium. To this end, three ad-hoc
	approaches to duality are compared.</description>
	</item>
	- <item>
	- <title>Graph Saturation</title>
	- <link>https://www.isa-afp.org/entries/Graph_Saturation.html</link>
	- <guid>https://www.isa-afp.org/entries/Graph_Saturation.html</guid>
	- <dc:creator> Sebastiaan J. C. Joosten </dc:creator>
	- <pubDate>23 Nov 2018 00:00:00 +0000</pubDate>
	- <description>
	-This is an Isabelle/HOL formalisation of graph saturation, closely
	-following a <a href="https://doi.org/10.1016/j.jlamp.2018.06.005">paper by the author</a> on graph saturation.
	-Nine out of ten lemmas of the original paper are proven in this
	-formalisation. The formalisation additionally includes two theorems
	-that show the main premise of the paper: that consistency and
	-entailment are decided through graph saturation. This formalisation
	-does not give executable code, and it did not implement any of the
	-optimisations suggested in the paper.</description>
	- </item>
	- <item>
	- <title>A Verified Functional Implementation of Bachmair and Ganzinger's Ordered Resolution Prover</title>
	- <link>https://www.isa-afp.org/entries/Functional_Ordered_Resolution_Prover.html</link>
	- <guid>https://www.isa-afp.org/entries/Functional_Ordered_Resolution_Prover.html</guid>
	- <dc:creator> Anders Schlichtkrull, Jasmin Christian Blanchette, Dmitriy Traytel </dc:creator>
	- <pubDate>23 Nov 2018 00:00:00 +0000</pubDate>
	- <description>
	-This Isabelle/HOL formalization refines the abstract ordered
	-resolution prover presented in Section 4.3 of Bachmair and
	-Ganzinger's "Resolution Theorem Proving" chapter in the
	-<i>Handbook of Automated Reasoning</i>. The result is a
	-functional implementation of a first-order prover.</description>
	- </item>
	- <item>
	- <title>Auto2 Prover</title>
	- <link>https://www.isa-afp.org/entries/Auto2_HOL.html</link>
	- <guid>https://www.isa-afp.org/entries/Auto2_HOL.html</guid>
	- <dc:creator> Bohua Zhan </dc:creator>
	- <pubDate>20 Nov 2018 00:00:00 +0000</pubDate>
	- <description>
	-Auto2 is a saturation-based heuristic prover for higher-order logic,
	-implemented as a tactic in Isabelle. This entry contains the
	-instantiation of auto2 for Isabelle/HOL, along with two basic
	-examples: solutions to some of the Pelletier’s problems, and
	-elementary number theory of primes.</description>
	- </item>
	- <item>
	- <title>Matroids</title>
	- <link>https://www.isa-afp.org/entries/Matroids.html</link>
	- <guid>https://www.isa-afp.org/entries/Matroids.html</guid>
	- <dc:creator> Jonas Keinholz </dc:creator>
	- <pubDate>16 Nov 2018 00:00:00 +0000</pubDate>
	- <description>
	-<p>This article defines the combinatorial structures known as
	-<em>Independence Systems</em> and
	-<em>Matroids</em> and provides basic concepts and theorems
	-related to them. These structures play an important role in
	-combinatorial optimisation, e. g. greedy algorithms such as
	-Kruskal's algorithm. The development is based on Oxley's
	-<a href="http://www.math.lsu.edu/~oxley/survey4.pdf">`What
	-is a Matroid?'</a>.</p></description>
	- </item>
	</channel>
	</rss>
	diff --git a/web/statistics.html b/web/statistics.html
	--- a/web/statistics.html
	+++ b/web/statistics.html
	@@ -1,304 +1,313 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Archive of Formal Proofs</title>
	<link rel="stylesheet" type="text/css" href="front.css">
	<link rel="icon" href="images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1><font class="first">S</font>tatistics
	</h1>
	<p> </p>

	<table width="80%" class="descr">
	<tbody>
	<tr><td>
	<h2>Statistics</h2>

	<table>
	-<tr><td>Number of Articles:</td><td class="statsnumber">474</td></tr>
	-<tr><td>Number of Authors:</td><td class="statsnumber">321</td></tr>
	-<tr><td>Number of lemmas:</td><td class="statsnumber">~133,000</td></tr>
	-<tr><td>Lines of Code:</td><td class="statsnumber">~2,237,800</td></tr>
	+<tr><td>Number of Articles:</td><td class="statsnumber">478</td></tr>
	+<tr><td>Number of Authors:</td><td class="statsnumber">323</td></tr>
	+<tr><td>Number of lemmas:</td><td class="statsnumber">~133,900</td></tr>
	+<tr><td>Lines of Code:</td><td class="statsnumber">~2,256,600</td></tr>
	</table>
	<h4>Most used AFP articles:</h4>
	<table id="most_used">
	<tr>
	<th></th><th>Name</th><th>Used by ? articles</th>
	</tr>

	<tr><td>1.</td>

	<td><a href="entries/Collections.html">Collections</a></td>
	<td>15</td>
	</tr>
	<tr><td>2.</td>

	<td><a href="entries/List-Index.html">List-Index</a></td>
	<td>14</td>
	</tr>
	<tr><td>3.</td>

	<td><a href="entries/Coinductive.html">Coinductive</a></td>
	<td>12</td>
	</tr>
	<td></td>
	<td><a href="entries/Regular-Sets.html">Regular-Sets</a></td>
	<td>12</td>
	</tr>
	<td></td>
	<td><a href="entries/Show.html">Show</a></td>
	<td>12</td>
	</tr>
	<tr><td>4.</td>

	<td><a href="entries/Landau_Symbols.html">Landau_Symbols</a></td>
	<td>11</td>
	</tr>
	<tr><td>5.</td>

	<td><a href="entries/Abstract-Rewriting.html">Abstract-Rewriting</a></td>
	<td>10</td>
	</tr>
	<td></td>
	<td><a href="entries/Deriving.html">Deriving</a></td>
	<td>10</td>
	</tr>
	<tr><td>6.</td>

	<td><a href="entries/Automatic_Refinement.html">Automatic_Refinement</a></td>
	<td>9</td>
	</tr>
	<tr><td>7.</td>

	<td><a href="entries/CAVA_Automata.html">CAVA_Automata</a></td>
	<td>8</td>
	</tr>
	+ <tr><td>8.</td>
	+
	+ <td><a href="entries/Jordan_Normal_Form.html">Jordan_Normal_Form</a></td>
	+ <td>7</td>
	+ </tr>
	<td></td>
	<td><a href="entries/Native_Word.html">Native_Word</a></td>
	- <td>8</td>
	+ <td>7</td>
	+ </tr>
	+ <td></td>
	+ <td><a href="entries/Polynomial_Factorization.html">Polynomial_Factorization</a></td>
	+ <td>7</td>
	</tr>

	</table>
	<script>
	// DATA
	var years = [2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019];
	-var no_articles = [14, 22, 29, 37, 52, 64, 86, 103, 128, 151, 208, 253, 326, 396, 455, 474];
	-var no_loc = [61000.0, 96800.0, 131400.0, 238900.0, 353800.0, 435900.0, 517100.0, 568100.0, 740400.0, 828000.0, 1037600.0, 1216000.0, 1579400.0, 1824800.0, 2098300.0, 2237800.0 ];
	-var no_authors = [14, 11, 6, 6, 10, 6, 24, 11, 17, 16, 36, 20, 63, 31, 29, 21];
	-var no_authors_series = [14, 25, 31, 37, 47, 53, 77, 88, 105, 121, 157, 177, 240, 271, 300, 321];
	-var all_articles = [ "MiniML","AVL-Trees","Functional-Automata","BinarySearchTree","Lazy-Lists-II","Topology","Group-Ring-Module","Depth-First-Search","Compiling-Exceptions-Correctly","Completeness","Ramsey-Infinite","Verified-Prover","Integration","FileRefinement","Category","RSAPSS","Jinja","JiveDataStoreModel","DiskPaxos","GenClock","FFT","Ordinal","Cauchy","ClockSynchInst","FeatherweightJava","CoreC++","Flyspeck-Tame","Abstract-Hoare-Logics","HotelKeyCards","FOL-Fitting","POPLmark-deBruijn","Valuation","SumSquares","Fermat3_4","MuchAdoAboutTwo","JinjaThreads","Program-Conflict-Analysis","LinearQuantifierElim","NormByEval","Simpl","BDD","Recursion-Theory-I","SATSolverVerification","FunWithFunctions","ArrowImpossibilityGS","VolpanoSmith","Slicing","Huffman","FunWithTilings","SenSocialChoice","SIFPL","BytecodeLogicJmlTypes","Stream-Fusion","FinFun","CofGroups","SequentInvertibility","Ordinals_and_Cardinals","WorkerWrapper","HRB-Slicing","Perfect-Number-Thm","Collections","Tree-Automata","Presburger-Automata","DPT-SAT-Solver","Coinductive","List-Index","InformationFlowSlicing","InformationFlowSlicing_Inter","Free-Boolean-Algebra","Locally-Nameless-Sigma","Regular-Sets","Robbins-Conjecture","DataRefinementIBP","GraphMarkingIBP","Abstract-Rewriting","Matrix","Category2","Free-Groups","Statecharts","Polynomials","Lam-ml-Normalization","Binomial-Queues","Binomial-Heaps","Finger-Trees","Shivers-CFA","Marriage","Lower_Semicontinuous","RIPEMD-160-SPARK","LightweightJava","List-Infinite","AutoFocus-Stream","Nat-Interval-Logic","Transitive-Closure","General-Triangle","KBPs","Max-Card-Matching","Gauss-Jordan-Elim-Fun","Myhill-Nerode","LatticeProperties","MonoBoolTranAlgebra","PseudoHoops","Efficient-Mergesort","TLA","Markov_Models","Dijkstra_Shortest_Path","Refine_Monadic","Girth_Chromatic","Transitive-Closure-II","Abortable_Linearizable_Modules","Well_Quasi_Orders","Ordinary_Differential_Equations","Inductive_Confidentiality","Stuttering_Equivalence","Separation_Algebra","Circus","Psi_Calculi","CCS","Pi_Calculus","Tycon","PCF","Heard_Of","Impossible_Geometry","Datatype_Order_Generator","Possibilistic_Noninterference","Bondy","Tarskis_Geometry","Open_Induction","Separation_Logic_Imperative_HOL","Sqrt_Babylonian","Kleene_Algebra","Rank_Nullity_Theorem","Ribbon_Proofs","Launchbury","Nominal2","Containers","Graph_Theory","ShortestPath","Sort_Encodings","Koenigsberg_Friendship","Lehmer","Pratt_Certificate","IEEE_Floating_Point","Native_Word","Automatic_Refinement","Decreasing-Diagrams","GoedelGod","FocusStreamsCaseStudies","Coinductive_Languages","Incompleteness","HereditarilyFinite","Tail_Recursive_Functions","CryptoBasedCompositionalProperties","Sturm_Sequences","Featherweight_OCL","KAT_and_DRA","Relation_Algebra","Secondary_Sylow","Regex_Equivalence","Real_Impl","Affine_Arithmetic","Selection_Heap_Sort","Random_Graph_Subgraph_Threshold","Partial_Function_MR","AWN","Probabilistic_Noninterference","GPU_Kernel_PL","Discrete_Summation","HyperCTL","Abstract_Completeness","Bounded_Deducibility_Security","SIFUM_Type_Systems","WHATandWHERE_Security","Strong_Security","ComponentDependencies","Regular_Algebras","Noninterference_CSP","Roy_Floyd_Warshall","Gabow_SCC","CAVA_Automata","CAVA_LTL_Modelchecker","LTL_to_GBA","Promela","Boolean_Expression_Checkers","MSO_Regex_Equivalence","Pop_Refinement","Network_Security_Policy_Verification","Amortized_Complexity","pGCL","CISC-Kernel","Show","Splay_Tree","Skew_Heap","VectorSpace","Special_Function_Bounds","Gauss_Jordan","Priority_Queue_Braun","Jordan_Hoelder","Cayley_Hamilton","Sturm_Tarski","Imperative_Insertion_Sort","Certification_Monads","XML","RefinementReactive","Density_Compiler","Stream_Fusion_Code","Lifting_Definition_Option","AODV","UPF","UpDown_Scheme","Finite_Automata_HF","QR_Decomposition","Echelon_Form","Call_Arity","Deriving","Consensus_Refined","Trie","ConcurrentIMP","ConcurrentGC","Residuated_Lattices","Vickrey_Clarke_Groves","Probabilistic_System_Zoo","Formula_Derivatives","Dynamic_Tables","Noninterference_Ipurge_Unwinding","Noninterference_Generic_Unwinding","List_Interleaving","Multirelations","Derangements","Hermite","Akra_Bazzi","Landau_Symbols","Case_Labeling","Encodability_Process_Calculi","Rep_Fin_Groups","Noninterference_Inductive_Unwinding","Decreasing-Diagrams-II","Jordan_Normal_Form","LTL_to_DRA","Isabelle_Meta_Model","Parity_Game","Planarity_Certificates","TortoiseHare","Euler_Partition","Ergodic_Theory","Latin_Square","Card_Partitions","Applicative_Lifting","Algebraic_Numbers","Stern_Brocot","Liouville_Numbers","Prime_Harmonic_Series","Triangle","Descartes_Sign_Rule","Card_Number_Partitions","Matrix_Tensor","Knot_Theory","Polynomial_Factorization","Polynomial_Interpolation","Formal_SSA","List_Update","LTL","Cartan_FP","Timed_Automata","PropResPI","KAD","Noninterference_Sequential_Composition","ROBDD","CYK","No_FTL_observers","Groebner_Bases","Bell_Numbers_Spivey","SDS_Impossibility","Randomised_Social_Choice","MFMC_Countable","FLP","Perron_Frobenius","Incredible_Proof_Machine","Posix-Lexing","Card_Equiv_Relations","Tree_Decomposition","Word_Lib","Noninterference_Concurrent_Composition","Algebraic_VCs","Catalan_Numbers","Dependent_SIFUM_Type_Systems","Card_Multisets","Category3","Dependent_SIFUM_Refinement","IP_Addresses","Rewriting_Z","Resolution_FOL","Buildings","DFS_Framework","Pairing_Heap","Surprise_Paradox","Ptolemys_Theorem","Refine_Imperative_HOL","EdmondsKarp_Maxflow","InfPathElimination","Simple_Firewall","Routing","Stirling_Formula","Stone_Algebras","SuperCalc","Iptables_Semantics","Lambda_Free_RPOs","Allen_Calculus","Fisher_Yates","Lp","Chord_Segments","Berlekamp_Zassenhaus","Source_Coding_Theorem","SPARCv8","LOFT","Stable_Matching","Modal_Logics_for_NTS","Deep_Learning","Lambda_Free_KBOs","Nested_Multisets_Ordinals","Separata","Abs_Int_ITP2012","Complx","Paraconsistency","Proof_Strategy_Language","Twelvefold_Way","Concurrent_Ref_Alg","FOL_Harrison","Password_Authentication_Protocol","UPF_Firewall","E_Transcendental","Bertrands_Postulate","Minimal_SSA","Bernoulli","Key_Agreement_Strong_Adversaries","Stone_Relation_Algebras","Abstract_Soundness","Differential_Dynamic_Logic","Menger","Elliptic_Curves_Group_Law","Euler_MacLaurin","Quick_Sort_Cost","Comparison_Sort_Lower_Bound","Random_BSTs","Subresultants","Lazy_Case","Constructor_Funs","LocalLexing","Types_Tableaus_and_Goedels_God","MonoidalCategory","Game_Based_Crypto","Monomorphic_Monad","Probabilistic_While","Monad_Normalisation","CryptHOL","Floyd_Warshall","Security_Protocol_Refinement","Dict_Construction","Optics","Flow_Networks","Prpu_Maxflow","Buffons_Needle","PSemigroupsConvolution","Propositional_Proof_Systems","Stone_Kleene_Relation_Algebras","CRDT","Name_Carrying_Type_Inference","Minkowskis_Theorem","HOLCF-Prelude","Decl_Sem_Fun_PL","DynamicArchitectures","Stewart_Apollonius","LambdaMu","Orbit_Stabiliser","Root_Balanced_Tree","First_Welfare_Theorem","AnselmGod","PLM","Lowe_Ontological_Argument","Dirichlet_Series","Zeta_Function","Linear_Recurrences","Diophantine_Eqns_Lin_Hom","Winding_Number_Eval","Count_Complex_Roots","Buchi_Complementation","Transition_Systems_and_Automata","Kuratowski_Closure_Complement","Hybrid_Multi_Lane_Spatial_Logic","IMAP-CRDT","Stochastic_Matrices","Knuth_Morris_Pratt","BNF_Operations","Dirichlet_L","Mason_Stothers","Median_Of_Medians_Selection","Falling_Factorial_Sum","Taylor_Models","Green","Gromov_Hyperbolicity","Ordered_Resolution_Prover","LLL_Basis_Reduction","Treaps","First_Order_Terms","Error_Function","LLL_Factorization","Hoare_Time","Architectural_Design_Patterns","CakeML","Weight_Balanced_Trees","Fishburn_Impossibility","BNF_CC","VerifyThis2018","WebAssembly","Modular_Assembly_Kit_Security","OpSets","Monad_Memo_DP","AxiomaticCategoryTheory","Irrationality_J_Hancl","Probabilistic_Timed_Automata","Hidden_Markov_Models","Optimal_BST","Partial_Order_Reduction","Projective_Geometry","Localization_Ring","Pell","Neumann_Morgenstern_Utility","DiscretePricing","Minsky_Machines","Simplex","Budan_Fourier","Quaternions","Octonions","Aggregation_Algebras","Prime_Number_Theorem","Signature_Groebner","Symmetric_Polynomials","Pi_Transcendental","Factored_Transition_System_Bounding","Lambda_Free_EPO","Randomised_BSTs","Smooth_Manifolds","Epistemic_Logic","GewirthPGCProof","Generic_Deriving","Matroids","Auto2_HOL","Functional_Ordered_Resolution_Prover","Graph_Saturation","Transformer_Semantics","Order_Lattice_Props","Quantales","Constructive_Cryptography","Auto2_Imperative_HOL","Concurrent_Revisions","Core_DOM","Store_Buffer_Reduction","Higher_Order_Terms","IMP2","Farkas","List_Inversions","UTP","Universal_Turing_Machine","Probabilistic_Prime_Tests","Kruskal","Prime_Distribution_Elementary","Safe_OCL","QHLProver","Transcendence_Series_Hancl_Rucki","Binding_Syntax_Theory","LTL_Master_Theorem","HOL-CSP","Multi_Party_Computation","LambdaAuth","KD_Tree"];
	-var years_loc_articles = [ 2004 , , , , , , , , , , , , , ,2005 , , , , , , , ,2006 , , , , , , ,2007 , , , , , , , ,2008 , , , , , , , , , , , , , , ,2009 , , , , , , , , , , , ,2010 , , , , , , , , , , , , , , , , , , , , , ,2011 , , , , , , , , , , , , , , , , ,2012 , , , , , , , , , , , , , , , , , , , , , , , , ,2013 , , , , , , , , , , , , , , , , , , , , , , ,2014 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2015 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2016 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2017 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2018 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2019 , , , , , , , , , , , , , , , , , ,];
	-var loc_articles = [ "1825","839","1544","1096","1058","2419","44269","205","142","1994","209","1109","3792","506","1141","3769","17203","3119","6430","1145","447","2537","1275","1583","1838","12833","13114","2685","1228","3556","4269","9649","970","2851","1741","79734","4738","3395","2186","31192","10664","6723","30332","180","794","1047","14411","2080","254","2221","5958","3462","799","1540","684","6654","8","2627","27490","330","32411","5025","4380","210","9533","447","2380","3399","611","6311","2042","840","713","1024","5632","1427","4078","2230","6061","22617","1602","1587","3370","2449","2592","260","1620","16","2930","7805","6557","6381","992","125","10136","332","235","1828","1039","1784","4425","295","4461","11857","2834","8583","1043","408","2940","2613","38037","3243","1450","2611","3153","27588","2580","25275","2266","4107","7701","1245","260","5309","73","9729","719","6673","1524","4354","1248","1908","6215","4974","10067","7894","538","3830","4595","202","848","1750","5209","10327","1524","150","5292","706","10777","2248","1458","1958","3067","11485","1860","1190","1219","2175","1144","14896","2215","1964","166","10685","6420","572","590","1698","465","883","4133","2138","1403","2280","1959","2467","220","5379","4431","9387","4041","4463","406","5930","1829","12887","2974","9475","4560","931","649","110","2338","1653","9143","185","2113","875","1727","627","931","1201","1296","7880","1922","90","28055","2879","2794","1116","4863","5258","8842","1169","6178","527","1601","6194","1782","5327","1085","4103","952","2446","1089","1060","2362","468","2068","3761","2148","710","16080","8267","908","1063","21109","9679","8635","3142","9161","690","460","13816","478","898","2715","10061","1162","401","495","500","741","843","3622","4616","6217","4120","8166","12107","2688","518","17583","2876","2411","5496","2453","886","1162","17386","509","702","5036","9700","4287","5354","3813","656","329","1057","7841","3257","2593","553","8478","206","18865","8773","3315","398","2960","12833","9483","375","173","384","18976","2545","6119","3777","1017","1892","4254","9356","20034","4032","3420","319","3204","171","19514","541","14618","2647","7033","7590","3898","3244","4493","855","2289","5004","1349","276","4339","1475","3482","7115","9662","601","1722","852","1627","12220","4035","590","13560","1695","4484","1641","835","694","737","3346","105","68","10492","1127","8000","4135","4711","1200","378","9435","2078","14059","639","1674","3930","4869","445","1531","5554","5553","1991","4205","478","4121","3146","3471","88","480","1261","1877","2199","250","10669","854","7461","3343","3071","2808","8849","5262","2237","4994","944","6519","992","489","809","8891","3131","338","854","493","5936","9462","16020","6058","10251","1818","2288","785","3252","8438","3278","13076","592","841","3383","3642","11559","13548","3734","5742","530","1049","7673","1042","1259","5297","2754","1390","1622","2173","13374","805","10026","2667","540","1271","3955","5323","9770","2765","934","11924","2375","1743","8098","1490","449","685","1811","1132","3248","3578","1644","2983","2218","7210","4968","2767","15247","34365","3259","6022","1900","372","10335","16867","3015","3300","5302","4577","10486","1000","15843","3108","9487","5414","3308","1515"];
	+var no_articles = [14, 22, 29, 37, 52, 64, 86, 103, 128, 151, 208, 253, 326, 396, 455, 478];
	+var no_loc = [61000.0, 96800.0, 131400.0, 238900.0, 353800.0, 435900.0, 517100.0, 568100.0, 740400.0, 828000.0, 1037600.0, 1216000.0, 1579300.0, 1824800.0, 2098200.0, 2256600.0 ];
	+var no_authors = [14, 11, 6, 6, 10, 6, 24, 11, 17, 16, 36, 20, 63, 31, 29, 23];
	+var no_authors_series = [14, 25, 31, 37, 47, 53, 77, 88, 105, 121, 157, 177, 240, 271, 300, 323];
	+var all_articles = [ "MiniML","AVL-Trees","Functional-Automata","BinarySearchTree","Lazy-Lists-II","Topology","Group-Ring-Module","Depth-First-Search","Compiling-Exceptions-Correctly","Completeness","Ramsey-Infinite","Verified-Prover","Integration","FileRefinement","Category","RSAPSS","Jinja","JiveDataStoreModel","DiskPaxos","GenClock","FFT","Ordinal","Cauchy","ClockSynchInst","FeatherweightJava","CoreC++","Flyspeck-Tame","Abstract-Hoare-Logics","HotelKeyCards","FOL-Fitting","POPLmark-deBruijn","Valuation","SumSquares","Fermat3_4","MuchAdoAboutTwo","JinjaThreads","Program-Conflict-Analysis","LinearQuantifierElim","NormByEval","Simpl","BDD","Recursion-Theory-I","SATSolverVerification","FunWithFunctions","ArrowImpossibilityGS","VolpanoSmith","Slicing","Huffman","FunWithTilings","SenSocialChoice","SIFPL","BytecodeLogicJmlTypes","Stream-Fusion","FinFun","CofGroups","SequentInvertibility","Ordinals_and_Cardinals","WorkerWrapper","HRB-Slicing","Perfect-Number-Thm","Collections","Tree-Automata","Presburger-Automata","DPT-SAT-Solver","Coinductive","List-Index","InformationFlowSlicing","InformationFlowSlicing_Inter","Free-Boolean-Algebra","Locally-Nameless-Sigma","Regular-Sets","Robbins-Conjecture","DataRefinementIBP","GraphMarkingIBP","Abstract-Rewriting","Matrix","Category2","Free-Groups","Statecharts","Polynomials","Lam-ml-Normalization","Binomial-Queues","Binomial-Heaps","Finger-Trees","Shivers-CFA","Marriage","Lower_Semicontinuous","RIPEMD-160-SPARK","LightweightJava","List-Infinite","AutoFocus-Stream","Nat-Interval-Logic","Transitive-Closure","General-Triangle","KBPs","Max-Card-Matching","Gauss-Jordan-Elim-Fun","Myhill-Nerode","LatticeProperties","MonoBoolTranAlgebra","PseudoHoops","Efficient-Mergesort","TLA","Markov_Models","Dijkstra_Shortest_Path","Refine_Monadic","Girth_Chromatic","Transitive-Closure-II","Abortable_Linearizable_Modules","Well_Quasi_Orders","Ordinary_Differential_Equations","Inductive_Confidentiality","Stuttering_Equivalence","Separation_Algebra","Circus","Psi_Calculi","CCS","Pi_Calculus","Tycon","PCF","Heard_Of","Impossible_Geometry","Datatype_Order_Generator","Possibilistic_Noninterference","Bondy","Tarskis_Geometry","Open_Induction","Separation_Logic_Imperative_HOL","Sqrt_Babylonian","Kleene_Algebra","Rank_Nullity_Theorem","Ribbon_Proofs","Launchbury","Nominal2","Containers","Graph_Theory","ShortestPath","Sort_Encodings","Koenigsberg_Friendship","Lehmer","Pratt_Certificate","IEEE_Floating_Point","Native_Word","Automatic_Refinement","Decreasing-Diagrams","GoedelGod","FocusStreamsCaseStudies","Coinductive_Languages","Incompleteness","HereditarilyFinite","Tail_Recursive_Functions","CryptoBasedCompositionalProperties","Sturm_Sequences","Featherweight_OCL","KAT_and_DRA","Relation_Algebra","Secondary_Sylow","Regex_Equivalence","Real_Impl","Affine_Arithmetic","Selection_Heap_Sort","Random_Graph_Subgraph_Threshold","Partial_Function_MR","AWN","Probabilistic_Noninterference","GPU_Kernel_PL","Discrete_Summation","HyperCTL","Abstract_Completeness","Bounded_Deducibility_Security","SIFUM_Type_Systems","WHATandWHERE_Security","Strong_Security","ComponentDependencies","Regular_Algebras","Noninterference_CSP","Roy_Floyd_Warshall","Gabow_SCC","CAVA_Automata","CAVA_LTL_Modelchecker","LTL_to_GBA","Promela","Boolean_Expression_Checkers","MSO_Regex_Equivalence","Pop_Refinement","Network_Security_Policy_Verification","Amortized_Complexity","pGCL","CISC-Kernel","Show","Splay_Tree","Skew_Heap","VectorSpace","Special_Function_Bounds","Gauss_Jordan","Priority_Queue_Braun","Jordan_Hoelder","Cayley_Hamilton","Sturm_Tarski","Imperative_Insertion_Sort","Certification_Monads","XML","RefinementReactive","Density_Compiler","Stream_Fusion_Code","Lifting_Definition_Option","AODV","UPF","UpDown_Scheme","Finite_Automata_HF","QR_Decomposition","Echelon_Form","Call_Arity","Deriving","Consensus_Refined","Trie","ConcurrentIMP","ConcurrentGC","Residuated_Lattices","Vickrey_Clarke_Groves","Probabilistic_System_Zoo","Formula_Derivatives","Dynamic_Tables","Noninterference_Ipurge_Unwinding","Noninterference_Generic_Unwinding","List_Interleaving","Multirelations","Derangements","Hermite","Akra_Bazzi","Landau_Symbols","Case_Labeling","Encodability_Process_Calculi","Rep_Fin_Groups","Noninterference_Inductive_Unwinding","Decreasing-Diagrams-II","Jordan_Normal_Form","LTL_to_DRA","Isabelle_Meta_Model","Parity_Game","Planarity_Certificates","TortoiseHare","Euler_Partition","Ergodic_Theory","Latin_Square","Card_Partitions","Applicative_Lifting","Algebraic_Numbers","Stern_Brocot","Liouville_Numbers","Prime_Harmonic_Series","Triangle","Descartes_Sign_Rule","Card_Number_Partitions","Matrix_Tensor","Knot_Theory","Polynomial_Factorization","Polynomial_Interpolation","Formal_SSA","List_Update","LTL","Cartan_FP","Timed_Automata","PropResPI","KAD","Noninterference_Sequential_Composition","ROBDD","CYK","No_FTL_observers","Groebner_Bases","Bell_Numbers_Spivey","SDS_Impossibility","Randomised_Social_Choice","MFMC_Countable","FLP","Perron_Frobenius","Incredible_Proof_Machine","Posix-Lexing","Card_Equiv_Relations","Tree_Decomposition","Word_Lib","Noninterference_Concurrent_Composition","Algebraic_VCs","Catalan_Numbers","Dependent_SIFUM_Type_Systems","Card_Multisets","Category3","Dependent_SIFUM_Refinement","IP_Addresses","Rewriting_Z","Resolution_FOL","Buildings","DFS_Framework","Pairing_Heap","Surprise_Paradox","Ptolemys_Theorem","Refine_Imperative_HOL","EdmondsKarp_Maxflow","InfPathElimination","Simple_Firewall","Routing","Stirling_Formula","Stone_Algebras","SuperCalc","Iptables_Semantics","Lambda_Free_RPOs","Allen_Calculus","Fisher_Yates","Lp","Chord_Segments","Berlekamp_Zassenhaus","Source_Coding_Theorem","SPARCv8","LOFT","Stable_Matching","Modal_Logics_for_NTS","Deep_Learning","Lambda_Free_KBOs","Nested_Multisets_Ordinals","Separata","Abs_Int_ITP2012","Complx","Paraconsistency","Proof_Strategy_Language","Twelvefold_Way","Concurrent_Ref_Alg","FOL_Harrison","Password_Authentication_Protocol","UPF_Firewall","E_Transcendental","Bertrands_Postulate","Minimal_SSA","Bernoulli","Key_Agreement_Strong_Adversaries","Stone_Relation_Algebras","Abstract_Soundness","Differential_Dynamic_Logic","Menger","Elliptic_Curves_Group_Law","Euler_MacLaurin","Quick_Sort_Cost","Comparison_Sort_Lower_Bound","Random_BSTs","Subresultants","Lazy_Case","Constructor_Funs","LocalLexing","Types_Tableaus_and_Goedels_God","MonoidalCategory","Game_Based_Crypto","Monomorphic_Monad","Probabilistic_While","Monad_Normalisation","CryptHOL","Floyd_Warshall","Security_Protocol_Refinement","Dict_Construction","Optics","Flow_Networks","Prpu_Maxflow","Buffons_Needle","PSemigroupsConvolution","Propositional_Proof_Systems","Stone_Kleene_Relation_Algebras","CRDT","Name_Carrying_Type_Inference","Minkowskis_Theorem","HOLCF-Prelude","Decl_Sem_Fun_PL","DynamicArchitectures","Stewart_Apollonius","LambdaMu","Orbit_Stabiliser","Root_Balanced_Tree","First_Welfare_Theorem","AnselmGod","PLM","Lowe_Ontological_Argument","Dirichlet_Series","Zeta_Function","Linear_Recurrences","Diophantine_Eqns_Lin_Hom","Winding_Number_Eval","Count_Complex_Roots","Buchi_Complementation","Transition_Systems_and_Automata","Kuratowski_Closure_Complement","Hybrid_Multi_Lane_Spatial_Logic","IMAP-CRDT","Stochastic_Matrices","Knuth_Morris_Pratt","BNF_Operations","Dirichlet_L","Mason_Stothers","Median_Of_Medians_Selection","Falling_Factorial_Sum","Taylor_Models","Green","Gromov_Hyperbolicity","Ordered_Resolution_Prover","LLL_Basis_Reduction","Treaps","First_Order_Terms","Error_Function","LLL_Factorization","Hoare_Time","Architectural_Design_Patterns","CakeML","Weight_Balanced_Trees","Fishburn_Impossibility","BNF_CC","VerifyThis2018","WebAssembly","Modular_Assembly_Kit_Security","OpSets","Monad_Memo_DP","AxiomaticCategoryTheory","Irrationality_J_Hancl","Probabilistic_Timed_Automata","Hidden_Markov_Models","Optimal_BST","Partial_Order_Reduction","Projective_Geometry","Localization_Ring","Pell","Neumann_Morgenstern_Utility","DiscretePricing","Minsky_Machines","Simplex","Budan_Fourier","Quaternions","Octonions","Aggregation_Algebras","Prime_Number_Theorem","Signature_Groebner","Symmetric_Polynomials","Pi_Transcendental","Factored_Transition_System_Bounding","Lambda_Free_EPO","Randomised_BSTs","Smooth_Manifolds","Epistemic_Logic","GewirthPGCProof","Generic_Deriving","Matroids","Auto2_HOL","Functional_Ordered_Resolution_Prover","Graph_Saturation","Transformer_Semantics","Order_Lattice_Props","Quantales","Constructive_Cryptography","Auto2_Imperative_HOL","Concurrent_Revisions","Core_DOM","Store_Buffer_Reduction","Higher_Order_Terms","IMP2","Farkas","List_Inversions","UTP","Universal_Turing_Machine","Probabilistic_Prime_Tests","Kruskal","Prime_Distribution_Elementary","Safe_OCL","QHLProver","Transcendence_Series_Hancl_Rucki","Binding_Syntax_Theory","LTL_Master_Theorem","HOL-CSP","Multi_Party_Computation","LambdaAuth","KD_Tree","IMP2_Binary_Heap","Groebner_Macaulay","Nullstellensatz","Linear_Inequalities"];
	+var years_loc_articles = [ 2004 , , , , , , , , , , , , , ,2005 , , , , , , , ,2006 , , , , , , ,2007 , , , , , , , ,2008 , , , , , , , , , , , , , , ,2009 , , , , , , , , , , , ,2010 , , , , , , , , , , , , , , , , , , , , , ,2011 , , , , , , , , , , , , , , , , ,2012 , , , , , , , , , , , , , , , , , , , , , , , , ,2013 , , , , , , , , , , , , , , , , , , , , , , ,2014 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2015 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2016 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2017 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2018 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2019 , , , , , , , , , , , , , , , , , , , , , ,];
	+var loc_articles = [ "1825","839","1544","1096","1058","2419","44269","205","142","1994","209","1109","3792","506","1141","3769","17203","3119","6430","1145","447","2537","1275","1583","1838","12833","13114","2685","1228","3556","4269","9649","970","2851","1741","79734","4738","3396","2186","31192","10664","6723","30332","180","794","1047","14411","2080","254","2221","5958","3462","799","1540","684","6654","8","2627","27490","330","32411","5025","4380","210","9533","447","2380","3399","611","6311","2042","840","713","1024","5632","1427","4078","2230","6061","22617","1602","1587","3370","2449","2592","260","1620","16","2930","7805","6557","6381","992","125","10136","332","235","1828","1039","1784","4425","295","4461","11857","2834","8583","1043","408","2940","2613","38037","3243","1450","2611","3153","27588","2580","25275","2266","4107","7701","1245","260","5309","73","9729","719","6673","1511","4354","1248","1908","6215","4974","10067","7894","538","3830","4595","202","848","1748","5209","10327","1524","150","5292","706","10774","2248","1458","1958","3067","11485","1860","1190","1219","2175","1144","14896","2215","1964","166","10685","6420","572","590","1698","465","883","4133","2138","1403","2280","1959","2467","220","5379","4431","9387","4041","4463","406","5930","1829","12887","2974","9486","4560","931","649","110","2338","1653","9143","185","2113","875","1727","627","931","1201","1296","7880","1922","90","28055","2879","2794","1116","4863","5258","8842","1169","6178","527","1601","6194","1782","5327","1085","4103","952","2446","1089","1060","2362","468","2068","3761","2148","710","16080","8267","908","1063","21109","9679","8635","3142","9161","690","435","13819","478","898","2715","10063","1162","401","495","500","741","843","3622","4616","6217","4121","8166","12107","2688","518","17583","2876","2411","5496","2453","886","1162","17386","509","702","5036","9700","4287","5354","3813","656","329","1057","7840","3257","2593","553","8478","206","18865","8773","3315","398","2960","12833","9483","375","173","384","18976","2545","6119","3777","1017","1892","4254","9356","20034","4032","3420","319","3204","171","19514","541","14618","2647","7033","7590","3898","3244","4493","855","2289","5004","1349","276","4339","1475","3482","7115","9662","601","1722","852","1627","12220","4035","590","13560","1695","4484","1641","835","694","737","3346","105","68","10492","1127","8000","4135","4711","1200","378","9435","2078","14059","639","1674","3930","4869","445","1531","5554","5553","1991","4205","478","4121","3146","3471","88","480","1261","1877","2199","250","10669","854","7461","3343","3071","2808","8850","5261","2237","4959","944","6519","992","489","809","8891","3131","338","854","493","5936","9462","16025","6058","10249","1818","2288","785","3252","8438","3278","13076","592","841","3383","3642","11559","13548","3734","5742","530","1049","7674","1042","1259","5297","2754","1390","1622","2173","13355","805","10026","2667","540","1271","3955","5323","9770","2765","934","11924","2375","1743","8098","1490","449","685","1811","1132","3248","3578","1644","2983","2218","7221","4968","2767","15247","34365","3259","6022","1900","372","10335","16867","3015","3300","5302","4576","10486","1000","15843","3106","9487","5415","3300","1518","805","10253","2607","5193"];

	</script>
	<h4>Growth in number of articles:</h4>
	<script src="Chart.js"></script>
	<div class="chart">
	<canvas id="NumberOfArticles" width="400" height="400"></canvas>
	</div>
	<script>
	var ctx = document.getElementById("NumberOfArticles");
	var myChart = new Chart(ctx, {
	type: 'bar',
	data: {
	labels: years,
	datasets: [{
	label: 'size of the AFP in # of articles',
	data: no_articles,
	backgroundColor: "rgba(46, 45, 78, 1)"
	}],
	},
	options: {
	responsive: true,
	maintainAspectRatio: true,
	scales: {
	yAxes: [{
	ticks: {
	beginAtZero:true
	}
	}]
	},
	}
	});
	</script>

	<h4>Growth in lines of code:</h4>
	<div class="chart">
	<canvas id="NumberOfLoc" width="400" height="400"></canvas>
	</div>
	<script>
	var ctx = document.getElementById("NumberOfLoc");
	var myChart = new Chart(ctx, {
	type: 'bar',
	data: {
	labels: years,
	datasets: [{
	label: 'size of the AFP in lines of code',
	data: no_loc,
	backgroundColor: "rgba(101, 99, 136, 1)"
	}],
	},
	options: {
	responsive: true,
	maintainAspectRatio: true,
	scales: {
	yAxes: [{
	ticks: {
	beginAtZero:true
	}
	}]
	},
	}
	});
	</script>

	<h4>Growth in number of authors:</h4>
	<div class="chart">
	<canvas id="NumberOfAuthors" width="400" height="400"></canvas>
	</div>
	<script>
	var ctx = document.getElementById("NumberOfAuthors");
	var myChart = new Chart(ctx, {
	type: 'bar',
	data: {
	labels: years,
	datasets: [{
	label: 'new authors per year',
	data: no_authors,
	backgroundColor: "rgba(101, 99, 136, 1)"
	},
	{
	label: 'number of authors contributing (cumulative)',
	data: no_authors_series,
	backgroundColor: "rgba(0, 15, 48, 1)"
	}],
	},
	options: {
	responsive: true,
	maintainAspectRatio: true,
	scales: {
	yAxes: [{
	ticks: {
	beginAtZero:true
	}
	}]
	},
	}
	});
	</script>

	<h4>Size of articles:</h4>
	<div style="width: 800px" class="chart">
	<canvas id="LocArticles" width="800" height="400"></canvas>
	</div>
	<script>
	var ctx = document.getElementById("LocArticles");
	var myChart = new Chart(ctx, {
	type: 'bar',
	data: {
	labels: years_loc_articles,
	datasets: [{
	label: 'loc per article',
	data: loc_articles,
	backgroundColor: "rgba(101, 99, 136, 1)"
	}]
	},
	options: {
	responsive: true,
	maintainAspectRatio: true,
	scales: {
	xAxes: [{
	categoryPercentage: 1,
	barPercentage: 0.9,
	ticks: {
	autoSkip: false
	}
	}],
	yAxes: [{
	ticks: {
	beginAtZero:true
	}
	}]
	},
	tooltips: {
	callbacks: {
	title: function(tooltipItem, data) {
	return all_articles[tooltipItem[0].index];
	}
	}
	}
	}
	});
	</script>

	</td></tr>

	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>

	<script src="Chart.js"></script>

	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/topics.html b/web/topics.html
	--- a/web/topics.html
	+++ b/web/topics.html
	@@ -1,767 +1,773 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Archive of Formal Proofs</title>
	<link rel="stylesheet" type="text/css" href="front.css">
	<link rel="icon" href="images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1><font class="first">I</font>ndex by <font class="first">T</font>opic
	</h1>
	<p> </p>

	<table width="80%" class="descr">
	<tbody>
	<tr>
	<td>
	<h2>Computer Science</h2>
	<div class="list">
	</div>
	<h3>Automata and Formal Languages</h3>
	<div class="list">
	<a href="entries/Partial_Order_Reduction.html">Partial_Order_Reduction</a>
	<a href="entries/Posix-Lexing.html">Posix-Lexing</a>
	<a href="entries/LocalLexing.html">LocalLexing</a>
	<a href="entries/KBPs.html">KBPs</a>
	<a href="entries/Regular-Sets.html">Regular-Sets</a>
	<a href="entries/Regex_Equivalence.html">Regex_Equivalence</a>
	<a href="entries/MSO_Regex_Equivalence.html">MSO_Regex_Equivalence</a>
	<a href="entries/Formula_Derivatives.html">Formula_Derivatives</a>
	<a href="entries/Myhill-Nerode.html">Myhill-Nerode</a>
	<a href="entries/Universal_Turing_Machine.html">Universal_Turing_Machine</a>
	<a href="entries/CYK.html">CYK</a>
	<a href="entries/Presburger-Automata.html">Presburger-Automata</a>
	<a href="entries/Functional-Automata.html">Functional-Automata</a>
	<a href="entries/Statecharts.html">Statecharts</a>
	<a href="entries/Stuttering_Equivalence.html">Stuttering_Equivalence</a>
	<a href="entries/Coinductive_Languages.html">Coinductive_Languages</a>
	<a href="entries/Tree-Automata.html">Tree-Automata</a>
	<a href="entries/Kleene_Algebra.html">Kleene_Algebra</a>
	<a href="entries/KAT_and_DRA.html">KAT_and_DRA</a>
	<a href="entries/KAD.html">KAD</a>
	<a href="entries/Regular_Algebras.html">Regular_Algebras</a>
	<a href="entries/Markov_Models.html">Markov_Models</a>
	<a href="entries/Probabilistic_System_Zoo.html">Probabilistic_System_Zoo</a>
	<a href="entries/CAVA_Automata.html">CAVA_Automata</a>
	<a href="entries/LTL.html">LTL</a>
	<a href="entries/LTL_to_GBA.html">LTL_to_GBA</a>
	<a href="entries/CAVA_LTL_Modelchecker.html">CAVA_LTL_Modelchecker</a>
	<a href="entries/Probabilistic_Timed_Automata.html">Probabilistic_Timed_Automata</a>
	<a href="entries/Finite_Automata_HF.html">Finite_Automata_HF</a>
	<a href="entries/LTL_to_DRA.html">LTL_to_DRA</a>
	<a href="entries/Timed_Automata.html">Timed_Automata</a>
	<a href="entries/Stochastic_Matrices.html">Stochastic_Matrices</a>
	<a href="entries/Buchi_Complementation.html">Buchi_Complementation</a>
	<a href="entries/Transition_Systems_and_Automata.html">Transition_Systems_and_Automata</a>
	<a href="entries/Factored_Transition_System_Bounding.html">Factored_Transition_System_Bounding</a>
	<a href="entries/LTL_Master_Theorem.html">LTL_Master_Theorem</a>
	</div>
	<h3>Algorithms</h3>
	<div class="list">
	<a href="entries/Knuth_Morris_Pratt.html">Knuth_Morris_Pratt</a>
	<a href="entries/Probabilistic_While.html">Probabilistic_While</a>
	<a href="entries/Comparison_Sort_Lower_Bound.html">Comparison_Sort_Lower_Bound</a>
	<a href="entries/Quick_Sort_Cost.html">Quick_Sort_Cost</a>
	<a href="entries/DFS_Framework.html">DFS_Framework</a>
	<a href="entries/Prpu_Maxflow.html">Prpu_Maxflow</a>
	<a href="entries/TortoiseHare.html">TortoiseHare</a>
	<a href="entries/Floyd_Warshall.html">Floyd_Warshall</a>
	<a href="entries/Roy_Floyd_Warshall.html">Roy_Floyd_Warshall</a>
	<a href="entries/Selection_Heap_Sort.html">Selection_Heap_Sort</a>
	<a href="entries/Dijkstra_Shortest_Path.html">Dijkstra_Shortest_Path</a>
	<a href="entries/EdmondsKarp_Maxflow.html">EdmondsKarp_Maxflow</a>
	<a href="entries/VerifyThis2018.html">VerifyThis2018</a>
	<a href="entries/CYK.html">CYK</a>
	<a href="entries/Boolean_Expression_Checkers.html">Boolean_Expression_Checkers</a>
	<a href="entries/Depth-First-Search.html">Depth-First-Search</a>
	<a href="entries/FFT.html">FFT</a>
	<a href="entries/Gauss-Jordan-Elim-Fun.html">Gauss-Jordan-Elim-Fun</a>
	<a href="entries/UpDown_Scheme.html">UpDown_Scheme</a>
	<a href="entries/GraphMarkingIBP.html">GraphMarkingIBP</a>
	<a href="entries/Efficient-Mergesort.html">Efficient-Mergesort</a>
	<a href="entries/SATSolverVerification.html">SATSolverVerification</a>
	<a href="entries/Transitive-Closure.html">Transitive-Closure</a>
	<a href="entries/Transitive-Closure-II.html">Transitive-Closure-II</a>
	<a href="entries/MuchAdoAboutTwo.html">MuchAdoAboutTwo</a>
	<a href="entries/First_Order_Terms.html">First_Order_Terms</a>
	<a href="entries/Polynomials.html">Polynomials</a>
	<a href="entries/Gabow_SCC.html">Gabow_SCC</a>
	<a href="entries/Monad_Memo_DP.html">Monad_Memo_DP</a>
	<a href="entries/Hidden_Markov_Models.html">Hidden_Markov_Models</a>
	<a href="entries/Gauss_Jordan.html">Gauss_Jordan</a>
	<a href="entries/Echelon_Form.html">Echelon_Form</a>
	<a href="entries/QR_Decomposition.html">QR_Decomposition</a>
	<a href="entries/Hermite.html">Hermite</a>
	<a href="entries/Imperative_Insertion_Sort.html">Imperative_Insertion_Sort</a>
	<a href="entries/Deep_Learning.html">Deep_Learning</a>
	<a href="entries/Formal_SSA.html">Formal_SSA</a>
	<a href="entries/ROBDD.html">ROBDD</a>
	<a href="entries/Groebner_Bases.html">Groebner_Bases</a>
	<a href="entries/Median_Of_Medians_Selection.html">Median_Of_Medians_Selection</a>
	<a href="entries/IMAP-CRDT.html">IMAP-CRDT</a>
	<a href="entries/Fisher_Yates.html">Fisher_Yates</a>
	<a href="entries/Diophantine_Eqns_Lin_Hom.html">Diophantine_Eqns_Lin_Hom</a>
	<a href="entries/Taylor_Models.html">Taylor_Models</a>
	<a href="entries/LLL_Basis_Reduction.html">LLL_Basis_Reduction</a>
	<a href="entries/Optimal_BST.html">Optimal_BST</a>
	<a href="entries/Simplex.html">Simplex</a>
	<a href="entries/Signature_Groebner.html">Signature_Groebner</a>
	<a href="entries/IMP2.html">IMP2</a>
	<a href="entries/Auto2_Imperative_HOL.html">Auto2_Imperative_HOL</a>
	<a href="entries/Kruskal.html">Kruskal</a>
	<a href="entries/List_Inversions.html">List_Inversions</a>
	+ <a href="entries/IMP2_Binary_Heap.html">IMP2_Binary_Heap</a>
	<strong>Distributed:</strong>
	<a href="entries/DiskPaxos.html">DiskPaxos</a>
	<a href="entries/GenClock.html">GenClock</a>
	<a href="entries/ClockSynchInst.html">ClockSynchInst</a>
	<a href="entries/Heard_Of.html">Heard_Of</a>
	<a href="entries/Consensus_Refined.html">Consensus_Refined</a>
	<a href="entries/Abortable_Linearizable_Modules.html">Abortable_Linearizable_Modules</a>
	<a href="entries/CRDT.html">CRDT</a>
	<a href="entries/OpSets.html">OpSets</a>
	<strong>Concurrent:</strong>
	<a href="entries/ConcurrentGC.html">ConcurrentGC</a>
	<strong>Online:</strong>
	<a href="entries/List_Update.html">List_Update</a>
	</div>
	<h3>Concurrency</h3>
	<div class="list">
	<a href="entries/FLP.html">FLP</a>
	<a href="entries/Concurrent_Ref_Alg.html">Concurrent_Ref_Alg</a>
	<a href="entries/Concurrent_Revisions.html">Concurrent_Revisions</a>
	<a href="entries/Store_Buffer_Reduction.html">Store_Buffer_Reduction</a>
	<strong>Process Calculi:</strong>
	<a href="entries/Noninterference_Generic_Unwinding.html">Noninterference_Generic_Unwinding</a>
	<a href="entries/AODV.html">AODV</a>
	<a href="entries/AWN.html">AWN</a>
	<a href="entries/CCS.html">CCS</a>
	<a href="entries/Pi_Calculus.html">Pi_Calculus</a>
	<a href="entries/Psi_Calculi.html">Psi_Calculi</a>
	<a href="entries/Encodability_Process_Calculi.html">Encodability_Process_Calculi</a>
	<a href="entries/Circus.html">Circus</a>
	<a href="entries/Noninterference_Sequential_Composition.html">Noninterference_Sequential_Composition</a>
	<a href="entries/Noninterference_Concurrent_Composition.html">Noninterference_Concurrent_Composition</a>
	<a href="entries/Modal_Logics_for_NTS.html">Modal_Logics_for_NTS</a>
	<a href="entries/HOL-CSP.html">HOL-CSP</a>
	</div>
	<h3>Data Structures</h3>
	<div class="list">
	<a href="entries/Generic_Deriving.html">Generic_Deriving</a>
	<a href="entries/Random_BSTs.html">Random_BSTs</a>
	<a href="entries/Randomised_BSTs.html">Randomised_BSTs</a>
	<a href="entries/List_Interleaving.html">List_Interleaving</a>
	<a href="entries/Refine_Imperative_HOL.html">Refine_Imperative_HOL</a>
	<a href="entries/Amortized_Complexity.html">Amortized_Complexity</a>
	<a href="entries/Dynamic_Tables.html">Dynamic_Tables</a>
	<a href="entries/AVL-Trees.html">AVL-Trees</a>
	<a href="entries/BDD.html">BDD</a>
	<a href="entries/BinarySearchTree.html">BinarySearchTree</a>
	<a href="entries/Splay_Tree.html">Splay_Tree</a>
	<a href="entries/Root_Balanced_Tree.html">Root_Balanced_Tree</a>
	<a href="entries/Skew_Heap.html">Skew_Heap</a>
	<a href="entries/Pairing_Heap.html">Pairing_Heap</a>
	<a href="entries/Priority_Queue_Braun.html">Priority_Queue_Braun</a>
	<a href="entries/Binomial-Queues.html">Binomial-Queues</a>
	<a href="entries/Binomial-Heaps.html">Binomial-Heaps</a>
	<a href="entries/Finger-Trees.html">Finger-Trees</a>
	<a href="entries/Trie.html">Trie</a>
	<a href="entries/FinFun.html">FinFun</a>
	<a href="entries/Collections.html">Collections</a>
	<a href="entries/Containers.html">Containers</a>
	<a href="entries/FileRefinement.html">FileRefinement</a>
	<a href="entries/Datatype_Order_Generator.html">Datatype_Order_Generator</a>
	<a href="entries/Deriving.html">Deriving</a>
	<a href="entries/List-Index.html">List-Index</a>
	<a href="entries/List-Infinite.html">List-Infinite</a>
	<a href="entries/Matrix.html">Matrix</a>
	<a href="entries/Matrix_Tensor.html">Matrix_Tensor</a>
	<a href="entries/Huffman.html">Huffman</a>
	<a href="entries/Lazy-Lists-II.html">Lazy-Lists-II</a>
	<a href="entries/IEEE_Floating_Point.html">IEEE_Floating_Point</a>
	<a href="entries/Native_Word.html">Native_Word</a>
	<a href="entries/XML.html">XML</a>
	<a href="entries/ROBDD.html">ROBDD</a>
	<a href="entries/IMAP-CRDT.html">IMAP-CRDT</a>
	<a href="entries/Word_Lib.html">Word_Lib</a>
	<a href="entries/CRDT.html">CRDT</a>
	<a href="entries/KD_Tree.html">KD_Tree</a>
	<a href="entries/Taylor_Models.html">Taylor_Models</a>
	<a href="entries/Treaps.html">Treaps</a>
	<a href="entries/Weight_Balanced_Trees.html">Weight_Balanced_Trees</a>
	<a href="entries/OpSets.html">OpSets</a>
	<a href="entries/Optimal_BST.html">Optimal_BST</a>
	<a href="entries/Core_DOM.html">Core_DOM</a>
	<a href="entries/Auto2_Imperative_HOL.html">Auto2_Imperative_HOL</a>
	+ <a href="entries/IMP2_Binary_Heap.html">IMP2_Binary_Heap</a>
	</div>
	<h3>Functional Programming</h3>
	<div class="list">
	<a href="entries/Optics.html">Optics</a>
	<a href="entries/CryptHOL.html">CryptHOL</a>
	<a href="entries/Probabilistic_While.html">Probabilistic_While</a>
	<a href="entries/Monad_Normalisation.html">Monad_Normalisation</a>
	<a href="entries/Monomorphic_Monad.html">Monomorphic_Monad</a>
	<a href="entries/Show.html">Show</a>
	<a href="entries/Certification_Monads.html">Certification_Monads</a>
	<a href="entries/Partial_Function_MR.html">Partial_Function_MR</a>
	<a href="entries/Lifting_Definition_Option.html">Lifting_Definition_Option</a>
	<a href="entries/Coinductive.html">Coinductive</a>
	<a href="entries/Stream-Fusion.html">Stream-Fusion</a>
	<a href="entries/Tycon.html">Tycon</a>
	<a href="entries/Monad_Memo_DP.html">Monad_Memo_DP</a>
	<a href="entries/XML.html">XML</a>
	<a href="entries/Tail_Recursive_Functions.html">Tail_Recursive_Functions</a>
	<a href="entries/Stream_Fusion_Code.html">Stream_Fusion_Code</a>
	<a href="entries/Applicative_Lifting.html">Applicative_Lifting</a>
	<a href="entries/HOLCF-Prelude.html">HOLCF-Prelude</a>
	<a href="entries/BNF_CC.html">BNF_CC</a>
	<a href="entries/Binding_Syntax_Theory.html">Binding_Syntax_Theory</a>
	</div>
	<h3>Games</h3>
	<div class="list">
	<a href="entries/Parity_Game.html">Parity_Game</a>
	</div>
	<h3>Hardware</h3>
	<div class="list">
	<a href="entries/SPARCv8.html">SPARCv8</a>
	</div>
	<h3>Networks</h3>
	<div class="list">
	<a href="entries/UPF_Firewall.html">UPF_Firewall</a>
	<a href="entries/IP_Addresses.html">IP_Addresses</a>
	<a href="entries/Simple_Firewall.html">Simple_Firewall</a>
	<a href="entries/Iptables_Semantics.html">Iptables_Semantics</a>
	<a href="entries/Routing.html">Routing</a>
	<a href="entries/LOFT.html">LOFT</a>
	</div>
	<h3>Programming Languages</h3>
	<div class="list">
	<a href="entries/Decl_Sem_Fun_PL.html">Decl_Sem_Fun_PL</a>
	<strong>Language Definitions:</strong>
	<a href="entries/CakeML.html">CakeML</a>
	<a href="entries/WebAssembly.html">WebAssembly</a>
	<a href="entries/pGCL.html">pGCL</a>
	<a href="entries/GPU_Kernel_PL.html">GPU_Kernel_PL</a>
	<a href="entries/LightweightJava.html">LightweightJava</a>
	<a href="entries/CoreC++.html">CoreC++</a>
	<a href="entries/FeatherweightJava.html">FeatherweightJava</a>
	<a href="entries/Jinja.html">Jinja</a>
	<a href="entries/JinjaThreads.html">JinjaThreads</a>
	<a href="entries/Locally-Nameless-Sigma.html">Locally-Nameless-Sigma</a>
	<a href="entries/AutoFocus-Stream.html">AutoFocus-Stream</a>
	<a href="entries/FocusStreamsCaseStudies.html">FocusStreamsCaseStudies</a>
	<a href="entries/Isabelle_Meta_Model.html">Isabelle_Meta_Model</a>
	<a href="entries/Simpl.html">Simpl</a>
	<a href="entries/Complx.html">Complx</a>
	<a href="entries/Safe_OCL.html">Safe_OCL</a>
	<strong>Lambda Calculi:</strong>
	<a href="entries/Higher_Order_Terms.html">Higher_Order_Terms</a>
	<a href="entries/Launchbury.html">Launchbury</a>
	<a href="entries/PCF.html">PCF</a>
	<a href="entries/POPLmark-deBruijn.html">POPLmark-deBruijn</a>
	<a href="entries/Lam-ml-Normalization.html">Lam-ml-Normalization</a>
	<a href="entries/LambdaMu.html">LambdaMu</a>
	<a href="entries/Binding_Syntax_Theory.html">Binding_Syntax_Theory</a>
	<a href="entries/LambdaAuth.html">LambdaAuth</a>
	<strong>Type Systems:</strong>
	<a href="entries/Name_Carrying_Type_Inference.html">Name_Carrying_Type_Inference</a>
	<a href="entries/MiniML.html">MiniML</a>
	<a href="entries/Possibilistic_Noninterference.html">Possibilistic_Noninterference</a>
	<a href="entries/SIFUM_Type_Systems.html">SIFUM_Type_Systems</a>
	<a href="entries/Dependent_SIFUM_Type_Systems.html">Dependent_SIFUM_Type_Systems</a>
	<a href="entries/Strong_Security.html">Strong_Security</a>
	<a href="entries/WHATandWHERE_Security.html">WHATandWHERE_Security</a>
	<a href="entries/VolpanoSmith.html">VolpanoSmith</a>
	<strong>Logics:</strong>
	<a href="entries/ConcurrentIMP.html">ConcurrentIMP</a>
	<a href="entries/Refine_Monadic.html">Refine_Monadic</a>
	<a href="entries/Automatic_Refinement.html">Automatic_Refinement</a>
	<a href="entries/MonoBoolTranAlgebra.html">MonoBoolTranAlgebra</a>
	<a href="entries/Simpl.html">Simpl</a>
	<a href="entries/Separation_Algebra.html">Separation_Algebra</a>
	<a href="entries/Separation_Logic_Imperative_HOL.html">Separation_Logic_Imperative_HOL</a>
	<a href="entries/Abstract-Hoare-Logics.html">Abstract-Hoare-Logics</a>
	<a href="entries/Kleene_Algebra.html">Kleene_Algebra</a>
	<a href="entries/KAT_and_DRA.html">KAT_and_DRA</a>
	<a href="entries/KAD.html">KAD</a>
	<a href="entries/BytecodeLogicJmlTypes.html">BytecodeLogicJmlTypes</a>
	<a href="entries/DataRefinementIBP.html">DataRefinementIBP</a>
	<a href="entries/RefinementReactive.html">RefinementReactive</a>
	<a href="entries/SIFPL.html">SIFPL</a>
	<a href="entries/TLA.html">TLA</a>
	<a href="entries/Ribbon_Proofs.html">Ribbon_Proofs</a>
	<a href="entries/Separata.html">Separata</a>
	<a href="entries/Complx.html">Complx</a>
	<a href="entries/Differential_Dynamic_Logic.html">Differential_Dynamic_Logic</a>
	<a href="entries/Hoare_Time.html">Hoare_Time</a>
	<a href="entries/IMP2.html">IMP2</a>
	<a href="entries/UTP.html">UTP</a>
	<a href="entries/QHLProver.html">QHLProver</a>
	<strong>Compiling:</strong>
	<a href="entries/Compiling-Exceptions-Correctly.html">Compiling-Exceptions-Correctly</a>
	<a href="entries/NormByEval.html">NormByEval</a>
	<a href="entries/Density_Compiler.html">Density_Compiler</a>
	<strong>Static Analysis:</strong>
	<a href="entries/RIPEMD-160-SPARK.html">RIPEMD-160-SPARK</a>
	<a href="entries/Program-Conflict-Analysis.html">Program-Conflict-Analysis</a>
	<a href="entries/Shivers-CFA.html">Shivers-CFA</a>
	<a href="entries/Slicing.html">Slicing</a>
	<a href="entries/HRB-Slicing.html">HRB-Slicing</a>
	<a href="entries/InfPathElimination.html">InfPathElimination</a>
	<a href="entries/Abs_Int_ITP2012.html">Abs_Int_ITP2012</a>
	<strong>Transformations:</strong>
	<a href="entries/Call_Arity.html">Call_Arity</a>
	<a href="entries/Refine_Imperative_HOL.html">Refine_Imperative_HOL</a>
	<a href="entries/WorkerWrapper.html">WorkerWrapper</a>
	<a href="entries/Monad_Memo_DP.html">Monad_Memo_DP</a>
	<a href="entries/Formal_SSA.html">Formal_SSA</a>
	<a href="entries/Minimal_SSA.html">Minimal_SSA</a>
	<strong>Misc:</strong>
	<a href="entries/JiveDataStoreModel.html">JiveDataStoreModel</a>
	<a href="entries/Pop_Refinement.html">Pop_Refinement</a>
	<a href="entries/Case_Labeling.html">Case_Labeling</a>
	</div>
	<h3>Security</h3>
	<div class="list">
	<a href="entries/Multi_Party_Computation.html">Multi_Party_Computation</a>
	<a href="entries/Noninterference_Generic_Unwinding.html">Noninterference_Generic_Unwinding</a>
	<a href="entries/Noninterference_Ipurge_Unwinding.html">Noninterference_Ipurge_Unwinding</a>
	<a href="entries/UPF.html">UPF</a>
	<a href="entries/UPF_Firewall.html">UPF_Firewall</a>
	<a href="entries/CISC-Kernel.html">CISC-Kernel</a>
	<a href="entries/Noninterference_CSP.html">Noninterference_CSP</a>
	<a href="entries/Key_Agreement_Strong_Adversaries.html">Key_Agreement_Strong_Adversaries</a>
	<a href="entries/Security_Protocol_Refinement.html">Security_Protocol_Refinement</a>
	<a href="entries/Inductive_Confidentiality.html">Inductive_Confidentiality</a>
	<a href="entries/Possibilistic_Noninterference.html">Possibilistic_Noninterference</a>
	<a href="entries/SIFUM_Type_Systems.html">SIFUM_Type_Systems</a>
	<a href="entries/Dependent_SIFUM_Type_Systems.html">Dependent_SIFUM_Type_Systems</a>
	<a href="entries/Dependent_SIFUM_Refinement.html">Dependent_SIFUM_Refinement</a>
	<a href="entries/Strong_Security.html">Strong_Security</a>
	<a href="entries/WHATandWHERE_Security.html">WHATandWHERE_Security</a>
	<a href="entries/VolpanoSmith.html">VolpanoSmith</a>
	<a href="entries/SIFPL.html">SIFPL</a>
	<a href="entries/HotelKeyCards.html">HotelKeyCards</a>
	<a href="entries/InformationFlowSlicing.html">InformationFlowSlicing</a>
	<a href="entries/InformationFlowSlicing_Inter.html">InformationFlowSlicing_Inter</a>
	<a href="entries/CryptoBasedCompositionalProperties.html">CryptoBasedCompositionalProperties</a>
	<a href="entries/Probabilistic_Noninterference.html">Probabilistic_Noninterference</a>
	<a href="entries/HyperCTL.html">HyperCTL</a>
	<a href="entries/Bounded_Deducibility_Security.html">Bounded_Deducibility_Security</a>
	<a href="entries/Network_Security_Policy_Verification.html">Network_Security_Policy_Verification</a>
	<a href="entries/Noninterference_Inductive_Unwinding.html">Noninterference_Inductive_Unwinding</a>
	<a href="entries/Password_Authentication_Protocol.html">Password_Authentication_Protocol</a>
	<a href="entries/Noninterference_Sequential_Composition.html">Noninterference_Sequential_Composition</a>
	<a href="entries/Noninterference_Concurrent_Composition.html">Noninterference_Concurrent_Composition</a>
	<a href="entries/SPARCv8.html">SPARCv8</a>
	<a href="entries/Modular_Assembly_Kit_Security.html">Modular_Assembly_Kit_Security</a>
	<a href="entries/LambdaAuth.html">LambdaAuth</a>
	<strong>Cryptography:</strong>
	<a href="entries/Game_Based_Crypto.html">Game_Based_Crypto</a>
	<a href="entries/CryptHOL.html">CryptHOL</a>
	<a href="entries/Constructive_Cryptography.html">Constructive_Cryptography</a>
	<a href="entries/RSAPSS.html">RSAPSS</a>
	<a href="entries/Elliptic_Curves_Group_Law.html">Elliptic_Curves_Group_Law</a>
	</div>
	<h3>Semantics</h3>
	<div class="list">
	<a href="entries/Launchbury.html">Launchbury</a>
	<a href="entries/Transformer_Semantics.html">Transformer_Semantics</a>
	<a href="entries/HOL-CSP.html">HOL-CSP</a>
	<a href="entries/QHLProver.html">QHLProver</a>
	</div>
	<h3>System Description Languages</h3>
	<div class="list">
	<a href="entries/Circus.html">Circus</a>
	<a href="entries/ComponentDependencies.html">ComponentDependencies</a>
	<a href="entries/Promela.html">Promela</a>
	<a href="entries/Featherweight_OCL.html">Featherweight_OCL</a>
	<a href="entries/DynamicArchitectures.html">DynamicArchitectures</a>
	<a href="entries/Architectural_Design_Patterns.html">Architectural_Design_Patterns</a>
	</div>
	<h2>Logic</h2>
	<div class="list">
	<a href="entries/Propositional_Proof_Systems.html">Propositional_Proof_Systems</a>
	<a href="entries/MSO_Regex_Equivalence.html">MSO_Regex_Equivalence</a>
	<a href="entries/Formula_Derivatives.html">Formula_Derivatives</a>
	<a href="entries/Universal_Turing_Machine.html">Universal_Turing_Machine</a>
	<a href="entries/Boolean_Expression_Checkers.html">Boolean_Expression_Checkers</a>
	<a href="entries/Presburger-Automata.html">Presburger-Automata</a>
	<a href="entries/Verified-Prover.html">Verified-Prover</a>
	<a href="entries/Completeness.html">Completeness</a>
	<a href="entries/Ordinal.html">Ordinal</a>
	<a href="entries/Ordinals_and_Cardinals.html">Ordinals_and_Cardinals</a>
	<a href="entries/FOL-Fitting.html">FOL-Fitting</a>
	<a href="entries/Epistemic_Logic.html">Epistemic_Logic</a>
	<a href="entries/SequentInvertibility.html">SequentInvertibility</a>
	<a href="entries/LinearQuantifierElim.html">LinearQuantifierElim</a>
	<a href="entries/Nat-Interval-Logic.html">Nat-Interval-Logic</a>
	<a href="entries/Recursion-Theory-I.html">Recursion-Theory-I</a>
	<a href="entries/Free-Boolean-Algebra.html">Free-Boolean-Algebra</a>
	<a href="entries/Sort_Encodings.html">Sort_Encodings</a>
	<a href="entries/LTL.html">LTL</a>
	<a href="entries/HereditarilyFinite.html">HereditarilyFinite</a>
	<a href="entries/Incompleteness.html">Incompleteness</a>
	<a href="entries/HyperCTL.html">HyperCTL</a>
	<a href="entries/Abstract_Completeness.html">Abstract_Completeness</a>
	<a href="entries/PropResPI.html">PropResPI</a>
	<a href="entries/SuperCalc.html">SuperCalc</a>
	<a href="entries/Incredible_Proof_Machine.html">Incredible_Proof_Machine</a>
	<a href="entries/Resolution_FOL.html">Resolution_FOL</a>
	<a href="entries/Surprise_Paradox.html">Surprise_Paradox</a>
	<a href="entries/Allen_Calculus.html">Allen_Calculus</a>
	<a href="entries/Modal_Logics_for_NTS.html">Modal_Logics_for_NTS</a>
	<a href="entries/Paraconsistency.html">Paraconsistency</a>
	<a href="entries/FOL_Harrison.html">FOL_Harrison</a>
	<a href="entries/Abstract_Soundness.html">Abstract_Soundness</a>
	<a href="entries/Differential_Dynamic_Logic.html">Differential_Dynamic_Logic</a>
	<a href="entries/LambdaMu.html">LambdaMu</a>
	<a href="entries/Hybrid_Multi_Lane_Spatial_Logic.html">Hybrid_Multi_Lane_Spatial_Logic</a>
	<a href="entries/Ordered_Resolution_Prover.html">Ordered_Resolution_Prover</a>
	<a href="entries/Minsky_Machines.html">Minsky_Machines</a>
	<a href="entries/Functional_Ordered_Resolution_Prover.html">Functional_Ordered_Resolution_Prover</a>
	<a href="entries/Binding_Syntax_Theory.html">Binding_Syntax_Theory</a>
	</div>
	<h3>Philosophy</h3>
	<div class="list">
	<a href="entries/GoedelGod.html">GoedelGod</a>
	<a href="entries/Types_Tableaus_and_Goedels_God.html">Types_Tableaus_and_Goedels_God</a>
	<a href="entries/GewirthPGCProof.html">GewirthPGCProof</a>
	<a href="entries/Lowe_Ontological_Argument.html">Lowe_Ontological_Argument</a>
	<a href="entries/AnselmGod.html">AnselmGod</a>
	<a href="entries/PLM.html">PLM</a>
	</div>
	<h3>Rewriting</h3>
	<div class="list">
	<a href="entries/Monad_Normalisation.html">Monad_Normalisation</a>
	<a href="entries/Lambda_Free_RPOs.html">Lambda_Free_RPOs</a>
	<a href="entries/Lambda_Free_KBOs.html">Lambda_Free_KBOs</a>
	<a href="entries/Lambda_Free_EPO.html">Lambda_Free_EPO</a>
	<a href="entries/Nested_Multisets_Ordinals.html">Nested_Multisets_Ordinals</a>
	<a href="entries/Abstract-Rewriting.html">Abstract-Rewriting</a>
	<a href="entries/First_Order_Terms.html">First_Order_Terms</a>
	<a href="entries/Decreasing-Diagrams.html">Decreasing-Diagrams</a>
	<a href="entries/Decreasing-Diagrams-II.html">Decreasing-Diagrams-II</a>
	<a href="entries/Rewriting_Z.html">Rewriting_Z</a>
	<a href="entries/Graph_Saturation.html">Graph_Saturation</a>
	</div>
	<h2>Mathematics</h2>
	<div class="list">
	</div>
	<h3>Algebra</h3>
	<div class="list">
	<a href="entries/Optics.html">Optics</a>
	<a href="entries/Subresultants.html">Subresultants</a>
	<a href="entries/Buildings.html">Buildings</a>
	<a href="entries/Algebraic_VCs.html">Algebraic_VCs</a>
	<a href="entries/Multirelations.html">Multirelations</a>
	<a href="entries/Residuated_Lattices.html">Residuated_Lattices</a>
	<a href="entries/PseudoHoops.html">PseudoHoops</a>
	<a href="entries/LatticeProperties.html">LatticeProperties</a>
	<a href="entries/Impossible_Geometry.html">Impossible_Geometry</a>
	<a href="entries/Gauss-Jordan-Elim-Fun.html">Gauss-Jordan-Elim-Fun</a>
	<a href="entries/Matrix_Tensor.html">Matrix_Tensor</a>
	<a href="entries/Stone_Algebras.html">Stone_Algebras</a>
	<a href="entries/Kleene_Algebra.html">Kleene_Algebra</a>
	<a href="entries/KAT_and_DRA.html">KAT_and_DRA</a>
	<a href="entries/KAD.html">KAD</a>
	<a href="entries/Regular_Algebras.html">Regular_Algebras</a>
	<a href="entries/Free-Groups.html">Free-Groups</a>
	<a href="entries/CofGroups.html">CofGroups</a>
	<a href="entries/Group-Ring-Module.html">Group-Ring-Module</a>
	<a href="entries/Robbins-Conjecture.html">Robbins-Conjecture</a>
	<a href="entries/Valuation.html">Valuation</a>
	<a href="entries/Rank_Nullity_Theorem.html">Rank_Nullity_Theorem</a>
	<a href="entries/Polynomials.html">Polynomials</a>
	<a href="entries/Relation_Algebra.html">Relation_Algebra</a>
	<a href="entries/PSemigroupsConvolution.html">PSemigroupsConvolution</a>
	<a href="entries/Secondary_Sylow.html">Secondary_Sylow</a>
	<a href="entries/Jordan_Hoelder.html">Jordan_Hoelder</a>
	<a href="entries/Cayley_Hamilton.html">Cayley_Hamilton</a>
	<a href="entries/VectorSpace.html">VectorSpace</a>
	<a href="entries/Echelon_Form.html">Echelon_Form</a>
	<a href="entries/QR_Decomposition.html">QR_Decomposition</a>
	<a href="entries/Hermite.html">Hermite</a>
	<a href="entries/Rep_Fin_Groups.html">Rep_Fin_Groups</a>
	<a href="entries/Jordan_Normal_Form.html">Jordan_Normal_Form</a>
	<a href="entries/Algebraic_Numbers.html">Algebraic_Numbers</a>
	<a href="entries/Polynomial_Interpolation.html">Polynomial_Interpolation</a>
	<a href="entries/Polynomial_Factorization.html">Polynomial_Factorization</a>
	<a href="entries/Perron_Frobenius.html">Perron_Frobenius</a>
	<a href="entries/Stochastic_Matrices.html">Stochastic_Matrices</a>
	<a href="entries/Groebner_Bases.html">Groebner_Bases</a>
	+ <a href="entries/Nullstellensatz.html">Nullstellensatz</a>
	<a href="entries/Mason_Stothers.html">Mason_Stothers</a>
	<a href="entries/Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a>
	<a href="entries/Allen_Calculus.html">Allen_Calculus</a>
	<a href="entries/Stone_Relation_Algebras.html">Stone_Relation_Algebras</a>
	<a href="entries/Stone_Kleene_Relation_Algebras.html">Stone_Kleene_Relation_Algebras</a>
	<a href="entries/Orbit_Stabiliser.html">Orbit_Stabiliser</a>
	<a href="entries/Dirichlet_L.html">Dirichlet_L</a>
	<a href="entries/Symmetric_Polynomials.html">Symmetric_Polynomials</a>
	<a href="entries/Taylor_Models.html">Taylor_Models</a>
	<a href="entries/LLL_Basis_Reduction.html">LLL_Basis_Reduction</a>
	<a href="entries/LLL_Factorization.html">LLL_Factorization</a>
	<a href="entries/Localization_Ring.html">Localization_Ring</a>
	<a href="entries/Quaternions.html">Quaternions</a>
	<a href="entries/Octonions.html">Octonions</a>
	<a href="entries/Aggregation_Algebras.html">Aggregation_Algebras</a>
	<a href="entries/Signature_Groebner.html">Signature_Groebner</a>
	<a href="entries/Order_Lattice_Props.html">Order_Lattice_Props</a>
	<a href="entries/Quantales.html">Quantales</a>
	<a href="entries/Transformer_Semantics.html">Transformer_Semantics</a>
	<a href="entries/Farkas.html">Farkas</a>
	+ <a href="entries/Groebner_Macaulay.html">Groebner_Macaulay</a>
	+ <a href="entries/Linear_Inequalities.html">Linear_Inequalities</a>
	</div>
	<h3>Analysis</h3>
	<div class="list">
	<a href="entries/E_Transcendental.html">E_Transcendental</a>
	<a href="entries/Liouville_Numbers.html">Liouville_Numbers</a>
	<a href="entries/Descartes_Sign_Rule.html">Descartes_Sign_Rule</a>
	<a href="entries/Euler_MacLaurin.html">Euler_MacLaurin</a>
	<a href="entries/Real_Impl.html">Real_Impl</a>
	<a href="entries/Lower_Semicontinuous.html">Lower_Semicontinuous</a>
	<a href="entries/Affine_Arithmetic.html">Affine_Arithmetic</a>
	<a href="entries/Cauchy.html">Cauchy</a>
	<a href="entries/Integration.html">Integration</a>
	<a href="entries/Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a>
	<a href="entries/Polynomials.html">Polynomials</a>
	<a href="entries/Sqrt_Babylonian.html">Sqrt_Babylonian</a>
	<a href="entries/Sturm_Sequences.html">Sturm_Sequences</a>
	<a href="entries/Sturm_Tarski.html">Sturm_Tarski</a>
	<a href="entries/Special_Function_Bounds.html">Special_Function_Bounds</a>
	<a href="entries/Landau_Symbols.html">Landau_Symbols</a>
	<a href="entries/Error_Function.html">Error_Function</a>
	<a href="entries/Akra_Bazzi.html">Akra_Bazzi</a>
	<a href="entries/Zeta_Function.html">Zeta_Function</a>
	<a href="entries/Linear_Recurrences.html">Linear_Recurrences</a>
	<a href="entries/Cartan_FP.html">Cartan_FP</a>
	<a href="entries/Stirling_Formula.html">Stirling_Formula</a>
	<a href="entries/Lp.html">Lp</a>
	<a href="entries/Bernoulli.html">Bernoulli</a>
	<a href="entries/Winding_Number_Eval.html">Winding_Number_Eval</a>
	<a href="entries/Count_Complex_Roots.html">Count_Complex_Roots</a>
	<a href="entries/Taylor_Models.html">Taylor_Models</a>
	<a href="entries/Green.html">Green</a>
	<a href="entries/Irrationality_J_Hancl.html">Irrationality_J_Hancl</a>
	<a href="entries/Budan_Fourier.html">Budan_Fourier</a>
	<a href="entries/Smooth_Manifolds.html">Smooth_Manifolds</a>
	<a href="entries/Transcendence_Series_Hancl_Rucki.html">Transcendence_Series_Hancl_Rucki</a>
	</div>
	<h3>Probability Theory</h3>
	<div class="list">
	<a href="entries/DiscretePricing.html">DiscretePricing</a>
	<a href="entries/CryptHOL.html">CryptHOL</a>
	<a href="entries/Constructive_Cryptography.html">Constructive_Cryptography</a>
	<a href="entries/Probabilistic_While.html">Probabilistic_While</a>
	<a href="entries/Markov_Models.html">Markov_Models</a>
	<a href="entries/Density_Compiler.html">Density_Compiler</a>
	<a href="entries/Probabilistic_Timed_Automata.html">Probabilistic_Timed_Automata</a>
	<a href="entries/Hidden_Markov_Models.html">Hidden_Markov_Models</a>
	<a href="entries/Random_Graph_Subgraph_Threshold.html">Random_Graph_Subgraph_Threshold</a>
	<a href="entries/Ergodic_Theory.html">Ergodic_Theory</a>
	<a href="entries/Source_Coding_Theorem.html">Source_Coding_Theorem</a>
	<a href="entries/Buffons_Needle.html">Buffons_Needle</a>
	</div>
	<h3>Number Theory</h3>
	<div class="list">
	<a href="entries/Pell.html">Pell</a>
	<a href="entries/Minkowskis_Theorem.html">Minkowskis_Theorem</a>
	<a href="entries/E_Transcendental.html">E_Transcendental</a>
	<a href="entries/Pi_Transcendental.html">Pi_Transcendental</a>
	<a href="entries/Liouville_Numbers.html">Liouville_Numbers</a>
	<a href="entries/Prime_Harmonic_Series.html">Prime_Harmonic_Series</a>
	<a href="entries/Fermat3_4.html">Fermat3_4</a>
	<a href="entries/Perfect-Number-Thm.html">Perfect-Number-Thm</a>
	<a href="entries/SumSquares.html">SumSquares</a>
	<a href="entries/Lehmer.html">Lehmer</a>
	<a href="entries/Pratt_Certificate.html">Pratt_Certificate</a>
	<a href="entries/Dirichlet_Series.html">Dirichlet_Series</a>
	<a href="entries/Zeta_Function.html">Zeta_Function</a>
	<a href="entries/Stern_Brocot.html">Stern_Brocot</a>
	<a href="entries/Bertrands_Postulate.html">Bertrands_Postulate</a>
	<a href="entries/Bernoulli.html">Bernoulli</a>
	<a href="entries/Diophantine_Eqns_Lin_Hom.html">Diophantine_Eqns_Lin_Hom</a>
	<a href="entries/Dirichlet_L.html">Dirichlet_L</a>
	<a href="entries/Irrationality_J_Hancl.html">Irrationality_J_Hancl</a>
	<a href="entries/Prime_Number_Theorem.html">Prime_Number_Theorem</a>
	<a href="entries/Probabilistic_Prime_Tests.html">Probabilistic_Prime_Tests</a>
	<a href="entries/Prime_Distribution_Elementary.html">Prime_Distribution_Elementary</a>
	<a href="entries/Transcendence_Series_Hancl_Rucki.html">Transcendence_Series_Hancl_Rucki</a>
	</div>
	<h3>Economics</h3>
	<div class="list">
	<a href="entries/DiscretePricing.html">DiscretePricing</a>
	<a href="entries/ArrowImpossibilityGS.html">ArrowImpossibilityGS</a>
	<a href="entries/SenSocialChoice.html">SenSocialChoice</a>
	<a href="entries/Vickrey_Clarke_Groves.html">Vickrey_Clarke_Groves</a>
	<a href="entries/First_Welfare_Theorem.html">First_Welfare_Theorem</a>
	<a href="entries/Randomised_Social_Choice.html">Randomised_Social_Choice</a>
	<a href="entries/SDS_Impossibility.html">SDS_Impossibility</a>
	<a href="entries/Stable_Matching.html">Stable_Matching</a>
	<a href="entries/Fishburn_Impossibility.html">Fishburn_Impossibility</a>
	<a href="entries/Neumann_Morgenstern_Utility.html">Neumann_Morgenstern_Utility</a>
	</div>
	<h3>Geometry</h3>
	<div class="list">
	<a href="entries/Minkowskis_Theorem.html">Minkowskis_Theorem</a>
	<a href="entries/Buildings.html">Buildings</a>
	<a href="entries/Chord_Segments.html">Chord_Segments</a>
	<a href="entries/Triangle.html">Triangle</a>
	<a href="entries/Impossible_Geometry.html">Impossible_Geometry</a>
	<a href="entries/Tarskis_Geometry.html">Tarskis_Geometry</a>
	<a href="entries/General-Triangle.html">General-Triangle</a>
	+ <a href="entries/Nullstellensatz.html">Nullstellensatz</a>
	<a href="entries/Ptolemys_Theorem.html">Ptolemys_Theorem</a>
	<a href="entries/Buffons_Needle.html">Buffons_Needle</a>
	<a href="entries/Stewart_Apollonius.html">Stewart_Apollonius</a>
	<a href="entries/Gromov_Hyperbolicity.html">Gromov_Hyperbolicity</a>
	<a href="entries/Projective_Geometry.html">Projective_Geometry</a>
	<a href="entries/Quaternions.html">Quaternions</a>
	<a href="entries/Octonions.html">Octonions</a>
	</div>
	<h3>Topology</h3>
	<div class="list">
	<a href="entries/Topology.html">Topology</a>
	<a href="entries/Knot_Theory.html">Knot_Theory</a>
	<a href="entries/Kuratowski_Closure_Complement.html">Kuratowski_Closure_Complement</a>
	<a href="entries/Smooth_Manifolds.html">Smooth_Manifolds</a>
	</div>
	<h3>Graph Theory</h3>
	<div class="list">
	<a href="entries/Flow_Networks.html">Flow_Networks</a>
	<a href="entries/Prpu_Maxflow.html">Prpu_Maxflow</a>
	<a href="entries/MFMC_Countable.html">MFMC_Countable</a>
	<a href="entries/ShortestPath.html">ShortestPath</a>
	<a href="entries/Gabow_SCC.html">Gabow_SCC</a>
	<a href="entries/Graph_Theory.html">Graph_Theory</a>
	<a href="entries/Planarity_Certificates.html">Planarity_Certificates</a>
	<a href="entries/Max-Card-Matching.html">Max-Card-Matching</a>
	<a href="entries/Girth_Chromatic.html">Girth_Chromatic</a>
	<a href="entries/Random_Graph_Subgraph_Threshold.html">Random_Graph_Subgraph_Threshold</a>
	<a href="entries/Flyspeck-Tame.html">Flyspeck-Tame</a>
	<a href="entries/Koenigsberg_Friendship.html">Koenigsberg_Friendship</a>
	<a href="entries/Tree_Decomposition.html">Tree_Decomposition</a>
	<a href="entries/Menger.html">Menger</a>
	<a href="entries/Factored_Transition_System_Bounding.html">Factored_Transition_System_Bounding</a>
	<a href="entries/Graph_Saturation.html">Graph_Saturation</a>
	</div>
	<h3>Combinatorics</h3>
	<div class="list">
	<a href="entries/Card_Equiv_Relations.html">Card_Equiv_Relations</a>
	<a href="entries/Twelvefold_Way.html">Twelvefold_Way</a>
	<a href="entries/Card_Multisets.html">Card_Multisets</a>
	<a href="entries/Card_Partitions.html">Card_Partitions</a>
	<a href="entries/Card_Number_Partitions.html">Card_Number_Partitions</a>
	<a href="entries/Well_Quasi_Orders.html">Well_Quasi_Orders</a>
	<a href="entries/Marriage.html">Marriage</a>
	<a href="entries/Bondy.html">Bondy</a>
	<a href="entries/Ramsey-Infinite.html">Ramsey-Infinite</a>
	<a href="entries/Derangements.html">Derangements</a>
	<a href="entries/Euler_Partition.html">Euler_Partition</a>
	<a href="entries/Discrete_Summation.html">Discrete_Summation</a>
	<a href="entries/Open_Induction.html">Open_Induction</a>
	<a href="entries/Latin_Square.html">Latin_Square</a>
	<a href="entries/Bell_Numbers_Spivey.html">Bell_Numbers_Spivey</a>
	<a href="entries/Catalan_Numbers.html">Catalan_Numbers</a>
	<a href="entries/Falling_Factorial_Sum.html">Falling_Factorial_Sum</a>
	<a href="entries/Matroids.html">Matroids</a>
	</div>
	<h3>Category Theory</h3>
	<div class="list">
	<a href="entries/Category3.html">Category3</a>
	<a href="entries/MonoidalCategory.html">MonoidalCategory</a>
	<a href="entries/Category.html">Category</a>
	<a href="entries/Category2.html">Category2</a>
	<a href="entries/AxiomaticCategoryTheory.html">AxiomaticCategoryTheory</a>
	</div>
	<h3>Physics</h3>
	<div class="list">
	<a href="entries/No_FTL_observers.html">No_FTL_observers</a>
	</div>
	<h3>Misc</h3>
	<div class="list">
	<a href="entries/FunWithFunctions.html">FunWithFunctions</a>
	<a href="entries/FunWithTilings.html">FunWithTilings</a>
	</div>
	<h2>Tools</h2>
	<div class="list">
	<a href="entries/Monad_Normalisation.html">Monad_Normalisation</a>
	<a href="entries/Constructor_Funs.html">Constructor_Funs</a>
	<a href="entries/Lazy_Case.html">Lazy_Case</a>
	<a href="entries/Dict_Construction.html">Dict_Construction</a>
	<a href="entries/Case_Labeling.html">Case_Labeling</a>
	<a href="entries/DPT-SAT-Solver.html">DPT-SAT-Solver</a>
	<a href="entries/Nominal2.html">Nominal2</a>
	<a href="entries/Separata.html">Separata</a>
	<a href="entries/Proof_Strategy_Language.html">Proof_Strategy_Language</a>
	<a href="entries/Diophantine_Eqns_Lin_Hom.html">Diophantine_Eqns_Lin_Hom</a>
	<a href="entries/BNF_Operations.html">BNF_Operations</a>
	<a href="entries/BNF_CC.html">BNF_CC</a>
	<a href="entries/Auto2_HOL.html">Auto2_HOL</a>
	</div>
	</td>
	</tr>
	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>


	</body>
	</html>
	\ No newline at end of file
	diff --git a/web/using.html b/web/using.html
	--- a/web/using.html
	+++ b/web/using.html
	@@ -1,118 +1,118 @@
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Archive of Formal Proofs</title>
	<link rel="stylesheet" type="text/css" href="front.css">
	<link rel="icon" href="images/favicon.ico" type="image/icon">
	<link rel="alternate" type="application/rss+xml" title="RSS" href="rss.xml">
	</head>

	<body>

	<table width="100%">
	<tbody>
	<tr>

	<!-- Navigation -->
	<td width="20%" align="center" valign="top">
	<p> </p>
	<a href="http://isabelle.in.tum.de">
	<img src="images/isabelle.png" width="100" height="86" border=0>
	</a>
	<p> </p>
	<p> </p>
	<table class="nav" width="80%">
	<tr>
	<td class="nav" width="100%"><a href="index.html">Home</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="about.html">About</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="submitting.html">Submission</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="updating.html">Updating Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="using.html">Using Entries</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="search.html">Search</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="statistics.html">Statistics</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="topics.html">Index</a></td>
	</tr>
	<tr>
	<td class="nav"><a href="download.html">Download</a></td>
	</tr>
	</table>
	<p> </p>
	<p> </p>
	</td>


	<!-- Content -->
	<td width="80%" valign="top">
	<div align="center">
	<p> </p>
	<h1><font class="first">R</font>eferring to
	<font class="first">A</font>FP
	<font class="first">E</font>ntries
	</h1>
	<p> </p>

	<table width="80%" class="descr">
	<tbody>
	<tr><td>

	<p>
	Once you have downloaded the AFP, you can include its articles and theories in
	your own developments. If you would like to make your work available to others
	<i>without</i> having to include the AFP articles you depend on, here is how to do it.
	</p>
	<p>
	-If you are using Isabelle2018, and have downloaded your AFP directory to
	+If you are using Isabelle2019, and have downloaded your AFP directory to
	<code>/home/myself/afp</code>, you should run the following command
	<a href="#1">[1]</a> to make the AFP session ROOTS available to Isabelle:</p>
	<p>
	<pre class="code">
	- echo "/home/myself/afp/thys" >> ~/.isabelle/Isabelle2018/ROOTS
	+ echo "/home/myself/afp/thys" >> ~/.isabelle/Isabelle2019/ROOTS
	</pre>

	<p>
	You can now refer to article <code>ABC</code> from the AFP in some theory of
	yours via</p>

	<pre class="code">
	imports "ABC.Some_ABC_Theory"
	</pre>

	<p>This allows you to distribute your material separately from any AFP
	theories. Users of your distribution also need to install the AFP in the above
	manner.</p>

	<p> </p>

	<p>
	<a name="1">[1]:</a> Tested for Linux and Mac installations &dash; it should be the same under cygwin on Windows.
	</p>
	<p>
	</td></tr>
	</tbody>
	</table>

	</div>
	</td>

	</tr>
	</tbody>
	</table>


	</body>
	</html>
	\ No newline at end of file

File Metadata

Mime Type: application/octet-stream
Expires: Mon, May 20, 10:53 PM (2 d)
Storage Engine: chunks
Storage Format: Chunks
Storage Handle: j2EYLtgGmJKh
Default Alt Text: (4 MB)

Offset	End	Complete
0	4194304	Yes
4194304	5225401	Yes

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions