Page MenuHomeIsabelle/Phabricator
Files F1592012

No OneTemporary
Actions

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/admin/common b/admin/common
--- a/admin/common
+++ b/admin/common
@@ -1,58 +1,58 @@
# -*- shell-script -*-
#
# Author: Gerwin Klein
#
# shell library functions common to the AFP scripts
# assumes all AFP bash scripts are in admin/
#
PRG="$(basename "$0")"
DIR="$(dirname "$0")"
AFP_ROOT="$(cd "${DIR}/.."; pwd)"
THYS="$AFP_ROOT/thys"
source "$AFP_ROOT/etc/version"
##
fail()
{
echo "### $1" >&2
exit 2
}
timestamp()
{
echo "[timestamp: $(date "+%Y-%m-%d %H:%M:%S")]"
}
check_isabelle()
{
[ -x "$ISABELLE_TOOL" ] || fail "No isabelle tool wrapper found at [$ISABELLE_TOOL]."
ISABELLE_HOME="$("$ISABELLE_TOOL" getenv -b ISABELLE_HOME)" || fail "could not find Isabelle home"
}
default_isabelle_tool()
{
if [ ! -x "$ISABELLE_TOOL" ]; then
if [[ "$VERSION" == devel ]]; then
ISABELLE_TOOL="$(which isabelle)"
else
[ "$ISABELLE_RELEASES" == "" ] && fail "ISABELLE_RELEASES not set"
ISABELLE_VERSION="Isabelle$VERSION"
ISABELLE_TOOL="$ISABELLE_RELEASES/$ISABELLE_VERSION/bin/isabelle"
if [[ "$OSTYPE" == darwin* && ! -x "$ISABELLE_TOOL" ]]; then
- ISABELLE_TOOL="$ISABELLE_RELEASES/${ISABELLE_VERSION}.app/Isabelle/bin/isabelle"
+ ISABELLE_TOOL="$ISABELLE_RELEASES/${ISABELLE_VERSION}.app/bin/isabelle"
fi
fi
fi
}
set_isabelle_tool()
{
default_isabelle_tool
check_isabelle
echo "using [$ISABELLE_TOOL]"
}
diff --git a/admin/publish b/admin/publish
--- a/admin/publish
+++ b/admin/publish
@@ -1,177 +1,177 @@
#!/usr/bin/env bash
#
# Author: Gerwin Klein, NICTA
#
# publishes archive entry + main web pages on isa-afp
#
# This script expects Isabelle version >= 2008-10-05
# (uses isabelle instead of isatool)
## settings
source "$(dirname "$0")/common"
AFP_VERSION=afp-$VERSION
ISABELLE_VERSION="Isabelle${VERSION}"
DEST=afpweb@isa-afp.org:
FILES=frs.sourceforge.net:/home/frs/project/afp/afp-$ISABELLE_VERSION/
SRC=ssh://hg@foss.heptapod.net/isa-afp/$AFP_VERSION
if [ -n "$SF_LOGIN" ]; then
LN=$SF_LOGIN
else
LN=$LOGNAME
fi
FILES=$LN@$FILES
EXPORT_PRE=afp
HG=hg
DATE=`date '+%Y-%m-%d'`
TAR=tar
## functions
function usage()
{
echo
echo "Usage: $PRG [options] [<entries>|-]"
echo
echo " Checks out web site and archive entries and publishes them on the isa-afp.org web site"
echo
echo "Options:"
echo " -r use specified Isabelle version"
echo " -f do not ask before publishing"
echo " -t <isabelle> <tag> use specified path to isabelle tool script"
echo
echo "Examples:"
echo " $PRG -r 2009 Example-Submission"
echo " $PRG -t /usr/proj/Isabelle2009/bin/isabelle Isabelle2009 Example-Submission"
echo
echo " $PRG Example-Submission"
exit 1
}
## argument checking
[ "$#" -lt "1" -o "$1" = "-?" ] && usage
INTERACTIVE="yes"
while getopts "ft:r:" OPT
do
case "$OPT" in
r)
VERSION="$OPTARG"
;;
f)
INTERACTIVE="no"
;;
t)
ISABELLE_TOOL="$OPTARG"
ISABELLE_VERSION="$1"
shift
;;
esac
done
shift $(($OPTIND - 1))
set_isabelle_tool
EXPORT=$EXPORT_PRE-$DATE
###
WD="$(pwd)"
cd "$DIR"
ROOT="$(hg root)" || fail "could not obtain repo root"
cd "$ROOT" || fail "could not cd to repo root"
echo "Checking sync with $SRC"
$HG outgoing $SRC && fail "Push changes to Heptapod first."
echo "Exporting from working copy $ROOT"
HG_EXPORT=afp-export-$DATE
rm -rf $HG_EXPORT
$HG archive -I thys -I web -I etc -I tools $HG_EXPORT || fail "hg archive failed."
cd $HG_EXPORT
echo -n $DATE > web/release-date.txt
mkdir $EXPORT
mv thys etc tools $EXPORT/
if [ "$1" != "-" ]; then
echo "Cleaning up browser_info directory"
BROWSER_INFO=`$ISABELLE_TOOL getenv -b ISABELLE_BROWSER_INFO` || fail "could not find browser info"
[ -e "$BROWSER_INFO" ] && rm -rf $BROWSER_INFO
HTML_THYS=web/browser_info/$ISABELLE_VERSION
TARS=web/release
mkdir -p $HTML_THYS
ln -s $ISABELLE_VERSION web/browser_info/current
ln -s ../front.css web/entries/front.css
mkdir -p $TARS
echo "Tarring [$EXPORT]"
$TAR -cf $EXPORT.tar $EXPORT
gzip --best -f $EXPORT.tar
ln -s $EXPORT.tar.gz $TARS/afp-current.tar.gz
mv $EXPORT.tar.gz $TARS/
echo "Generating HTML for [$@]"
- $ISABELLE_TOOL afp_build -- -v -c $@ || fail "isabelle afp_build failed on [$@]"
+ $ISABELLE_TOOL afp_build -- -v -c -j 2 $@ || fail "isabelle afp_build failed on [$@]"
cd $EXPORT/thys
for ENTRY in $@; do
if [ -d $ENTRY ]; then
echo "Tarring [$ENTRY]"
$TAR -cf $EXPORT_PRE-$ENTRY-$DATE.tar $ENTRY
gzip --best -f $EXPORT_PRE-$ENTRY-$DATE.tar
mv $EXPORT_PRE-$ENTRY-$DATE.tar.gz ../../$TARS/
ln -s $EXPORT_PRE-$ENTRY-$DATE.tar.gz ../../$TARS/$EXPORT_PRE-$ENTRY-current.tar.gz
echo "Finished [$ENTRY]"
fi
done
cd ../..
echo "Copying generated HTML"
for DIR in $BROWSER_INFO/*; do
if [ -d $DIR ]; then
cp -r $DIR $HTML_THYS
fi
done
if [ "$INTERACTIVE" == "yes" ]; then
echo "Web pages are prepared for publication under"
echo "[`pwd`/web/]."
echo "Please check content."
read -n 1 -p "Type y if you want to publish. Any other key quits." RESPONSE
else
RESPONSE="y"
fi
else
RESPONSE="y"
fi
if [ "$RESPONSE" == "y" ]; then
# if [ "$TARS" != "" ]; then
# echo
# echo "Pushing $EXPORT to [$FILES]"
# scp $TARS/$EXPORT.tar.gz $FILES
# fi
echo
echo "Publishing to [$DEST]"
chmod -R g-w web
chmod -R a+r web
find web -type d | xargs chmod a+x
chmod 755 web
rsync -rplvz --links --rsh=ssh web/ $DEST && echo "Finished."
else
echo
echo "Aborted."
exit 1;
fi
diff --git a/metadata/metadata b/metadata/metadata
--- a/metadata/metadata
+++ b/metadata/metadata
@@ -1,10268 +1,10311 @@
[Arith_Prog_Rel_Primes]
title = Arithmetic progressions and relative primes
author = José Manuel Rodríguez Caballero <https://josephcmac.github.io/>
topic = Mathematics/Number theory
date = 2020-02-01
notify = jose.manuel.rodriguez.caballero@ut.ee
abstract =
This article provides a formalization of the solution obtained by the
author of the Problem “ARITHMETIC PROGRESSIONS” from the
<a href="https://www.ocf.berkeley.edu/~wwu/riddles/putnam.shtml">
Putnam exam problems of 2002</a>. The statement of the problem is
as follows: For which integers <em>n</em> > 1 does the set of positive
integers less than and relatively prime to <em>n</em> constitute an
arithmetic progression?
[Banach_Steinhaus]
title = Banach-Steinhaus Theorem
author = Dominique Unruh <http://kodu.ut.ee/~unruh/> <mailto:unruh@ut.ee>, Jose Manuel Rodriguez Caballero <https://josephcmac.github.io/> <mailto:jose.manuel.rodriguez.caballero@ut.ee>
topic = Mathematics/Analysis
date = 2020-05-02
notify = jose.manuel.rodriguez.caballero@ut.ee, unruh@ut.ee
abstract =
We formalize in Isabelle/HOL a result
due to S. Banach and H. Steinhaus known as
the Banach-Steinhaus theorem or Uniform boundedness principle: a
pointwise-bounded family of continuous linear operators from a Banach
space to a normed space is uniformly bounded. Our approach is an
adaptation to Isabelle/HOL of a proof due to A. Sokal.
[Complex_Geometry]
title = Complex Geometry
author = Filip Marić <http://www.matf.bg.ac.rs/~filip>, Danijela Simić <http://poincare.matf.bg.ac.rs/~danijela>
topic = Mathematics/Geometry
date = 2019-12-16
notify = danijela@matf.bg.ac.rs, filip@matf.bg.ac.rs, boutry@unistra.fr
abstract =
A formalization of geometry of complex numbers is presented.
Fundamental objects that are investigated are the complex plane
extended by a single infinite point, its objects (points, lines and
circles), and groups of transformations that act on them (e.g.,
inversions and Möbius transformations). Most objects are defined
algebraically, but correspondence with classical geometric definitions
is shown.
[Poincare_Disc]
title = Poincaré Disc Model
author = Danijela Simić <http://poincare.matf.bg.ac.rs/~danijela>, Filip Marić <http://www.matf.bg.ac.rs/~filip>, Pierre Boutry <mailto:boutry@unistra.fr>
topic = Mathematics/Geometry
date = 2019-12-16
notify = danijela@matf.bg.ac.rs, filip@matf.bg.ac.rs, boutry@unistra.fr
abstract =
We describe formalization of the Poincaré disc model of hyperbolic
geometry within the Isabelle/HOL proof assistant. The model is defined
within the extended complex plane (one dimensional complex projectives
space &#8450;P1), formalized in the AFP entry “Complex Geometry”.
Points, lines, congruence of pairs of points, betweenness of triples
of points, circles, and isometries are defined within the model. It is
shown that the model satisfies all Tarski's axioms except the
Euclid's axiom. It is shown that it satisfies its negation and
the limiting parallels axiom (which proves it to be a model of
hyperbolic geometry).
[Fourier]
title = Fourier Series
author = Lawrence C Paulson <https://www.cl.cam.ac.uk/~lp15/>
topic = Mathematics/Analysis
date = 2019-09-06
notify = lp15@cam.ac.uk
abstract =
This development formalises the square integrable functions over the
reals and the basics of Fourier series. It culminates with a proof
that every well-behaved periodic function can be approximated by a
Fourier series. The material is ported from HOL Light:
https://github.com/jrh13/hol-light/blob/master/100/fourier.ml
[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.
[CakeML_Codegen]
title = A Verified Code Generator from Isabelle/HOL to CakeML
author = Lars Hupel <https://lars.hupel.info/>
topic = Computer science/Programming languages/Compiling, Logic/Rewriting
date = 2019-07-08
notify = lars@hupel.info
abstract =
This entry contains the formalization that accompanies my PhD thesis
(see https://lars.hupel.info/research/codegen/). I develop a verified
compilation toolchain from executable specifications in Isabelle/HOL
to CakeML abstract syntax trees. This improves over the
state-of-the-art in Isabelle by providing a trustworthy procedure for
code generation.
[DiscretePricing]
title = Pricing in discrete financial models
author = Mnacho Echenim <http://lig-membres.imag.fr/mechenim/>
topic = Mathematics/Probability theory, Mathematics/Games and 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>&thinsp;<em>y</em><sup>2</sup>,
where
<em>D</em>&thinsp;&isin;&thinsp;&#8469; 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>&thinsp;&isin;&thinsp;&#8469;
such that |<em>x</em>| +
|<em>y</em>|&thinsp;&radic;<span
style="text-decoration:
overline"><em>D</em></span> =
(<em>x</em><sub>0</sub> +
<em>y</em><sub>0</sub>&thinsp;&radic;<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
&#8477;<sup>n</sup>, the Lebesgue measure, and the
integer lattice &#8484;<sup>n</sup>: It states that
any convex subset of &#8477;<sup>n</sup> with volume
greater than 2<sup>n</sup> contains at least one lattice
point from &#8484;<sup>n</sup>\{0}, i.&thinsp;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
&#8477;<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/Proof theory
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.
extra-history =
Change history:
[2020-03-02]:
Added partial bijective and symmetric lenses.
Improved alphabet command generating additional lenses and results.
Several additional lens relations, including observational equivalence.
Additional theorems throughout.
Adaptations for Isabelle 2020.
(revision 44e2e5c)
[2021-01-27]
Addition of new theorems throughout, particularly for prisms.
New "chantype" command allows the definition of an algebraic datatype with generated prisms.
New "dataspace" command allows the definition of a local-based state space, including lenses and prisms.
Addition of various examples for the above.
(revision 89cf045a)
[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.
[Sigma_Commit_Crypto]
title = Sigma Protocols and Commitment Schemes
author = David Butler <https://www.turing.ac.uk/people/doctoral-students/david-butler>, Andreas Lochbihler <http://www.andreas-lochbihler.de>
topic = Computer science/Security/Cryptography
date = 2019-10-07
notify = dbutler@turing.ac.uk
abstract =
We use CryptHOL to formalise commitment schemes and Sigma-protocols.
Both are widely used fundamental two party cryptographic primitives.
Security for commitment schemes is considered using game-based
definitions whereas the security of Sigma-protocols is considered
using both the game-based and simulation-based security paradigms. In
this work, we first define security for both primitives and then prove
secure multiple case studies: the Schnorr, Chaum-Pedersen and
Okamoto Sigma-protocols as well as a construction that allows for
compound (AND and OR statements) Sigma-protocols and the Pedersen and
Rivest commitment schemes. We also prove that commitment schemes can
be constructed from Sigma-protocols. We formalise this proof at an
abstract level, only assuming the existence of a Sigma-protocol;
consequently, the instantiations of this result for the concrete
Sigma-protocols we consider come for free.
[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
&lambda;-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>&nbsp;(n!)</em>
in the worst case, i.&thinsp;e.&nbsp;<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.&thinsp;e.&nbsp;QuickSort with random pivot choice) is
<em>2&thinsp;(n+1)&thinsp;H<sub>n</sub> -
4&thinsp;n</em>, which is asymptotically equivalent to
<em>2&thinsp;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.&thinsp;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 &pi; 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/Graph
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/Graph, 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.
[C2KA_DistributedSystems]
title = Communicating Concurrent Kleene Algebra for Distributed Systems Specification
author = Maxime Buyse <mailto:maxime.buyse@polytechnique.edu>, Jason Jaskolka <https://carleton.ca/jaskolka/>
topic = Computer science/Automata and formal languages, Mathematics/Algebra
date = 2019-08-06
notify = maxime.buyse@polytechnique.edu, jason.jaskolka@carleton.ca
abstract =
Communicating Concurrent Kleene Algebra (C²KA) is a mathematical
framework for capturing the communicating and concurrent behaviour of
agents in distributed systems. It extends Hoare et al.'s
Concurrent Kleene Algebra (CKA) with communication actions through the
notions of stimuli and shared environments. C²KA has applications in
studying system-level properties of distributed systems such as
safety, security, and reliability. In this work, we formalize results
about C²KA and its application for distributed systems specification.
We first formalize the stimulus structure and behaviour structure
(CKA). Next, we combine them to formalize C²KA and its properties.
Then, we formalize notions and properties related to the topology of
distributed systems and the potential for communication via stimuli
and via shared environments of agents, all within the algebraic
setting of C²KA.
[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 =
<p>
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.
</p><p>
Revisions made subsequent to the first version of this article added
material on equivalence of categories, cartesian categories,
categories with pullbacks, categories with finite limits, and
cartesian closed categories. A construction was given of the category
of hereditarily finite sets and functions between them, and it was
shown that this category is cartesian closed.
</p>
extra-history =
Change history:
[2018-05-29]:
Revised axioms for the category locale. Introduced notation for composition and "in hom".
(revision 8318366d4575)<br>
[2020-02-15]:
Move ConcreteCategory.thy from Bicategory to Category3 and use it systematically.
Make other minor improvements throughout.
(revision a51840d36867)<br>
[2020-07-10]:
Added new material, mostly centered around cartesian categories.
(revision 06640f317a79)<br>
[2020-11-04]:
Minor modifications and extensions made in conjunction with the addition
of new material to Bicategory.
(revision 472cb2268826)<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 =
<p>
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.
</p><p>
Revisions made subsequent to the first version of this article added
material on cartesian monoidal categories; showing that the underlying
category of a cartesian monoidal category is a cartesian category, and
that every cartesian category extends to a cartesian monoidal
category.
</p>
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>
[2020-02-15]:
Cosmetic improvements.
(revision a51840d36867)<br>
[2020-07-10]:
Added new material on cartesian monoidal categories.
(revision 06640f317a79)<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>
[2020-12-19]:
simpler proof of linkability for bounded unhindered bipartite webs, leading to a simpler proof for networks with bounded out-capacities
(revision 93ca33f4d915)<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&thinsp;prime]&thinsp;·&thinsp;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 =
[Relational_Method]
title = The Relational Method with Message Anonymity for the Verification of Cryptographic Protocols
author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
topic = Computer science/Security
date = 2020-12-05
notify = pasquale.noce.lavoro@gmail.com
abstract =
This paper introduces a new method for the formal verification of
cryptographic protocols, the relational method, derived from
Paulson's inductive method by means of some enhancements aimed at
streamlining formal definitions and proofs, specially for protocols
using public key cryptography. Moreover, this paper proposes a method
to formalize a further security property, message anonymity, in
addition to message confidentiality and authenticity. The relational
method, including message anonymity, is then applied to the
verification of a sample authentication protocol, comprising Password
Authenticated Connection Establishment (PACE) with Chip Authentication
Mapping followed by the explicit verification of an additional
password over the PACE secure channel.
[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/Graph
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/Graph
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/Graph
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/Graph
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/Order
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<http://cl-informatik.uibk.ac.at/users/mhaslbeck//>
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 &mdash;except for the <tt>iptables-save</tt> dump of
the analyzed firewall&mdash; 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
[IsaGeoCoq]
title = Tarski's Parallel Postulate implies the 5th Postulate of Euclid, the Postulate of Playfair and the original Parallel Postulate of Euclid
author = Roland Coghetto <mailto:roland_coghetto@hotmail.com>
topic = Mathematics/Geometry
license = LGPL
date = 2021-01-31
notify = roland_coghetto@hotmail.com
abstract =
<p>The <a href="https://geocoq.github.io/GeoCoq/">GeoCoq library</a> contains a formalization
of geometry using the Coq proof assistant. It contains both proofs
about the foundations of geometry and high-level proofs in the same
style as in high school. We port a part of the GeoCoq
2.4.0 library to Isabelle/HOL: more precisely,
the files Chap02.v to Chap13_3.v, suma.v as well as the associated
definitions and some useful files for the demonstration of certain
parallel postulates. The synthetic approach of the demonstrations is directly
inspired by those contained in GeoCoq. The names of the lemmas and
theorems used are kept as far as possible as well as the definitions.
</p>
<p>It should be noted that T.J.M. Makarios has done
<a href="https://www.isa-afp.org/entries/Tarskis_Geometry.html">some proofs in Tarski's Geometry</a>. It uses a definition that does not quite
coincide with the definition used in Geocoq and here.
Furthermore, corresponding definitions in the <a href="https://www.isa-afp.org/entries/Poincare_Disc.html">Poincaré Disc Model
development</a> are not identical to those defined in GeoCoq.
</p>
<p>In the last part, it is
formalized that, in the neutral/absolute space, the axiom of the
parallels of Tarski's system implies the Playfair axiom, the 5th
postulate of Euclid and Euclid's original parallel postulate. These
proofs, which are not constructive, are directly inspired by Pierre
Boutry, Charly Gries, Julien Narboux and Pascal Schreck.
</p>
[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 <https://traytel.bitbucket.io>
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 <https://traytel.bitbucket.io>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
topic = Computer science/Automata and formal languages, Logic/General logic/Decidability of theories
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 <https://traytel.bitbucket.io>
topic = Computer science/Automata and formal languages, Logic/General logic/Decidability of theories
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/Computability, 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/General logic/Mechanization of proofs
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/General logic/Decidability of theories
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 <https://traytel.bitbucket.io>
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/Graph
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/Mathematical
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/Mathematical, 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/Mathematical
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/Graph
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.
[2020-11-20]:
Additional theory Natural_Mergesort that developes an efficient mergesort
algorithm without key-functions for educational purposes.
notify = c.sternagel@gmail.com
[SATSolverVerification]
title = Formal Verification of Modern SAT Solvers
author = Filip Marić <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/Graph
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/Graph
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 entry verifies priority queues based on Braun trees. Insertion
and deletion take logarithmic time and preserve the balanced nature
of Braun trees. Two implementations of deletion are provided.
notify = nipkow@in.tum.de
extra-history =
Change history:
[2019-12-16]: Added theory Priority_Queue_Braun2 with second version of del_min
[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
[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..&lt;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 <mailto:c.sternagel@gmail.com>, 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
[Attack_Trees]
title = Attack Trees in Isabelle for GDPR compliance of IoT healthcare systems
author = Florian Kammueller <http://www.cs.mdx.ac.uk/people/florian-kammueller/>
topic = Computer science/Security
date = 2020-04-27
notify = florian.kammuller@gmail.com
abstract =
In this article, we present a proof theory for Attack Trees. Attack
Trees are a well established and useful model for the construction of
attacks on systems since they allow a stepwise exploration of high
level attacks in application scenarios. Using the expressiveness of
Higher Order Logic in Isabelle, we develop a generic
theory of Attack Trees with a state-based semantics based on Kripke
structures and CTL. The resulting framework
allows mechanically supported logic analysis of the meta-theory of the
proof calculus of Attack Trees and at the same time the developed
proof theory enables application to case studies. A central
correctness and completeness result proved in Isabelle establishes a
connection between the notion of Attack Tree validity and CTL. The
application is illustrated on the example of a healthcare IoT system
and GDPR compliance verification.
[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
[Clean]
title = Clean - An Abstract Imperative Programming Language and its Theory
author = Frédéric Tuong <https://www.lri.fr/~ftuong/>, Burkhart Wolff <https://www.lri.fr/~wolff/>
topic = Computer science/Programming languages, Computer science/Semantics
date = 2019-10-04
notify = wolff@lri.fr, ftuong@lri.fr
abstract =
Clean is based on a simple, abstract execution model for an imperative
target language. “Abstract” is understood in contrast to “Concrete
Semantics”; alternatively, the term “shallow-style embedding” could be
used. It strives for a type-safe notion of program-variables, an
incremental construction of the typed state-space, support of
incremental verification, and open-world extensibility of new type
definitions being intertwined with the program definitions. Clean is
based on a “no-frills” state-exception monad with the usual
definitions of bind and unit for the compositional glue of state-based
computations. Clean offers conditionals and loops supporting C-like
control-flow operators such as break and return. The state-space
construction is based on the extensible record package. Direct
recursion of procedures is supported. Clean’s design strives for
extreme simplicity. It is geared towards symbolic execution and proven
correct verification tools. The underlying libraries of this package,
however, deliberately restrict themselves to the most elementary
infrastructure for these tasks. The package is intended to serve as
demonstrator semantic backend for Isabelle/C, or for the
test-generation techniques.
[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>&lt;:</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>&lt;:</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 <https://www.andreipopescu.uk>, 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 =
[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)
[Relational-Incorrectness-Logic]
title = An Under-Approximate Relational Logic
author = Toby Murray <https://people.eng.unimelb.edu.au/tobym/>
topic = Computer science/Programming languages/Logics, Computer science/Security
date = 2020-03-12
notify = toby.murray@unimelb.edu.au
abstract =
Recently, authors have proposed under-approximate logics for reasoning
about programs. So far, all such logics have been confined to
reasoning about individual program behaviours. Yet there exist many
over-approximate relational logics for reasoning about pairs of
programs and relating their behaviours. We present the first
under-approximate relational logic, for the simple imperative language
IMP. We prove our logic is both sound and complete. Additionally, we
show how reasoning in this logic can be decomposed into non-relational
reasoning in an under-approximate Hoare logic, mirroring Beringer’s
result for over-approximate relational logics. We illustrate the
application of our logic on some small examples in which we provably
demonstrate the presence of insecurity.
[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 =
[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 =
[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/Order
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/General logic/Mechanization of proofs
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/Proof theory
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/Set theory
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 <https://www.andreipopescu.uk>
date = 2009-09-01
topic = Logic/Set theory
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 = Asta Halkjær From <https://people.compute.dtu.dk/ahfrom/>
date = 2007-08-02
topic = Logic/General logic/Classical first-order 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 = Asta Halkjær From <https://people.compute.dtu.dk/ahfrom/>
topic = Logic/General logic/Logics of knowledge and belief
date = 2018-10-29
notify = ahfrom@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/Proof theory
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/General logic/Decidability of theories
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/General logic/Temporal 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/Computability
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/General logic/Classical propositional 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 <https://www.andreipopescu.uk>
date = 2013-06-27
topic = Logic/General logic/Mechanization of proofs
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 <https://traytel.bitbucket.io>
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 <mailto:c.sternagel@gmail.com>, 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 <mailto:c.sternagel@gmail.com>, 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
[Laplace_Transform]
title = Laplace Transform
author = Fabian Immler <https://home.in.tum.de/~immler/>
topic = Mathematics/Analysis
date = 2019-08-14
notify = fimmler@cs.cmu.edu
abstract =
This entry formalizes the Laplace transform and concrete Laplace
transforms for arithmetic functions, frequency shift, integration and
(higher) differentiation in the time domain. It proves Lerch's
lemma and uniqueness of the Laplace transform for continuous
functions. In order to formalize the foundational assumptions, this
entry contains a formalization of piecewise continuous functions and
functions of exponential order.
[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 <mailto:c.sternagel@gmail.com>, 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/Mathematical
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
&#8712; &#8477;”.
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 <https://traytel.bitbucket.io>
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/General logic/Temporal 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/Graph, 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 =
[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 = 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@gmail.com, 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@gmail.com, 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/Games and 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/Games and 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/Games and 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@gmail.com
[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@gmail.com
[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 &ge; 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 &ge; 0</i>, let <var>n(i)</var> be the number of nodes
labeled <i>i</i>. If <i>|M| = n(1) +
&sum;<sub>i &ge; 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@gmail.com
[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.html">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 <mailto:c.sternagel@gmail.com>
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://foss.heptapod.net/isa-afp/afp-devel/-/commit/3498bb1e4c7ba468db8588eb7184c1849641f7d3">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/Set theory
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/Proof theory
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/Philosophical aspects
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/Philosophical aspects
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/Philosophical aspects
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/Philosophical aspects
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/Philosophical aspects
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://foss.heptapod.net/isa-afp/afp-devel/-/commit/e68e1996d5d4926397c9244e786446e99ab17e63">afp-devel@ea3b38fc54d6</a> and
<a href="https://projects.brucker.ch/hol-testgen/log/trunk?rev=12148">hol-testgen@12148</a><br>
&nbsp;&nbsp;&nbsp;Update of Featherweight OCL including a change in the abstract.<br>
[2014-01-16]:
<a href="https://foss.heptapod.net/isa-afp/afp-devel/-/commit/6217cc5b29c560f24ecc64c81047778becb69f51">afp-devel@9091ce05cb20</a> and
<a href="https://projects.brucker.ch/hol-testgen/log/trunk?rev=10241">hol-testgen@10241</a><br>
&nbsp;&nbsp;&nbsp;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 <https://www.andreipopescu.uk>, 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 <https://www.andreipopescu.uk>
date = 2014-04-16
topic = Computer science/Security, Logic/General logic/Temporal 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 <https://www.andreipopescu.uk>, 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 <https://www.andreipopescu.uk>, Dmitriy Traytel <https://traytel.bitbucket.io>
date = 2014-04-16
topic = Logic/Proof theory
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 &ldquo;Introduction to Analytic Number
Theory&rdquo;. This includes: <ul> <li>Definitions and
basic properties for several number-theoretic functions (Euler's
&phi;, M&ouml;bius &mu;, Liouville's &lambda;,
the divisor function &sigma;, von Mangoldt's
&Lambda;)</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.
[Gauss_Sums]
title = Gauss Sums and the Pólya–Vinogradov Inequality
author = Rodrigo Raya <https://people.epfl.ch/rodrigo.raya>, Manuel Eberl <https://www21.in.tum.de/~eberlm>
topic = Mathematics/Number theory
date = 2019-12-10
notify = manuel.eberl@tum.de
abstract =
<p>This article provides a full formalisation of Chapter 8 of
Apostol's <em><a
href="https://www.springer.com/de/book/9780387901633">Introduction
to Analytic Number Theory</a></em>. Subjects that are
covered are:</p> <ul> <li>periodic arithmetic
functions and their finite Fourier series</li>
<li>(generalised) Ramanujan sums</li> <li>Gauss sums
and separable characters</li> <li>induced moduli and
primitive characters</li> <li>the
Pólya&mdash;Vinogradov inequality</li> </ul>
[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 &zeta; function &zeta;(<em>a</em>,<em>s</em>) and,
based on that, the Riemann &zeta; function &zeta;(<em>s</em>).
This is done by first defining them for &real;(<em>z</em>) > 1
and then successively extending the domain to the left using the
Euler&ndash;MacLaurin formula.</p>
<p>Apart from the most basic facts such as analyticity, the following
results are provided:</p>
<ul>
<li>the Stieltjes constants and the Laurent expansion of
&zeta;(<em>s</em>) at <em>s</em> = 1</li>
<li>the non-vanishing of &zeta;(<em>s</em>)
for &real;(<em>z</em>) &ge; 1</li>
<li>the relationship between &zeta;(<em>a</em>,<em>s</em>) and &Gamma;</li>
<li>the special values at negative integers and positive even integers</li>
<li>Hurwitz's formula and the reflection formula for &zeta;(<em>s</em>)</li>
<li>the <a href="https://arxiv.org/abs/math/0405478">
Hadjicostas&ndash;Chapman formula</a></li>
</ul>
<p>The entry also contains Euler's analytic proof of the infinitude of primes,
based on the fact that &zeta;(<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>&phi;</i><sup><i>n</i></sup>
-
(-<i>&phi;</i>)<sup>-<i>n</i></sup>)
/ &radic;<span style="text-decoration:
overline">5</span> where &phi; is the golden ratio.
</p> <p> In this work, I build on existing tools in
Isabelle &ndash; such as formal power series and polynomial
factorisation algorithms &ndash; 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>
[Lambert_W]
title = The Lambert W Function on the Reals
author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
topic = Mathematics/Analysis
date = 2020-04-24
notify = eberlm@in.tum.de
abstract =
<p>The Lambert <em>W</em> function is a multi-valued
function defined as the inverse function of <em>x</em>
&#x21A6; <em>x</em>
e<sup><em>x</em></sup>. Besides numerous
applications in combinatorics, physics, and engineering, it also
frequently occurs when solving equations containing both
e<sup><em>x</em></sup> and
<em>x</em>, or both <em>x</em> and log
<em>x</em>.</p> <p>This article provides a
definition of the two real-valued branches
<em>W</em><sub>0</sub>(<em>x</em>)
and
<em>W</em><sub>-1</sub>(<em>x</em>)
and proves various properties such as basic identities and
inequalities, monotonicity, differentiability, asymptotic expansions,
and the MacLaurin series of
<em>W</em><sub>0</sub>(<em>x</em>)
at <em>x</em> = 0.</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/Mathematical
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/Mathematical, 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/Mathematical, 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/Mathematical, 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@gmail.com
[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 = Mathematics/Games and economics, Mathematics/Graph theory
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>
contributors = Manuel Eberl <https://www21.in.tum.de/~eberlm>
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/Machine learning, Mathematics/Analysis
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
[Inductive_Inference]
title = Some classical results in inductive inference of recursive functions
author = Frank J. Balbach <mailto:frank-balbach@gmx.de>
topic = Logic/Computability, Computer science/Machine learning
date = 2020-08-31
notify = frank-balbach@gmx.de
abstract =
<p> This entry formalizes some classical concepts and results
from inductive inference of recursive functions. In the basic setting
a partial recursive function ("strategy") must identify
("learn") all functions from a set ("class") of
recursive functions. To that end the strategy receives more and more
values $f(0), f(1), f(2), \ldots$ of some function $f$ from the given
class and in turn outputs descriptions of partial recursive functions,
for example, Gödel numbers. The strategy is considered successful if
the sequence of outputs ("hypotheses") converges to a
description of $f$. A class of functions learnable in this sense is
called "learnable in the limit". The set of all these
classes is denoted by LIM. </p> <p> Other types of
inference considered are finite learning (FIN), behaviorally correct
learning in the limit (BC), and some variants of LIM with restrictions
on the hypotheses: total learning (TOTAL), consistent learning (CONS),
and class-preserving learning (CP). The main results formalized are
the proper inclusions $\mathrm{FIN} \subset \mathrm{CP} \subset
\mathrm{TOTAL} \subset \mathrm{CONS} \subset \mathrm{LIM} \subset
\mathrm{BC} \subset 2^{\mathcal{R}}$, where $\mathcal{R}$ is the set
of all total recursive functions. Further results show that for all
these inference types except CONS, strategies can be assumed to be
total recursive functions; that all inference types but CP are closed
under the subset relation between classes; and that no inference type
is closed under the union of classes. </p> <p> The above
is based on a formalization of recursive functions heavily inspired by
the <a
href="https://www.isa-afp.org/entries/Universal_Turing_Machine.html">Universal
Turing Machine</a> entry by Xu et al., but different in that it
models partial functions with codomain <em>nat
option</em>. The formalization contains a construction of a
universal partial recursive function, without resorting to Turing
machines, introduces decidability and recursive enumerability, and
proves some standard results: existence of a Kleene normal form, the
<em>s-m-n</em> theorem, Rice's theorem, and assorted
fixed-point theorems (recursion theorems) by Kleene, Rogers, and
Smullyan. </p>
[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>
contributors = Manuel Eberl <https://www21.in.tum.de/~eberlm>
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&ndash;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&ndash;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&ndash;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&ndash;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/General logic/Mechanization of proofs
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/Proof theory
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/Games and 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 <http://cl-informatik.uibk.ac.at/users/mhaslbeck//>, 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/Mathematical
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/Games and 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/Games and 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&ndash;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.&thinsp;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&nbsp;&le;&nbsp;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/Distributed, 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/Proof theory
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> / (&radic;<span
style="text-decoration: overline">&pi;</span> &middot;
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 <mailto:c.sternagel@gmail.com>
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/General logic/Mechanization of proofs
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/Proof theory
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 =
<p>This work contains a proof of Stirling's formula both for the factorial $n! \sim \sqrt{2\pi n} (n/e)^n$ on natural numbers and the real
Gamma function $\Gamma(x)\sim \sqrt{2\pi/x} (x/e)^x$. The proof is based on work by <a
href="http://www.maths.lancs.ac.uk/~jameson/stirlgamma.pdf">Graham Jameson</a>.</p>
<p>This is then extended to the full asymptotic expansion
$$\log\Gamma(z) = \big(z - \tfrac{1}{2}\big)\log z - z + \tfrac{1}{2}\log(2\pi) + \sum_{k=1}^{n-1} \frac{B_{k+1}}{k(k+1)} z^{-k}\\
{} - \frac{1}{n} \int_0^\infty B_n([t])(t + z)^{-n}\,\text{d}t$$
uniformly for all complex $z\neq 0$ in the cone $\text{arg}(z)\leq \alpha$ for any $\alpha\in(0,\pi)$, with which the above asymptotic
relation for &Gamma; is also extended to complex arguments.</p>
[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/General logic/Temporal logic, Mathematics/Order
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/Games and 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/General logic/Modal 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/General logic/Paraconsistent logics
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/General logic/Mechanization of proofs
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 Asta 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> + &hellip; + 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&ndash;Tanigawa algorithm for computing Bernoulli numbers
with reasonable efficiency, and we define the periodic Bernoulli
polynomials (which appear e.g. in the Euler&ndash;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 <https://www.andreipopescu.uk>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Logic/Proof theory
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/General logic/Modal 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.
[Syntax_Independent_Logic]
title = Syntax-Independent Logic Infrastructure
author = Andrei Popescu <https://www.andreipopescu.uk>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Logic/Proof theory
date = 2020-09-16
notify = a.popescu@sheffield.ac.uk, traytel@di.ku.dk
abstract =
We formalize a notion of logic whose terms and formulas are kept
abstract. In particular, logical connectives, substitution, free
variables, and provability are not defined, but characterized by their
general properties as locale assumptions. Based on this abstract
characterization, we develop further reusable reasoning
infrastructure. For example, we define parallel substitution (along
with proving its characterizing theorems) from single-point
substitution. Similarly, we develop a natural deduction style proof
system starting from the abstract Hilbert-style one. These one-time
efforts benefit different concrete logics satisfying our locales'
assumptions. We instantiate the syntax-independent logic
infrastructure to Robinson arithmetic (also known as Q) in the AFP
entry <a
href="https://www.isa-afp.org/entries/Robinson_Arithmetic.html">Robinson_Arithmetic</a>
and to hereditarily finite set theory in the AFP entries <a
href="https://www.isa-afp.org/entries/Goedel_HFSet_Semantic.html">Goedel_HFSet_Semantic</a>
and <a
href="https://www.isa-afp.org/entries/Goedel_HFSet_Semanticless.html">Goedel_HFSet_Semanticless</a>,
which are part of our formalization of G&ouml;del's
Incompleteness Theorems described in our CADE-27 paper <a
href="https://dx.doi.org/10.1007/978-3-030-29436-6_26">A
Formally Verified Abstract Account of Gödel's Incompleteness
Theorems</a>.
[Goedel_Incompleteness]
title = An Abstract Formalization of G&ouml;del's Incompleteness Theorems
author = Andrei Popescu <https://www.andreipopescu.uk>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Logic/Proof theory
date = 2020-09-16
notify = a.popescu@sheffield.ac.uk, traytel@di.ku.dk
abstract =
We present an abstract formalization of G&ouml;del's
incompleteness theorems. We analyze sufficient conditions for the
theorems' applicability to a partially specified logic. Our
abstract perspective enables a comparison between alternative
approaches from the literature. These include Rosser's variation
of the first theorem, Jeroslow's variation of the second theorem,
and the Swierczkowski&ndash;Paulson semantics-based approach. This
AFP entry is the main entry point to the results described in our
CADE-27 paper <a
href="https://dx.doi.org/10.1007/978-3-030-29436-6_26">A
Formally Verified Abstract Account of Gödel's Incompleteness
Theorems</a>. As part of our abstract formalization's
validation, we instantiate our locales twice in the separate AFP
entries <a
href="https://www.isa-afp.org/entries/Goedel_HFSet_Semantic.html">Goedel_HFSet_Semantic</a>
and <a
href="https://www.isa-afp.org/entries/Goedel_HFSet_Semanticless.html">Goedel_HFSet_Semanticless</a>.
[Goedel_HFSet_Semantic]
title = From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part I
author = Andrei Popescu <https://www.andreipopescu.uk>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Logic/Proof theory
date = 2020-09-16
notify = a.popescu@sheffield.ac.uk, traytel@di.ku.dk
abstract =
We validate an abstract formulation of G&ouml;del's First and
Second Incompleteness Theorems from a <a
href="https://www.isa-afp.org/entries/Goedel_Incompleteness.html">separate
AFP entry</a> by instantiating them to the case of
<i>finite sound extensions of the Hereditarily Finite (HF) Set
theory</i>, i.e., FOL theories extending the HF Set theory with
a finite set of axioms that are sound in the standard model. The
concrete results had been previously formalised in an <a
href="https://www.isa-afp.org/entries/Incompleteness.html">AFP
entry by Larry Paulson</a>; our instantiation reuses the
infrastructure developed in that entry.
[Goedel_HFSet_Semanticless]
title = From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part II
author = Andrei Popescu <https://www.andreipopescu.uk>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Logic/Proof theory
date = 2020-09-16
notify = a.popescu@sheffield.ac.uk, traytel@di.ku.dk
abstract =
We validate an abstract formulation of G&ouml;del's Second
Incompleteness Theorem from a <a
href="https://www.isa-afp.org/entries/Goedel_Incompleteness.html">separate
AFP entry</a> by instantiating it to the case of <i>finite
consistent extensions of the Hereditarily Finite (HF) Set
theory</i>, i.e., consistent FOL theories extending the HF Set
theory with a finite set of axioms. The instantiation draws heavily
on infrastructure previously developed by Larry Paulson in his <a
href="https://www.isa-afp.org/entries/Incompleteness.html">direct
formalisation of the concrete result</a>. It strengthens
Paulson's formalization of G&ouml;del's Second from that
entry by <i>not</i> assuming soundness, and in fact not
relying on any notion of model or semantic interpretation. The
strengthening was obtained by first replacing some of Paulson’s
semantic arguments with proofs within his HF calculus, and then
plugging in some of Paulson's (modified) lemmas to instantiate
our soundness-free G&ouml;del's Second locale.
[Robinson_Arithmetic]
title = Robinson Arithmetic
author = Andrei Popescu <https://www.andreipopescu.uk>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Logic/Proof theory
date = 2020-09-16
notify = a.popescu@sheffield.ac.uk, traytel@di.ku.dk
abstract =
We instantiate our syntax-independent logic infrastructure developed
in <a
href="https://www.isa-afp.org/entries/Syntax_Independent_Logic.html">a
separate AFP entry</a> to the FOL theory of Robinson arithmetic
(also known as Q). The latter was formalised using Nominal Isabelle by
adapting <a
href="https://www.isa-afp.org/entries/Incompleteness.html">Larry
Paulson’s formalization of the Hereditarily Finite Set
theory</a>.
[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 =
<p>This is an example submission to the Archive of Formal Proofs. It shows
submission requirements and explains the structure of a simple typical
submission.</p>
<p>Note that you can use <em>HTML tags</em> and LaTeX formulae like
$\sum_{n=1}^\infty \frac{1}{n^2} = \frac{\pi^2}{6}$ in the abstract. Display formulae like
$$ \int_0^1 x^{-x}\,\text{d}x = \sum_{n=1}^\infty n^{-n}$$
are also possible. Please read the
<a href="../submitting.html">submission guidelines</a> before using this.</p>
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/General logic/Lambda calculus
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/Philosophical aspects
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&uuml;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 =
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>.
extra-history =
Change history:
[2020-15-04]: Change representation of k-dimensional points from 'list' to
HOL-Analysis.Finite_Cartesian_Product 'vec'. Update proofs
to incorporate HOL-Analysis 'dist' and 'cbox' primitives.
[Closest_Pair_Points]
title = Closest Pair of Points Algorithms
author = Martin Rau <mailto:martin.rau@tum.de>, Tobias Nipkow <http://www.in.tum.de/~nipkow>
topic = Computer science/Algorithms/Geometry
date = 2020-01-13
notify = martin.rau@tum.de, nipkow@in.tum.de
abstract =
This entry provides two related verified divide-and-conquer algorithms
solving the fundamental <em>Closest Pair of Points</em>
problem in Computational Geometry. Functional correctness and the
optimal running time of <em>O</em>(<em>n</em> log <em>n</em>) are
proved. Executable code is generated which is empirically competitive
with handwritten reference implementations.
extra-history =
Change history:
[2020-14-04]: Incorporate Time_Monad of the AFP entry Root_Balanced_Tree.
[Approximation_Algorithms]
title = Verified Approximation Algorithms
author = Robin Eßmann <mailto:robin.essmann@tum.de>, Tobias Nipkow <http://www.in.tum.de/~nipkow/>, Simon Robillard <https://simon-robillard.net/>
topic = Computer science/Algorithms/Approximation
date = 2020-01-16
notify = nipkow@in.tum.de
abstract =
We present the first formal verification of approximation algorithms
for NP-complete optimization problems: vertex cover, set cover, independent set,
load balancing, and bin packing. The proofs correct incompletenesses
in existing proofs and improve the approximation ratio in one case.
A detailed description of our work has been published in the proceedings of
<a href="https://doi.org/10.1007/978-3-030-51054-1_17">IJCAR 2020</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/Mathematical, 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/General logic/Modal 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 &ndash; most notably their analyticity,
their areas of convergence, and their non-vanishing for &Re;(s)
&ge; 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>,&hellip;,<em>X</em><sub>n</sub>
that does not discriminate between its variables, i.&thinsp;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>,&hellip;,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>,&hellip;,<em>x</em><sub>n</sub>,
namely
<em>c</em><sub><em>k</em></sub> = (-1)<sup><em>n</em>-<em>k</em></sup>&thinsp;e<sub><em>n</em>-<em>k</em></sub>(<em>x</em><sub>1</sub>,&hellip;,<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/Mathematical, 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 <http://home.in.tum.de/~mansour/>, 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.
[AI_Planning_Languages_Semantics]
title = AI Planning Languages Semantics
author = Mohammad Abdulaziz <http://home.in.tum.de/~mansour/>, Peter Lammich <http://www21.in.tum.de/~lammich>
topic = Computer science/Artificial intelligence
date = 2020-10-29
notify = mohammad.abdulaziz8@gmail.com
abstract =
This is an Isabelle/HOL formalisation of the semantics of the
multi-valued planning tasks language that is used by the planning
system Fast-Downward, the STRIPS fragment of the Planning Domain
Definition Language (PDDL), and the STRIPS soundness meta-theory
developed by Vladimir Lifschitz. It also contains formally verified
checkers for checking the well-formedness of problems specified in
either language as well the correctness of potential solutions. The
formalisation in this entry was described in an earlier publication.
[Verified_SAT_Based_AI_Planning]
title = Verified SAT-Based AI Planning
author = Mohammad Abdulaziz <http://home.in.tum.de/~mansour/>, Friedrich Kurz <>
topic = Computer science/Artificial intelligence
date = 2020-10-29
notify = mohammad.abdulaziz8@gmail.com
abstract =
We present an executable formally verified SAT encoding of classical
AI planning that is based on the encodings by Kautz and Selman and the
one by Rintanen et al. The encoding was experimentally tested and
shown to be usable for reasonably sized standard AI planning
benchmarks. We also use it as a reference to test a state-of-the-art
SAT-based planner, showing that it sometimes falsely claims that
problems have no solutions of certain lengths. The formalisation in
this submission was described in an independent publication.
[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 <https://people.compute.dtu.dk/andschl/>, Jasmin Christian Blanchette <mailto:j.c.blanchette@vu.nl>, Dmitriy Traytel <https://traytel.bitbucket.io>, Uwe Waldmann <mailto:uwe@mpi-inf.mpg.de>
topic = Logic/General logic/Mechanization of proofs
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.
[Chandy_Lamport]
title = A Formal Proof of The Chandy--Lamport Distributed Snapshot Algorithm
author = Ben Fiedler <mailto:ben.fiedler@inf.ethz.ch>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Computer science/Algorithms/Distributed
date = 2020-07-21
notify = ben.fiedler@inf.ethz.ch, traytel@inf.ethz.ch
abstract =
We provide a suitable distributed system model and implementation of the
Chandy--Lamport distributed snapshot algorithm [ACM Transactions on
Computer Systems, 3, 63-75, 1985]. Our main result is a formal
termination and correctness proof of the Chandy--Lamport algorithm and
its use in stable property detection.
[BNF_Operations]
title = Operations on Bounded Natural Functors
author = Jasmin Christian Blanchette <mailto:jasmin.blanchette@gmail.com>, Andrei Popescu <https://www.andreipopescu.uk>, Dmitriy Traytel <https://traytel.bitbucket.io>
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 <http://cl-informatik.uibk.ac.at/users/mhaslbeck/>, Sebastiaan Joosten <http://sjcjoosten.nl/>, René Thiemann <http://cl-informatik.uibk.ac.at/users/thiemann/>, Akihisa Yamada<>
topic = Computer science/Algorithms/Mathematical, 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 <http://cl-informatik.uibk.ac.at/users/mhaslbeck/>, 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>
[Skip_Lists]
title = Skip Lists
author = Max W. Haslbeck <http://cl-informatik.uibk.ac.at/users/mhaslbeck/>, Manuel Eberl <https://www21.in.tum.de/~eberlm/>
topic = Computer science/Data structures
date = 2020-01-09
notify = max.haslbeck@gmx.de
abstract =
<p> Skip lists are sorted linked lists enhanced with shortcuts
and are an alternative to binary search trees. A skip lists consists
of multiple levels of sorted linked lists where a list on level n is a
subsequence of the list on level n − 1. In the ideal case, elements
are skipped in such a way that a lookup in a skip lists takes O(log n)
time. In a randomised skip list the skipped elements are choosen
randomly. </p> <p> This entry contains formalized proofs
of the textbook results about the expected height and the expected
length of a search path in a randomised skip list. </p>
[Mersenne_Primes]
title = Mersenne primes and the Lucas–Lehmer test
author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
topic = Mathematics/Number theory
date = 2020-01-17
notify = eberlm@in.tum.de
abstract =
<p>This article provides formal proofs of basic properties of
Mersenne numbers, i. e. numbers of the form
2<sup><em>n</em></sup> - 1, and especially of
Mersenne primes.</p> <p>In particular, an efficient,
verified, and executable version of the Lucas&ndash;Lehmer test is
developed. This test decides primality for Mersenne numbers in time
polynomial in <em>n</em>.</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/Games and 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/Computability
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/Games and 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/Optimization
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
&pi;(<em>x</em>) ~ <em>x</em>/ln
<em>x</em> where &pi;(<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 &psi; and the
&ldquo;<em>n</em>-th prime number&rdquo; 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.&thinsp;e.
&sum;<sub><em>p</em>&le;<em>x</em></sub>
ln <em>p</em>/<em>p</em> = ln
<em>x</em> + <em>O</em>(1) and
&sum;<sub><em>p</em>&le;<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
&sum;<sub><em>p</em>&le;<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/Mathematical
date = 2018-09-20
notify = alexander.maletzky@risc.jku.at
abstract =
<p>This article formalizes signature-based algorithms for computing
Gr&ouml;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&ouml;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&egrave;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 <https://people.compute.dtu.dk/andschl/>, Jasmin Christian Blanchette <mailto:j.c.blanchette@vu.nl>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Logic/General logic/Mechanization of proofs
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/Order
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.
[Core_SC_DOM]
title = The Safely Composable DOM
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 = 2020-09-28
notify = adbrucker@0x5f.org, mail@michael-herzberg.de
abstract =
In this AFP entry, we formalize the core of the Safely Composable
Document Object Model (SC DOM). The SC DOM improve the standard DOM
(as formalized in the AFP entry "Core DOM") by strengthening
the tree boundaries set by shadow roots: in the SC DOM, the shadow
root is a sub-class of the document class (instead of a base class).
This modifications also results in changes to some API methods (e.g.,
getOwnerDocument) to return the nearest shadow root rather than the
document root. As a result, many API methods that, when called on a
node inside a shadow tree, would previously ``break out''
and return or modify nodes that are possibly outside the shadow tree,
now stay within its boundaries. This change in behavior makes programs
that operate on shadow trees more predictable for the developer and
allows them to make more assumptions about other code accessing the
DOM.
[Shadow_SC_DOM]
title = A Formal Model of the Safely Composable Document Object Model with Shadow Roots
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 = 2020-09-28
notify = adbrucker@0x5f.org, mail@michael-herzberg.de
abstract =
In this AFP entry, we extend our formalization of the safely
composable DOM with Shadow Roots. This is a proposal for Shadow Roots
with stricter safety guarantess than the standard compliant
formalization (see "Shadow DOM"). Shadow Roots are a recent
proposal of the web community to support a component-based development
approach for client-side web applications. Shadow roots are a
significant extension to the DOM standard and, as web standards are
condemned to be backward compatible, such extensions often result in
complex specification that may contain unwanted subtleties that can be
detected by a formalization. Our Isabelle/HOL formalization is, in
the sense of object-orientation, an extension of our formalization of
the core DOM and enjoys the same basic properties, i.e., it is
extensible, i.e., can be extended without the need of re-proving
already proven properties and executable, i.e., we can generate
executable code from our specification. We exploit the executability
to show that our formalization complies to the official standard of
the W3C, respectively, the WHATWG.
[SC_DOM_Components]
title = A Formalization of Safely Composable Web Components
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 = 2020-09-28
notify = adbrucker@0x5f.org, mail@michael-herzberg.de
abstract =
While the (safely composable) DOM with shadow trees provide the
technical basis for defining web components, it does neither defines
the concept of web components nor specifies the safety properties that
web components should guarantee. Consequently, the standard also does
not discuss how or even if the methods for modifying the DOM respect
component boundaries. In AFP entry, we present a formally verified
model of safely composable web components and define safety properties
which ensure that different web components can only interact with each
other using well-defined interfaces. Moreover, our verification of the
application programming interface (API) of the DOM revealed numerous
invariants that implementations of the DOM API need to preserve to
ensure the integrity of components. In comparison to the strict
standard compliance formalization of Web Components in the AFP entry
"DOM_Components", the notion of components in this entry
(based on "SC_DOM" and "Shadow_SC_DOM") provides
much stronger safety guarantees.
[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&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.
[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 &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>
[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/Graph
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.&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>
[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 <https://www.andreipopescu.uk>
topic = Computer science/Programming languages/Lambda calculi, Computer science/Functional programming, Logic/General logic/Mechanization of proofs
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 <https://traytel.bitbucket.io>
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 &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>.
[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.
[Linear_Programming]
title = Linear Programming
author = Julian Parsert <http://www.parsert.com/>, Cezary Kaliszyk <http://cl-informatik.uibk.ac.at/cek/>
topic = Mathematics/Algebra
date = 2019-08-06
notify = julian.parsert@gmail.com, cezary.kaliszyk@uibk.ac.at
abstract =
We use the previous formalization of the general simplex algorithm to
formulate an algorithm for solving linear programs. We encode the
linear programs using only linear constraints. Solving these
constraints also solves the original linear program. This algorithm is
proven to be sound by applying the weak duality theorem which is also
part of this formalization.
[Differential_Game_Logic]
title = Differential Game Logic
author = André Platzer <http://www.cs.cmu.edu/~aplatzer/>
topic = Computer science/Programming languages/Logics
date = 2019-06-03
notify = aplatzer@cs.cmu.edu
abstract =
This formalization provides differential game logic (dGL), a logic for
proving properties of hybrid game. In addition to the syntax and
semantics, it formalizes a uniform substitution calculus for dGL.
Church's uniform substitutions substitute a term or formula for a
function or predicate symbol everywhere. The uniform substitutions for
dGL also substitute hybrid games for a game symbol everywhere. We
prove soundness of one-pass uniform substitutions and the axioms of
differential game logic with respect to their denotational semantics.
One-pass uniform substitutions are faster by postponing
soundness-critical admissibility checks with a linear pass homomorphic
application and regain soundness by a variable condition at the
replacements. The formalization is based on prior non-mechanized
soundness proofs for dGL.
[Complete_Non_Orders]
title = Complete Non-Orders and Fixed Points
author = Akihisa Yamada <http://group-mmm.org/~ayamada/>, Jérémy Dubut <http://group-mmm.org/~dubut/>
topic = Mathematics/Order
date = 2019-06-27
notify = akihisayamada@nii.ac.jp, dubut@nii.ac.jp
abstract =
We develop an Isabelle/HOL library of order-theoretic concepts, such
as various completeness conditions and fixed-point theorems. We keep
our formalization as general as possible: we reprove several
well-known results about complete orders, often without any properties
of ordering, thus complete non-orders. In particular, we generalize
the Knaster–Tarski theorem so that we ensure the existence of a
quasi-fixed point of monotone maps over complete non-orders, and show
that the set of quasi-fixed points is complete under a mild
condition—attractivity—which is implied by either antisymmetry or
transitivity. This result generalizes and strengthens a result by
Stauti and Maaden. Finally, we recover Kleene’s fixed-point theorem
for omega-complete non-orders, again using attractivity to prove that
Kleene’s fixed points are least quasi-fixed points.
[Priority_Search_Trees]
title = Priority Search Trees
author = Peter Lammich <http://www21.in.tum.de/~lammich>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
topic = Computer science/Data structures
date = 2019-06-25
notify = lammich@in.tum.de
abstract =
We present a new, purely functional, simple and efficient data
structure combining a search tree and a priority queue, which we call
a <em>priority search tree</em>. The salient feature of priority search
trees is that they offer a decrease-key operation, something that is
missing from other simple, purely functional priority queue
implementations. Priority search trees can be implemented on top of
any search tree. This entry does the implementation for red-black
trees. This entry formalizes the first part of our ITP-2019 proof
pearl <em>Purely Functional, Simple and Efficient Priority
Search Trees and Applications to Prim and Dijkstra</em>.
[Prim_Dijkstra_Simple]
title = Purely Functional, Simple, and Efficient Implementation of Prim and Dijkstra
author = Peter Lammich <http://www21.in.tum.de/~lammich>, Tobias Nipkow <http://www21.in.tum.de/~nipkow>
topic = Computer science/Algorithms/Graph
date = 2019-06-25
notify = lammich@in.tum.de
abstract =
We verify purely functional, simple and efficient implementations of
Prim's and Dijkstra's algorithms. This constitutes the first
verification of an executable and even efficient version of
Prim's algorithm. This entry formalizes the second part of our
ITP-2019 proof pearl <em>Purely Functional, Simple and Efficient
Priority Search Trees and Applications to Prim and Dijkstra</em>.
[MFOTL_Monitor]
title = Formalization of a Monitoring Algorithm for Metric First-Order Temporal Logic
author = Joshua Schneider <mailto:joshua.schneider@inf.ethz.ch>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Computer science/Algorithms, Logic/General logic/Temporal logic, Computer science/Automata and formal languages
date = 2019-07-04
notify = joshua.schneider@inf.ethz.ch, traytel@inf.ethz.ch
abstract =
A monitor is a runtime verification tool that solves the following
problem: Given a stream of time-stamped events and a policy formulated
in a specification language, decide whether the policy is satisfied at
every point in the stream. We verify the correctness of an executable
monitor for specifications given as formulas in metric first-order
temporal logic (MFOTL), an expressive extension of linear temporal
logic with real-time constraints and first-order quantification. The
verified monitor implements a simplified variant of the algorithm used
in the efficient MonPoly monitoring tool. The formalization is
presented in a <a href="https://doi.org/10.1007/978-3-030-32079-9_18">RV
2019 paper</a>, which also compares the output of the verified
monitor to that of other monitoring tools on randomly generated
inputs. This case study revealed several errors in the optimized but
unverified tools.
extra-history =
Change history:
[2020-08-13]:
added the formalization of the abstract slicing framework and joint data
slicer (revision b1639ed541b7)<br>
[FOL_Seq_Calc1]
title = A Sequent Calculus for First-Order Logic
author = Asta Halkjær From <https://people.compute.dtu.dk/ahfrom/>
contributors = 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/Proof theory
date = 2019-07-18
notify = ahfrom@dtu.dk
abstract =
This work formalizes soundness and completeness of a one-sided sequent
calculus for first-order logic. The completeness is shown via a
translation from a complete semantic tableau calculus, the proof of
which is based on the First-Order Logic According to Fitting theory.
The calculi and proof techniques are taken from Ben-Ari's
Mathematical Logic for Computer Science.
[Szpilrajn]
title = Szpilrajn Extension Theorem
author = Peter Zeller <mailto:p_zeller@cs.uni-kl.de>
topic = Mathematics/Order
date = 2019-07-27
notify = p_zeller@cs.uni-kl.de
abstract =
We formalize the Szpilrajn extension theorem, also known as
order-extension principal: Every strict partial order can be extended
to a strict linear order.
[TESL_Language]
title = A Formal Development of a Polychronous Polytimed Coordination Language
author = Hai Nguyen Van <mailto:hai.nguyenvan.phie@gmail.com>, Frédéric Boulanger <mailto:frederic.boulanger@centralesupelec.fr>, Burkhart Wolff <mailto:burkhart.wolff@lri.fr>
topic = Computer science/System description languages, Computer science/Semantics, Computer science/Concurrency
date = 2019-07-30
notify = frederic.boulanger@centralesupelec.fr, burkhart.wolff@lri.fr
abstract =
The design of complex systems involves different formalisms for
modeling their different parts or aspects. The global model of a
system may therefore consist of a coordination of concurrent
sub-models that use different paradigms. We develop here a theory for
a language used to specify the timed coordination of such
heterogeneous subsystems by addressing the following issues:
<ul><li>the
behavior of the sub-systems is observed only at a series of discrete
instants,</li><li>events may occur in different sub-systems at unrelated
times, leading to polychronous systems, which do not necessarily have
a common base clock,</li><li>coordination between subsystems involves
causality, so the occurrence of an event may enforce the occurrence of
other events, possibly after a certain duration has elapsed or an
event has occurred a given number of times,</li><li>the domain of time
(discrete, rational, continuous...) may be different in the
subsystems, leading to polytimed systems,</li><li>the time frames of
different sub-systems may be related (for instance, time in a GPS
satellite and in a GPS receiver on Earth are related although they are
not the same).</li></ul>
Firstly, a denotational semantics of the language is
defined. Then, in order to be able to incrementally check the behavior
of systems, an operational semantics is given, with proofs of
progress, soundness and completeness with regard to the denotational
semantics. These proofs are made according to a setup that can scale
up when new operators are added to the language. In order for
specifications to be composed in a clean way, the language should be
invariant by stuttering (i.e., adding observation instants at which
nothing happens). The proof of this invariance is also given.
[Stellar_Quorums]
title = Stellar Quorum Systems
author = Giuliano Losa <mailto:giuliano@galois.com>
topic = Computer science/Algorithms/Distributed
date = 2019-08-01
notify = giuliano@galois.com
abstract =
We formalize the static properties of personal Byzantine quorum
systems (PBQSs) and Stellar quorum systems, as described in the paper
``Stellar Consensus by Reduction'' (to appear at DISC 2019).
[IMO2019]
title = Selected Problems from the International Mathematical Olympiad 2019
author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
topic = Mathematics/Misc
date = 2019-08-05
notify = eberlm@in.tum.de
abstract =
<p>This entry contains formalisations of the answers to three of
the six problem of the International Mathematical Olympiad 2019,
namely Q1, Q4, and Q5.</p> <p>The reason why these
problems were chosen is that they are particularly amenable to
formalisation: they can be solved with minimal use of libraries. The
remaining three concern geometry and graph theory, which, in the
author's opinion, are more difficult to formalise resp. require a
more complex library.</p>
[Adaptive_State_Counting]
title = Formalisation of an Adaptive State Counting Algorithm
author = Robert Sachtleben <mailto:rob_sac@uni-bremen.de>
topic = Computer science/Automata and formal languages, Computer science/Algorithms
date = 2019-08-16
notify = rob_sac@uni-bremen.de
abstract =
This entry provides a formalisation of a refinement of an adaptive
state counting algorithm, used to test for reduction between finite
state machines. The algorithm has been originally presented by Hierons
in the paper <a
href="https://doi.org/10.1109/TC.2004.85">Testing from a
Non-Deterministic Finite State Machine Using Adaptive State
Counting</a>. Definitions for finite state machines and
adaptive test cases are given and many useful theorems are derived
from these. The algorithm is formalised using mutually recursive
functions, for which it is proven that the generated test suite is
sufficient to test for reduction against finite state machines of a
certain fault domain. Additionally, the algorithm is specified in a
simple WHILE-language and its correctness is shown using Hoare-logic.
[Jacobson_Basic_Algebra]
title = A Case Study in Basic Algebra
author = Clemens Ballarin <http://www21.in.tum.de/~ballarin/>
topic = Mathematics/Algebra
date = 2019-08-30
notify = ballarin@in.tum.de
abstract =
The focus of this case study is re-use in abstract algebra. It
contains locale-based formalisations of selected parts of set, group
and ring theory from Jacobson's <i>Basic Algebra</i>
leading to the respective fundamental homomorphism theorems. The
study is not intended as a library base for abstract algebra. It
rather explores an approach towards abstract algebra in Isabelle.
[Hybrid_Systems_VCs]
title = Verification Components for Hybrid Systems
author = Jonathan Julian Huerta y Munive <>
topic = Mathematics/Algebra, Mathematics/Analysis
date = 2019-09-10
notify = jjhuertaymunive1@sheffield.ac.uk, jonjulian23@gmail.com
abstract =
These components formalise a semantic framework for the deductive
verification of hybrid systems. They support reasoning about
continuous evolutions of hybrid programs in the style of differential
dynamics logic. Vector fields or flows model these evolutions, and
their verification is done with invariants for the former or orbits
for the latter. Laws of modal Kleene algebra or categorical predicate
transformers implement the verification condition generation. Examples
show the approach at work.
extra-history =
Change history:
[2020-12-13]: added components based on Kleene algebras with tests. These implement differential Hoare logic (dH) and a Morgan-style differential refinement calculus (dR) for verification of hybrid programs.
[Generic_Join]
title = Formalization of Multiway-Join Algorithms
author = Thibault Dardinier<>
topic = Computer science/Algorithms
date = 2019-09-16
notify = tdardini@student.ethz.ch, traytel@inf.ethz.ch
abstract =
Worst-case optimal multiway-join algorithms are recent seminal
achievement of the database community. These algorithms compute the
natural join of multiple relational databases and improve in the worst
case over traditional query plan optimizations of nested binary joins.
In 2014, <a
href="https://doi.org/10.1145/2590989.2590991">Ngo, Ré,
and Rudra</a> gave a unified presentation of different multi-way
join algorithms. We formalized and proved correct their "Generic
Join" algorithm and extended it to support negative joins.
[Aristotles_Assertoric_Syllogistic]
title = Aristotle's Assertoric Syllogistic
author = Angeliki Koutsoukou-Argyraki <https://www.cl.cam.ac.uk/~ak2110/>
topic = Logic/Philosophical aspects
date = 2019-10-08
notify = ak2110@cam.ac.uk
abstract =
We formalise with Isabelle/HOL some basic elements of Aristotle's
assertoric syllogistic following the <a
href="https://plato.stanford.edu/entries/aristotle-logic/">article from the Stanford Encyclopedia of Philosophy by Robin Smith.</a> To
this end, we use a set theoretic formulation (covering both individual
and general predication). In particular, we formalise the deductions
in the Figures and after that we present Aristotle's
metatheoretical observation that all deductions in the Figures can in
fact be reduced to either Barbara or Celarent. As the formal proofs
prove to be straightforward, the interest of this entry lies in
illustrating the functionality of Isabelle and high efficiency of
Sledgehammer for simple exercises in philosophy.
[VerifyThis2019]
title = VerifyThis 2019 -- Polished Isabelle Solutions
author = Peter Lammich<>, Simon Wimmer<http://home.in.tum.de/~wimmers/>
topic = Computer science/Algorithms
date = 2019-10-16
notify = lammich@in.tum.de, wimmers@in.tum.de
abstract =
VerifyThis 2019 (http://www.pm.inf.ethz.ch/research/verifythis.html)
was a program verification competition associated with ETAPS 2019. It
was the 8th event in the VerifyThis competition series. In this entry,
we present polished and completed versions of our solutions that we
created during the competition.
[ZFC_in_HOL]
title = Zermelo Fraenkel Set Theory in Higher-Order Logic
author = Lawrence C. Paulson <https://www.cl.cam.ac.uk/~lp15/>
topic = Logic/Set theory
date = 2019-10-24
notify = lp15@cam.ac.uk
abstract =
<p>This entry is a new formalisation of ZFC set theory in Isabelle/HOL. It is
logically equivalent to Obua's HOLZF; the point is to have the closest
possible integration with the rest of Isabelle/HOL, minimising the amount of
new notations and exploiting type classes.</p>
<p>There is a type <em>V</em> of sets and a function <em>elts :: V =&gt; V
set</em> mapping a set to its elements. Classes simply have type <em>V
set</em>, and a predicate identifies the small classes: those that correspond
to actual sets. Type classes connected with orders and lattices are used to
minimise the amount of new notation for concepts such as the subset relation,
union and intersection. Basic concepts — Cartesian products, disjoint sums,
natural numbers, functions, etc. — are formalised.</p>
<p>More advanced set-theoretic concepts, such as transfinite induction,
ordinals, cardinals and the transitive closure of a set, are also provided.
The definition of addition and multiplication for general sets (not just
ordinals) follows Kirby.</p>
<p>The theory provides two type classes with the aim of facilitating
developments that combine <em>V</em> with other Isabelle/HOL types:
<em>embeddable</em>, the class of types that can be injected into <em>V</em>
(including <em>V</em> itself as well as <em>V*V</em>, etc.), and
<em>small</em>, the class of types that correspond to some ZF set.</p>
extra-history =
Change history:
[2020-01-28]: Generalisation of the "small" predicate and order types to arbitrary sets;
ordinal exponentiation;
introduction of the coercion ord_of_nat :: "nat => V";
numerous new lemmas. (revision 6081d5be8d08)
[Interval_Arithmetic_Word32]
title = Interval Arithmetic on 32-bit Words
author = Brandon Bohrer <mailto:bbohrer@cs.cmu.edu>
topic = Computer science/Data structures
date = 2019-11-27
notify = bjbohrer@gmail.com, bbohrer@cs.cmu.edu
abstract =
Interval_Arithmetic implements conservative interval arithmetic
computations, then uses this interval arithmetic to implement a simple
programming language where all terms have 32-bit signed word values,
with explicit infinities for terms outside the representable bounds.
Our target use case is interpreters for languages that must have a
well-understood low-level behavior. We include a formalization of
bounded-length strings which are used for the identifiers of our
language. Bounded-length identifiers are useful in some applications,
for example the <a href="https://www.isa-afp.org/entries/Differential_Dynamic_Logic.html">Differential_Dynamic_Logic</a> article,
where a Euclidean space indexed by identifiers demands that identifiers
are finitely many.
[Generalized_Counting_Sort]
title = An Efficient Generalization of Counting Sort for Large, possibly Infinite Key Ranges
author = Pasquale Noce <mailto:pasquale.noce.lavoro@gmail.com>
topic = Computer science/Algorithms, Computer science/Functional programming
date = 2019-12-04
notify = pasquale.noce.lavoro@gmail.com
abstract =
Counting sort is a well-known algorithm that sorts objects of any kind
mapped to integer keys, or else to keys in one-to-one correspondence
with some subset of the integers (e.g. alphabet letters). However, it
is suitable for direct use, viz. not just as a subroutine of another
sorting algorithm (e.g. radix sort), only if the key range is not
significantly larger than the number of the objects to be sorted.
This paper describes a tail-recursive generalization of counting sort
making use of a bounded number of counters, suitable for direct use in
case of a large, or even infinite key range of any kind, subject to
the only constraint of being a subset of an arbitrary linear order.
After performing a pen-and-paper analysis of how such algorithm has to
be designed to maximize its efficiency, this paper formalizes the
resulting generalized counting sort (GCsort) algorithm and then
formally proves its correctness properties, namely that (a) the
counters' number is maximized never exceeding the fixed upper
bound, (b) objects are conserved, (c) objects get sorted, and (d) the
algorithm is stable.
[Poincare_Bendixson]
title = The Poincaré-Bendixson Theorem
author = Fabian Immler <http://home.in.tum.de/~immler/>, Yong Kiam Tan <https://www.cs.cmu.edu/~yongkiat/>
topic = Mathematics/Analysis
date = 2019-12-18
notify = fimmler@cs.cmu.edu, yongkiat@cs.cmu.edu
abstract =
The Poincaré-Bendixson theorem is a classical result in the study of
(continuous) dynamical systems. Colloquially, it restricts the
possible behaviors of planar dynamical systems: such systems cannot be
chaotic. In practice, it is a useful tool for proving the existence of
(limiting) periodic behavior in planar systems. The theorem is an
interesting and challenging benchmark for formalized mathematics
because proofs in the literature rely on geometric sketches and only
hint at symmetric cases. It also requires a substantial background of
mathematical theories, e.g., the Jordan curve theorem, real analysis,
ordinary differential equations, and limiting (long-term) behavior of
dynamical systems.
[Isabelle_C]
title = Isabelle/C
author = Frédéric Tuong <https://www.lri.fr/~ftuong/>, Burkhart Wolff <https://www.lri.fr/~wolff/>
topic = Computer science/Programming languages/Language definitions, Computer science/Semantics, Tools
date = 2019-10-22
notify = tuong@users.gforge.inria.fr, wolff@lri.fr
abstract =
We present a framework for C code in C11 syntax deeply integrated into
the Isabelle/PIDE development environment. Our framework provides an
abstract interface for verification back-ends to be plugged-in
independently. Thus, various techniques such as deductive program
verification or white-box testing can be applied to the same source,
which is part of an integrated PIDE document model. Semantic back-ends
are free to choose the supported C fragment and its semantics. In
particular, they can differ on the chosen memory model or the
specification mechanism for framing conditions. Our framework supports
semantic annotations of C sources in the form of comments. Annotations
serve to locally control back-end settings, and can express the term
focus to which an annotation refers. Both the logical and the
syntactic context are available when semantic annotations are
evaluated. As a consequence, a formula in an annotation can refer both
to HOL or C variables. Our approach demonstrates the degree of
maturity and expressive power the Isabelle/PIDE sub-system has
achieved in recent years. Our integration technique employs Lex and
Yacc style grammars to ensure efficient deterministic parsing. This
is the core-module of Isabelle/C; the AFP package for Clean and
Clean_wrapper as well as AutoCorres and AutoCorres_wrapper (available
via git) are applications of this front-end.
[Zeta_3_Irrational]
title = The Irrationality of ζ(3)
author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
topic = Mathematics/Number theory
date = 2019-12-27
notify = manuel.eberl@tum.de
abstract =
<p>This article provides a formalisation of Beukers's
straightforward analytic proof that ζ(3) is irrational. This was first
proven by Apéry (which is why this result is also often called
‘Apéry's Theorem’) using a more algebraic approach. This
formalisation follows <a
href="http://people.math.sc.edu/filaseta/gradcourses/Math785/Math785Notes4.pdf">Filaseta's
presentation</a> of Beukers's proof.</p>
[Hybrid_Logic]
title = Formalizing a Seligman-Style Tableau System for Hybrid Logic
author = Asta Halkjær From <https://people.compute.dtu.dk/ahfrom/>
topic = Logic/General logic/Modal logic
date = 2019-12-20
notify = ahfrom@dtu.dk
abstract =
This work is a formalization of soundness and completeness proofs
for a Seligman-style tableau system for hybrid logic. The completeness
result is obtained via a synthetic approach using maximally
consistent sets of tableau blocks. The formalization differs from
previous work in a few ways. First, to avoid the need to backtrack in
the construction of a tableau, the formalized system has no unnamed
initial segment, and therefore no Name rule. Second, I show that the
full Bridge rule is admissible in the system. Third, I start from rules
restricted to only extend the branch with new formulas, including only
witnessing diamonds that are not already witnessed, and show that
the unrestricted rules are admissible. Similarly, I start from simpler
versions of the @-rules and show that these are sufficient.
The GoTo rule is restricted using a notion of potential such that each
application consumes potential and potential is earned through applications of
the remaining rules. I show that if a branch can be closed then it can
be closed starting from a single unit. Finally, Nom is restricted by
a fixed set of allowed nominals. The resulting system should be terminating.
extra-history =
Change history:
[2020-06-03]: The fully restricted system has been shown complete by updating the synthetic completeness proof.
[Bicategory]
title = Bicategories
author = Eugene W. Stark <mailto:stark@cs.stonybrook.edu>
topic = Mathematics/Category theory
date = 2020-01-06
notify = stark@cs.stonybrook.edu
abstract =
<p>
Taking as a starting point the author's previous work on
developing aspects of category theory in Isabelle/HOL, this article
gives a compatible formalization of the notion of
"bicategory" and develops a framework within which formal
proofs of facts about bicategories can be given. The framework
includes a number of basic results, including the Coherence Theorem,
the Strictness Theorem, pseudofunctors and biequivalence, and facts
about internal equivalences and adjunctions in a bicategory. As a
driving application and demonstration of the utility of the framework,
it is used to give a formal proof of a theorem, due to Carboni,
Kasangian, and Street, that characterizes up to biequivalence the
bicategories of spans in a category with pullbacks. The formalization
effort necessitated the filling-in of many details that were not
evident from the brief presentation in the original paper, as well as
identifying a few minor corrections along the way.
</p><p>
Revisions made subsequent to the first version of this article added
additional material on pseudofunctors, pseudonatural transformations,
modifications, and equivalence of bicategories; the main thrust being
to give a proof that a pseudofunctor is a biequivalence if and only
if it can be extended to an equivalence of bicategories.
</p>
extra-history =
Change history:
[2020-02-15]:
Move ConcreteCategory.thy from Bicategory to Category3 and use it systematically.
Make other minor improvements throughout.
(revision a51840d36867)<br>
[2020-11-04]:
Added new material on equivalence of bicategories, with associated changes.
(revision 472cb2268826)<br>
[Subset_Boolean_Algebras]
title = A Hierarchy of Algebras for Boolean Subsets
author = Walter Guttmann <http://www.cosc.canterbury.ac.nz/walter.guttmann/>, Bernhard Möller <https://www.informatik.uni-augsburg.de/en/chairs/dbis/pmi/staff/moeller/>
topic = Mathematics/Algebra
date = 2020-01-31
notify = walter.guttmann@canterbury.ac.nz
abstract =
We present a collection of axiom systems for the construction of
Boolean subalgebras of larger overall algebras. The subalgebras are
defined as the range of a complement-like operation on a semilattice.
This technique has been used, for example, with the antidomain
operation, dynamic negation and Stone algebras. We present a common
ground for these constructions based on a new equational
axiomatisation of Boolean algebras.
[Goodstein_Lambda]
title = Implementing the Goodstein Function in &lambda;-Calculus
author = Bertram Felgenhauer <mailto:int-e@gmx.de>
topic = Logic/Rewriting
date = 2020-02-21
notify = int-e@gmx.de
abstract =
In this formalization, we develop an implementation of the Goodstein
function G in plain &lambda;-calculus, linked to a concise, self-contained
specification. The implementation works on a Church-encoded
representation of countable ordinals. The initial conversion to
hereditary base 2 is not covered, but the material is sufficient to
compute the particular value G(16), and easily extends to other fixed
arguments.
[VeriComp]
title = A Generic Framework for Verified Compilers
author = Martin Desharnais <https://martin.desharnais.me>
topic = Computer science/Programming languages/Compiling
date = 2020-02-10
notify = martin.desharnais@unibw.de
abstract =
This is a generic framework for formalizing compiler transformations.
It leverages Isabelle/HOL’s locales to abstract over concrete
languages and transformations. It states common definitions for
language semantics, program behaviours, forward and backward
simulations, and compilers. We provide generic operations, such as
simulation and compiler composition, and prove general (partial)
correctness theorems, resulting in reusable proof components.
[Hello_World]
title = Hello World
author = Cornelius Diekmann <http://net.in.tum.de/~diekmann>, Lars Hupel <https://www21.in.tum.de/~hupel/>
topic = Computer science/Functional programming
date = 2020-03-07
notify = diekmann@net.in.tum.de
abstract =
In this article, we present a formalization of the well-known
"Hello, World!" code, including a formal framework for
reasoning about IO. Our model is inspired by the handling of IO in
Haskell. We start by formalizing the 🌍 and embrace the IO monad
afterwards. Then we present a sample main :: IO (), followed by its
proof of correctness.
[WOOT_Strong_Eventual_Consistency]
title = Strong Eventual Consistency of the Collaborative Editing Framework WOOT
author = Emin Karayel <https://orcid.org/0000-0003-3290-5034>, Edgar Gonzàlez <mailto:edgargip@google.com>
topic = Computer science/Algorithms/Distributed
date = 2020-03-25
notify = eminkarayel@google.com, edgargip@google.com, me@eminkarayel.de
abstract =
Commutative Replicated Data Types (CRDTs) are a promising new class of
data structures for large-scale shared mutable content in applications
that only require eventual consistency. The WithOut Operational
Transforms (WOOT) framework is a CRDT for collaborative text editing
introduced by Oster et al. (CSCW 2006) for which the eventual
consistency property was verified only for a bounded model to date. We
contribute a formal proof for WOOTs strong eventual consistency.
[Furstenberg_Topology]
title = Furstenberg's topology and his proof of the infinitude of primes
author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
topic = Mathematics/Number theory
date = 2020-03-22
notify = manuel.eberl@tum.de
abstract =
<p>This article gives a formal version of Furstenberg's
topological proof of the infinitude of primes. He defines a topology
on the integers based on arithmetic progressions (or, equivalently,
residue classes). Using some fairly obvious properties of this
topology, the infinitude of primes is then easily obtained.</p>
<p>Apart from this, this topology is also fairly ‘nice’ in
general: it is second countable, metrizable, and perfect. All of these
(well-known) facts are formally proven, including an explicit metric
for the topology given by Zulfeqarr.</p>
[Saturation_Framework]
title = A Comprehensive Framework for Saturation Theorem Proving
author = Sophie Tourret <https://www.mpi-inf.mpg.de/departments/automation-of-logic/people/sophie-tourret/>
topic = Logic/General logic/Mechanization of proofs
date = 2020-04-09
notify = stourret@mpi-inf.mpg.de
abstract =
This Isabelle/HOL formalization is the companion of the technical
report “A comprehensive framework for saturation theorem proving”,
itself companion of the eponym IJCAR 2020 paper, written by Uwe
Waldmann, Sophie Tourret, Simon Robillard and Jasmin Blanchette. It
verifies a framework for formal refutational completeness proofs of
abstract provers that implement saturation calculi, such as ordered
resolution or superposition, and allows to model entire prover
architectures in such a way that the static refutational completeness
of a calculus immediately implies the dynamic refutational
completeness of a prover implementing the calculus using a variant of
the given clause loop. The technical report “A comprehensive
framework for saturation theorem proving” is available <a
href="http://matryoshka.gforge.inria.fr/pubs/satur_report.pdf">on
the Matryoshka website</a>. The names of the Isabelle lemmas and
theorems corresponding to the results in the report are indicated in
the margin of the report.
[Saturation_Framework_Extensions]
title = Extensions to the Comprehensive Framework for Saturation Theorem Proving
author = Jasmin Blanchette <https://www.cs.vu.nl/~jbe248/>, Sophie Tourret <https://www.mpi-inf.mpg.de/departments/automation-of-logic/people/sophie-tourret>
topic = Logic/General logic/Mechanization of proofs
date = 2020-08-25
notify = jasmin.blanchette@gmail.com
abstract =
This Isabelle/HOL formalization extends the AFP entry
<em>Saturation_Framework</em> with the following
contributions: <ul> <li>an application of the framework
to prove Bachmair and Ganzinger's resolution prover RP
refutationally complete, which was formalized in a more ad hoc fashion
by Schlichtkrull et al. in the AFP entry
<em>Ordered_Resultion_Prover</em>;</li>
<li>generalizations of various basic concepts formalized by
Schlichtkrull et al., which were needed to verify RP and could be
useful to formalize other calculi, such as superposition;</li>
<li>alternative proofs of fairness (and hence saturation and
ultimately refutational completeness) for the given clause procedures
GC and LGC, based on invariance.</li> </ul>
[MFODL_Monitor_Optimized]
title = Formalization of an Optimized Monitoring Algorithm for Metric First-Order Dynamic Logic with Aggregations
author = Thibault Dardinier<>, Lukas Heimes<>, Martin Raszyk <mailto:martin.raszyk@inf.ethz.ch>, Joshua Schneider <mailto:joshua.schneider@inf.ethz.ch>, Dmitriy Traytel <https://traytel.bitbucket.io>
topic = Computer science/Algorithms, Logic/General logic/Modal logic, Computer science/Automata and formal languages
date = 2020-04-09
notify = martin.raszyk@inf.ethz.ch, joshua.schneider@inf.ethz.ch, traytel@inf.ethz.ch
abstract =
A monitor is a runtime verification tool that solves the following
problem: Given a stream of time-stamped events and a policy formulated
in a specification language, decide whether the policy is satisfied at
every point in the stream. We verify the correctness of an executable
monitor for specifications given as formulas in metric first-order
dynamic logic (MFODL), which combines the features of metric
first-order temporal logic (MFOTL) and metric dynamic logic. Thus,
MFODL supports real-time constraints, first-order parameters, and
regular expressions. Additionally, the monitor supports aggregation
operations such as count and sum. This formalization, which is
described in a <a
href="http://people.inf.ethz.ch/trayteld/papers/ijcar20-verimonplus/verimonplus.pdf">
forthcoming paper at IJCAR 2020</a>, significantly extends <a
href="https://www.isa-afp.org/entries/MFOTL_Monitor.html">previous
work on a verified monitor</a> for MFOTL. Apart from the
addition of regular expressions and aggregations, we implemented <a
href="https://www.isa-afp.org/entries/Generic_Join.html">multi-way
joins</a> and a specialized sliding window algorithm to further
optimize the monitor.
[Sliding_Window_Algorithm]
title = Formalization of an Algorithm for Greedily Computing Associative Aggregations on Sliding Windows
author = Lukas Heimes<>, Dmitriy Traytel <https://traytel.bitbucket.io>, Joshua Schneider<>
topic = Computer science/Algorithms
date = 2020-04-10
notify = heimesl@student.ethz.ch, traytel@inf.ethz.ch, joshua.schneider@inf.ethz.ch
abstract =
Basin et al.'s <a
href="https://doi.org/10.1016/j.ipl.2014.09.009">sliding
window algorithm (SWA)</a> is an algorithm for combining the
elements of subsequences of a sequence with an associative operator.
It is greedy and minimizes the number of operator applications. We
formalize the algorithm and verify its functional correctness. We
extend the algorithm with additional operations and provide an
alternative interface to the slide operation that does not require the
entire input sequence.
[Lucas_Theorem]
title = Lucas's Theorem
author = Chelsea Edmonds <mailto:cle47@cam.ac.uk>
topic = Mathematics/Number theory
date = 2020-04-07
notify = cle47@cam.ac.uk
abstract =
This work presents a formalisation of a generating function proof for
Lucas's theorem. We first outline extensions to the existing
Formal Power Series (FPS) library, including an equivalence relation
for coefficients modulo <em>n</em>, an alternate binomial theorem statement,
and a formalised proof of the Freshman's dream (mod <em>p</em>) lemma.
The second part of the work presents the formal proof of Lucas's
Theorem. Working backwards, the formalisation first proves a well
known corollary of the theorem which is easier to formalise, and then
applies induction to prove the original theorem statement. The proof
of the corollary aims to provide a good example of a formalised
generating function equivalence proof using the FPS library. The final
theorem statement is intended to be integrated into the formalised
proof of Hilbert's 10th Problem.
[ADS_Functor]
title = Authenticated Data Structures As Functors
author = Andreas Lochbihler <http://www.andreas-lochbihler.de>, Ognjen Marić <mailto:ogi.afp@mynosefroze.com>
topic = Computer science/Data structures
date = 2020-04-16
notify = andreas.lochbihler@digitalasset.com, mail@andreas-lochbihler.de
abstract =
Authenticated data structures allow several systems to convince each
other that they are referring to the same data structure, even if each
of them knows only a part of the data structure. Using inclusion
proofs, knowledgeable systems can selectively share their knowledge
with other systems and the latter can verify the authenticity of what
is being shared. In this article, we show how to modularly define
authenticated data structures, their inclusion proofs, and operations
thereon as datatypes in Isabelle/HOL, using a shallow embedding.
Modularity allows us to construct complicated trees from reusable
building blocks, which we call Merkle functors. Merkle functors
include sums, products, and function spaces and are closed under
composition and least fixpoints. As a practical application, we model
the hierarchical transactions of <a
href="https://www.canton.io">Canton</a>, a
practical interoperability protocol for distributed ledgers, as
authenticated data structures. This is a first step towards
formalizing the Canton protocol and verifying its integrity and
security guarantees.
[Power_Sum_Polynomials]
title = Power Sum Polynomials
author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
topic = Mathematics/Algebra
date = 2020-04-24
notify = eberlm@in.tum.de
abstract =
<p>This article provides a formalisation of the symmetric
multivariate polynomials known as <em>power sum
polynomials</em>. These are of the form
p<sub>n</sub>(<em>X</em><sub>1</sub>,&hellip;,
<em>X</em><sub><em>k</em></sub>) =
<em>X</em><sub>1</sub><sup>n</sup>
+ &hellip; +
X<sub><em>k</em></sub><sup>n</sup>.
A formal proof of the Girard–Newton Theorem is also given. This
theorem relates the power sum polynomials to the elementary symmetric
polynomials s<sub><em>k</em></sub> in the form
of a recurrence relation
(-1)<sup><em>k</em></sup>
<em>k</em> s<sub><em>k</em></sub>
=
&sum;<sub>i&isinv;[0,<em>k</em>)</sub>
(-1)<sup>i</sup> s<sub>i</sub>
p<sub><em>k</em>-<em>i</em></sub>&thinsp;.</p>
<p>As an application, this is then used to solve a generalised
form of a puzzle given as an exercise in Dummit and Foote's
<em>Abstract Algebra</em>: For <em>k</em>
complex unknowns <em>x</em><sub>1</sub>,
&hellip;,
<em>x</em><sub><em>k</em></sub>,
define p<sub><em>j</em></sub> :=
<em>x</em><sub>1</sub><sup><em>j</em></sup>
+ &hellip; +
<em>x</em><sub><em>k</em></sub><sup><em>j</em></sup>.
Then for each vector <em>a</em> &isinv;
&#x2102;<sup><em>k</em></sup>, show that
there is exactly one solution to the system p<sub>1</sub>
= a<sub>1</sub>, &hellip;,
p<sub><em>k</em></sub> =
a<sub><em>k</em></sub> up to permutation of
the
<em>x</em><sub><em>i</em></sub>
and determine the value of
p<sub><em>i</em></sub> for
i&gt;k.</p>
+[Formal_Puiseux_Series]
+title = Formal Puiseux Series
+author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
+topic = Mathematics/Algebra
+date = 2021-02-17
+notify = eberlm@in.tum.de
+abstract =
+ <p>Formal Puiseux series are generalisations of formal power
+ series and formal Laurent series that also allow for fractional
+ exponents. They have the following general form: \[\sum_{i=N}^\infty
+ a_{i/d} X^{i/d}\] where <em>N</em> is an integer and
+ <em>d</em> is a positive integer.</p> <p>This
+ entry defines these series including their basic algebraic properties.
+ Furthermore, it proves the Newton–Puiseux Theorem, namely that the
+ Puiseux series over an algebraically closed field of characteristic 0
+ are also algebraically closed.</p>
+
[Gaussian_Integers]
title = Gaussian Integers
author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
topic = Mathematics/Number theory
date = 2020-04-24
notify = eberlm@in.tum.de
abstract =
<p>The Gaussian integers are the subring &#8484;[i] of the
complex numbers, i. e. the ring of all complex numbers with integral
real and imaginary part. This article provides a definition of this
ring as well as proofs of various basic properties, such as that they
form a Euclidean ring and a full classification of their primes. An
executable (albeit not very efficient) factorisation algorithm is also
provided.</p> <p>Lastly, this Gaussian integer
formalisation is used in two short applications:</p> <ol>
<li> The characterisation of all positive integers that can be
written as sums of two squares</li> <li> Euclid's
formula for primitive Pythagorean triples</li> </ol>
<p>While elementary proofs for both of these are already
available in the AFP, the theory of Gaussian integers provides more
concise proofs and a more high-level view.</p>
[Forcing]
title = Formalization of Forcing in Isabelle/ZF
author = Emmanuel Gunther <mailto:gunther@famaf.unc.edu.ar>, Miguel Pagano <https://cs.famaf.unc.edu.ar/~mpagano/>, Pedro Sánchez Terraf <https://cs.famaf.unc.edu.ar/~pedro/home_en>
topic = Logic/Set theory
date = 2020-05-06
notify = gunther@famaf.unc.edu.ar, pagano@famaf.unc.edu.ar, sterraf@famaf.unc.edu.ar
abstract =
We formalize the theory of forcing in the set theory framework of
Isabelle/ZF. Under the assumption of the existence of a countable
transitive model of ZFC, we construct a proper generic extension and
show that the latter also satisfies ZFC.
[Delta_System_Lemma]
title = Cofinality and the Delta System Lemma
author = Pedro Sánchez Terraf <https://cs.famaf.unc.edu.ar/~pedro/home_en.html>
topic = Mathematics/Combinatorics, Logic/Set theory
date = 2020-12-27
notify = sterraf@famaf.unc.edu.ar
abstract =
We formalize the basic results on cofinality of linearly ordered sets
and ordinals and Šanin’s Lemma for uncountable families of finite
sets. This last result is used to prove the countable chain condition
for Cohen posets. We work in the set theory framework of Isabelle/ZF,
using the Axiom of Choice as needed.
[Recursion-Addition]
title = Recursion Theorem in ZF
author = Georgy Dunaev <mailto:georgedunaev@gmail.com>
topic = Logic/Set theory
date = 2020-05-11
notify = georgedunaev@gmail.com
abstract =
This document contains a proof of the recursion theorem. This is a
mechanization of the proof of the recursion theorem from the text <i>Introduction to
Set Theory</i>, by Karel Hrbacek and Thomas Jech. This
implementation may be used as the basis for a model of Peano arithmetic in
ZF. While recursion and the natural numbers are already available in Isabelle/ZF, this clean development
is much easier to follow.
[LTL_Normal_Form]
title = An Efficient Normalisation Procedure for Linear Temporal Logic: Isabelle/HOL Formalisation
author = Salomon Sickert <mailto:s.sickert@tum.de>
topic = Computer science/Automata and formal languages, Logic/General logic/Temporal logic
date = 2020-05-08
notify = s.sickert@tum.de
abstract =
In the mid 80s, Lichtenstein, Pnueli, and Zuck proved a classical
theorem stating that every formula of Past LTL (the extension of LTL
with past operators) is equivalent to a formula of the form
$\bigwedge_{i=1}^n \mathbf{G}\mathbf{F} \varphi_i \vee
\mathbf{F}\mathbf{G} \psi_i$, where $\varphi_i$ and $\psi_i$ contain
only past operators. Some years later, Chang, Manna, and Pnueli built
on this result to derive a similar normal form for LTL. Both
normalisation procedures have a non-elementary worst-case blow-up, and
follow an involved path from formulas to counter-free automata to
star-free regular expressions and back to formulas. We improve on both
points. We present an executable formalisation of a direct and purely
syntactic normalisation procedure for LTL yielding a normal form,
comparable to the one by Chang, Manna, and Pnueli, that has only a
single exponential blow-up.
[Matrices_for_ODEs]
title = Matrices for ODEs
author = Jonathan Julian Huerta y Munive <mailto:jjhuertaymunive1@sheffield.ac.uk>
topic = Mathematics/Analysis, Mathematics/Algebra
date = 2020-04-19
notify = jonjulian23@gmail.com
abstract =
Our theories formalise various matrix properties that serve to
establish existence, uniqueness and characterisation of the solution
to affine systems of ordinary differential equations (ODEs). In
particular, we formalise the operator and maximum norm of matrices.
Then we use them to prove that square matrices form a Banach space,
and in this setting, we show an instance of Picard-Lindelöf’s
theorem for affine systems of ODEs. Finally, we use this formalisation
to verify three simple hybrid programs.
[Irrational_Series_Erdos_Straus]
title = Irrationality Criteria for Series by Erdős and Straus
author = Angeliki Koutsoukou-Argyraki <https://www.cl.cam.ac.uk/~ak2110/>, Wenda Li <https://www.cl.cam.ac.uk/~wl302/>
topic = Mathematics/Number theory, Mathematics/Analysis
date = 2020-05-12
notify = ak2110@cam.ac.uk, wl302@cam.ac.uk, liwenda1990@hotmail.com
abstract =
We formalise certain irrationality criteria for infinite series of the form:
\[\sum_{n=1}^\infty \frac{b_n}{\prod_{i=1}^n a_i} \]
where $\{b_n\}$ is a sequence of integers and $\{a_n\}$ a sequence of positive integers
with $a_n >1$ for all large n. The results are due to P. Erdős and E. G. Straus
<a href="https://projecteuclid.org/euclid.pjm/1102911140">[1]</a>.
In particular, we formalise Theorem 2.1, Corollary 2.10 and Theorem 3.1.
The latter is an application of Theorem 2.1 involving the prime numbers.
[Knuth_Bendix_Order]
title = A Formalization of Knuth–Bendix Orders
author = Christian Sternagel <mailto:c.sternagel@gmail.com>, René Thiemann <http://cl-informatik.uibk.ac.at/~thiemann/>
topic = Logic/Rewriting
date = 2020-05-13
notify = c.sternagel@gmail.com, rene.thiemann@uibk.ac.at
abstract =
We define a generalized version of Knuth&ndash;Bendix orders,
including subterm coefficient functions. For these orders we formalize
several properties such as strong normalization, the subterm property,
closure properties under substitutions and contexts, as well as ground
totality.
[Stateful_Protocol_Composition_and_Typing]
title = Stateful Protocol Composition and Typing
author = Andreas V. Hess <mailto:avhe@dtu.dk>, Sebastian Mödersheim <https://people.compute.dtu.dk/samo/>, Achim D. Brucker <https://www.brucker.ch/>
topic = Computer science/Security
date = 2020-04-08
notify = avhe@dtu.dk, andreasvhess@gmail.com, samo@dtu.dk, brucker@spamfence.net, andschl@dtu.dk
abstract =
We provide in this AFP entry several relative soundness results for
security protocols. In particular, we prove typing and
compositionality results for stateful protocols (i.e., protocols with
mutable state that may span several sessions), and that focuses on
reachability properties. Such results are useful to simplify protocol
verification by reducing it to a simpler problem: Typing results give
conditions under which it is safe to verify a protocol in a typed
model where only "well-typed" attacks can occur whereas
compositionality results allow us to verify a composed protocol by
only verifying the component protocols in isolation. The conditions on
the protocols under which the results hold are furthermore syntactic
in nature allowing for full automation. The foundation presented here
is used in another entry to provide fully automated and formalized
security proofs of stateful protocols.
[Automated_Stateful_Protocol_Verification]
title = Automated Stateful Protocol Verification
author = Andreas V. Hess <mailto:avhe@dtu.dk>, Sebastian Mödersheim <https://people.compute.dtu.dk/samo/>, Achim D. Brucker <https://www.brucker.ch/>, Anders Schlichtkrull <https://people.compute.dtu.dk/andschl/>
topic = Computer science/Security, Tools
date = 2020-04-08
notify = avhe@dtu.dk, andreasvhess@gmail.com, samo@dtu.dk, brucker@spamfence.net, andschl@dtu.dk
abstract =
In protocol verification we observe a wide spectrum from fully
automated methods to interactive theorem proving with proof assistants
like Isabelle/HOL. In this AFP entry, we present a fully-automated
approach for verifying stateful security protocols, i.e., protocols
with mutable state that may span several sessions. The approach
supports reachability goals like secrecy and authentication. We also
include a simple user-friendly transaction-based protocol
specification language that is embedded into Isabelle.
[Smith_Normal_Form]
title = A verified algorithm for computing the Smith normal form of a matrix
author = Jose Divasón <https://www.unirioja.es/cu/jodivaso/>
topic = Mathematics/Algebra, Computer science/Algorithms/Mathematical
date = 2020-05-23
notify = jose.divason@unirioja.es
abstract =
This work presents a formal proof in Isabelle/HOL of an algorithm to
transform a matrix into its Smith normal form, a canonical matrix
form, in a general setting: the algorithm is parameterized by
operations to prove its existence over elementary divisor rings, while
execution is guaranteed over Euclidean domains. We also provide a
formal proof on some results about the generality of this algorithm as
well as the uniqueness of the Smith normal form. Since Isabelle/HOL
does not feature dependent types, the development is carried out
switching conveniently between two different existing libraries: the
Hermite normal form (based on HOL Analysis) and the Jordan normal form
AFP entries. This permits to reuse results from both developments and
it is done by means of the lifting and transfer package together with
the use of local type definitions.
[Nash_Williams]
title = The Nash-Williams Partition Theorem
author = Lawrence C. Paulson <https://www.cl.cam.ac.uk/~lp15/>
topic = Mathematics/Combinatorics
date = 2020-05-16
notify = lp15@cam.ac.uk
abstract =
In 1965, Nash-Williams discovered a generalisation of the infinite
form of Ramsey's theorem. Where the latter concerns infinite sets
of n-element sets for some fixed n, the Nash-Williams theorem concerns
infinite sets of finite sets (or lists) subject to a “no initial
segment” condition. The present formalisation follows a
monograph on Ramsey Spaces by Todorčević.
[Safe_Distance]
title = A Formally Verified Checker of the Safe Distance Traffic Rules for Autonomous Vehicles
author = Albert Rizaldi <mailto:albert.rizaldi@ntu.edu.sg>, Fabian Immler <http://home.in.tum.de/~immler/>
topic = Computer science/Algorithms/Mathematical, Mathematics/Physics
date = 2020-06-01
notify = albert.rizaldi@ntu.edu.sg, fimmler@andrew.cmu.edu, martin.rau@tum.de
abstract =
The Vienna Convention on Road Traffic defines the safe distance
traffic rules informally. This could make autonomous vehicle liable
for safe-distance-related accidents because there is no clear
definition of how large a safe distance is. We provide a formally
proven prescriptive definition of a safe distance, and checkers which
can decide whether an autonomous vehicle is obeying the safe distance
rule. Not only does our work apply to the domain of law, but it also
serves as a specification for autonomous vehicle manufacturers and for
online verification of path planners.
[Relational_Paths]
title = Relational Characterisations of Paths
author = Walter Guttmann <http://www.cosc.canterbury.ac.nz/walter.guttmann/>, Peter Höfner <http://www.hoefner-online.de/>
topic = Mathematics/Graph theory
date = 2020-07-13
notify = walter.guttmann@canterbury.ac.nz, peter@hoefner-online.de
abstract =
Binary relations are one of the standard ways to encode, characterise
and reason about graphs. Relation algebras provide equational axioms
for a large fragment of the calculus of binary relations. Although
relations are standard tools in many areas of mathematics and
computing, researchers usually fall back to point-wise reasoning when
it comes to arguments about paths in a graph. We present a purely
algebraic way to specify different kinds of paths in Kleene relation
algebras, which are relation algebras equipped with an operation for
reflexive transitive closure. We study the relationship between paths
with a designated root vertex and paths without such a vertex. Since
we stay in first-order logic this development helps with mechanising
proofs. To demonstrate the applicability of the algebraic framework we
verify the correctness of three basic graph algorithms.
[Amicable_Numbers]
title = Amicable Numbers
author = Angeliki Koutsoukou-Argyraki <https://www.cl.cam.ac.uk/~ak2110/>
topic = Mathematics/Number theory
date = 2020-08-04
notify = ak2110@cam.ac.uk
abstract =
This is a formalisation of Amicable Numbers, involving some relevant
material including Euler's sigma function, some relevant
definitions, results and examples as well as rules such as
Th&#257;bit ibn Qurra's Rule, Euler's Rule, te
Riele's Rule and Borho's Rule with breeders.
[Ordinal_Partitions]
title = Ordinal Partitions
author = Lawrence C. Paulson <https://www.cl.cam.ac.uk/~lp15/>
topic = Mathematics/Combinatorics, Logic/Set theory
date = 2020-08-03
notify = lp15@cam.ac.uk
abstract =
The theory of partition relations concerns generalisations of
Ramsey's theorem. For any ordinal $\alpha$, write $\alpha \to
(\alpha, m)^2$ if for each function $f$ from unordered pairs of
elements of $\alpha$ into $\{0,1\}$, either there is a subset
$X\subseteq \alpha$ order-isomorphic to $\alpha$ such that
$f\{x,y\}=0$ for all $\{x,y\}\subseteq X$, or there is an $m$ element
set $Y\subseteq \alpha$ such that $f\{x,y\}=1$ for all
$\{x,y\}\subseteq Y$. (In both cases, with $\{x,y\}$ we require
$x\not=y$.) In particular, the infinite Ramsey theorem can be written
in this notation as $\omega \to (\omega, \omega)^2$, or if we
restrict $m$ to the positive integers as above, then $\omega \to
(\omega, m)^2$ for all $m$. This entry formalises Larson's proof
of $\omega^\omega \to (\omega^\omega, m)^2$ along with a similar proof
of a result due to Specker: $\omega^2 \to (\omega^2, m)^2$. Also
proved is a necessary result by Erdős and Milner:
$\omega^{1+\alpha\cdot n} \to (\omega^{1+\alpha}, 2^n)^2$.
[Relational_Disjoint_Set_Forests]
title = Relational Disjoint-Set Forests
author = Walter Guttmann <http://www.cosc.canterbury.ac.nz/walter.guttmann/>
topic = Computer science/Data structures
date = 2020-08-26
notify = walter.guttmann@canterbury.ac.nz
abstract =
We give a simple relation-algebraic semantics of read and write
operations on associative arrays. The array operations seamlessly
integrate with assignments in the Hoare-logic library. Using relation
algebras and Kleene algebras we verify the correctness of an
array-based implementation of disjoint-set forests with a naive union
operation and a find operation with path compression.
[PAC_Checker]
title = Practical Algebraic Calculus Checker
author = Mathias Fleury <http://fmv.jku.at/fleury>, Daniela Kaufmann <http://fmv.jku.at/kaufmann>
topic = Computer science/Algorithms
date = 2020-08-31
notify = mathias.fleury@jku.at
abstract =
Generating and checking proof certificates is important to increase
the trust in automated reasoning tools. In recent years formal
verification using computer algebra became more important and is
heavily used in automated circuit verification. An existing proof
format which covers algebraic reasoning and allows efficient proof
checking is the practical algebraic calculus (PAC). In this
development, we present the verified checker Pastèque that is obtained
by synthesis via the Refinement Framework. This is the formalization
going with our FMCAD'20 tool presentation.
[BirdKMP]
title = Putting the `K' into Bird's derivation of Knuth-Morris-Pratt string matching
author = Peter Gammie <http://peteg.org>
topic = Computer science/Functional programming
date = 2020-08-25
notify = peteg42@gmail.com
abstract =
Richard Bird and collaborators have proposed a derivation of an
intricate cyclic program that implements the Morris-Pratt string
matching algorithm. Here we provide a proof of total correctness for
Bird's derivation and complete it by adding Knuth's
optimisation.
[Extended_Finite_State_Machines]
title = A Formal Model of Extended Finite State Machines
author = Michael Foster <mailto:jmafoster1@sheffield.ac.uk>, Achim D. Brucker <mailto:a.brucker@exeter.ac.uk>, Ramsay G. Taylor <mailto:r.g.taylor@sheffield.ac.uk>, John Derrick <mailto:j.derrick@sheffield.ac.uk>
topic = Computer science/Automata and formal languages
date = 2020-09-07
notify = jmafoster1@sheffield.ac.uk, adbrucker@0x5f.org
abstract =
In this AFP entry, we provide a formalisation of extended finite state
machines (EFSMs) where models are represented as finite sets of
transitions between states. EFSMs execute traces to produce observable
outputs. We also define various simulation and equality metrics for
EFSMs in terms of traces and prove their strengths in relation to each
other. Another key contribution is a framework of function definitions
such that LTL properties can be phrased over EFSMs. Finally, we
provide a simple example case study in the form of a drinks machine.
[Extended_Finite_State_Machine_Inference]
title = Inference of Extended Finite State Machines
author = Michael Foster <mailto:jmafoster1@sheffield.ac.uk>, Achim D. Brucker <mailto:a.brucker@exeter.ac.uk>, Ramsay G. Taylor <mailto:r.g.taylor@sheffield.ac.uk>, John Derrick <mailto:j.derrick@sheffield.ac.uk>
topic = Computer science/Automata and formal languages
date = 2020-09-07
notify = jmafoster1@sheffield.ac.uk, adbrucker@0x5f.org
abstract =
In this AFP entry, we provide a formal implementation of a
state-merging technique to infer extended finite state machines
(EFSMs), complete with output and update functions, from black-box
traces. In particular, we define the subsumption in context relation
as a means of determining whether one transition is able to account
for the behaviour of another. Building on this, we define the direct
subsumption relation, which lifts the subsumption in context relation
to EFSM level such that we can use it to determine whether it is safe
to merge a given pair of transitions. Key proofs include the
conditions necessary for subsumption to occur and that subsumption
and direct subsumption are preorder relations. We also provide a
number of different heuristics which can be used to abstract away
concrete values into registers so that more states and transitions can
be merged and provide proofs of the various conditions which must hold
for these abstractions to subsume their ungeneralised counterparts. A
Code Generator setup to create executable Scala code is also defined.
[Physical_Quantities]
title = A Sound Type System for Physical Quantities, Units, and Measurements
author = Simon Foster <https://www-users.cs.york.ac.uk/~simonf/>, Burkhart Wolff <https://www.lri.fr/~wolff/>
topic = Mathematics/Physics, Computer science/Programming languages/Type systems
date = 2020-10-20
notify = simon.foster@york.ac.uk, wolff@lri.fr
abstract =
The present Isabelle theory builds a formal model for both the
International System of Quantities (ISQ) and the International System
of Units (SI), which are both fundamental for physics and engineering.
Both the ISQ and the SI are deeply integrated into Isabelle's
type system. Quantities are parameterised by dimension types, which
correspond to base vectors, and thus only quantities of the same
dimension can be equated. Since the underlying "algebra of
quantities" induces congruences on quantity and SI types,
specific tactic support is developed to capture these. Our
construction is validated by a test-set of known equivalences between
both quantities and SI units. Moreover, the presented theory can be
used for type-safe conversions between the SI system and others, like
the British Imperial System (BIS).
[Shadow_DOM]
title = A Formal Model of the Document Object Model with Shadow Roots
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 = 2020-09-28
notify = adbrucker@0x5f.org, mail@michael-herzberg.de
abstract =
In this AFP entry, we extend our formalization of the core DOM with
Shadow Roots. Shadow roots are a recent proposal of the web community
to support a component-based development approach for client-side web
applications. Shadow roots are a significant extension to the DOM
standard and, as web standards are condemned to be backward
compatible, such extensions often result in complex specification that
may contain unwanted subtleties that can be detected by a
formalization. Our Isabelle/HOL formalization is, in the sense of
object-orientation, an extension of our formalization of the core DOM
and enjoys the same basic properties, i.e., it is extensible, i.e.,
can be extended without the need of re-proving already proven
properties and executable, i.e., we can generate executable code from
our specification. We exploit the executability to show that our
formalization complies to the official standard of the W3C,
respectively, the WHATWG.
[DOM_Components]
title = A Formalization of Web Components
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 = 2020-09-28
notify = adbrucker@0x5f.org, mail@michael-herzberg.de
abstract =
While the DOM with shadow trees provide the technical basis for
defining web components, the DOM standard neither defines the concept
of web components nor specifies the safety properties that web
components should guarantee. Consequently, the standard also does not
discuss how or even if the methods for modifying the DOM respect
component boundaries. In AFP entry, we present a formally verified
model of web components and define safety properties which ensure that
different web components can only interact with each other using
well-defined interfaces. Moreover, our verification of the application
programming interface (API) of the DOM revealed numerous invariants
that implementations of the DOM API need to preserve to ensure the
integrity of components.
[Interpreter_Optimizations]
title = Inline Caching and Unboxing Optimization for Interpreters
author = Martin Desharnais <https://martin.desharnais.me>
topic = Computer science/Programming languages/Misc
date = 2020-12-07
notify = martin.desharnais@unibw.de
abstract =
This Isabelle/HOL formalization builds on the
<em>VeriComp</em> entry of the <em>Archive of Formal
Proofs</em> to provide the following contributions: <ul>
<li>an operational semantics for a realistic virtual machine
(Std) for dynamically typed programming languages;</li>
<li>the formalization of an inline caching optimization (Inca),
a proof of bisimulation with (Std), and a compilation
function;</li> <li>the formalization of an unboxing
optimization (Ubx), a proof of bisimulation with (Inca), and a simple
compilation function.</li> </ul> This formalization was
described in the CPP 2021 paper <em>Towards Efficient and
Verified Virtual Machines for Dynamic Languages</em>
[Isabelle_Marries_Dirac]
title = Isabelle Marries Dirac: a Library for Quantum Computation and Quantum Information
author = Anthony Bordg <mailto:apdb3@cam.ac.uk>, Hanna Lachnitt<mailto:lachnitt@stanford.edu>, Yijun He<mailto:yh403@cam.ac.uk>
topic = Computer science/Algorithms/Quantum computing, Mathematics/Physics/Quantum information
date = 2020-11-22
notify = apdb3@cam.ac.uk, lachnitt@stanford.edu
abstract =
This work is an effort to formalise some quantum algorithms and
results in quantum information theory. Formal methods being critical
for the safety and security of algorithms and protocols, we foresee
their widespread use for quantum computing in the future. We have
developed a large library for quantum computing in Isabelle based on a
matrix representation for quantum circuits, successfully formalising
the no-cloning theorem, quantum teleportation, Deutsch's
algorithm, the Deutsch-Jozsa algorithm and the quantum Prisoner's
Dilemma.
[Finite-Map-Extras]
title = Finite Map Extras
author = Javier Díaz <mailto:javier.diaz.manzi@gmail.com>
topic = Computer science/Data structures
date = 2020-10-12
notify = javier.diaz.manzi@gmail.com
abstract =
This entry includes useful syntactic sugar, new operators and functions, and
their associated lemmas for finite maps which currently are not
present in the standard Finite_Map theory.
[Relational_Minimum_Spanning_Trees]
title = Relational Minimum Spanning Tree Algorithms
author = Walter Guttmann <http://www.cosc.canterbury.ac.nz/walter.guttmann/>, Nicolas Robinson-O'Brien<>
topic = Computer science/Algorithms/Graph
date = 2020-12-08
notify = walter.guttmann@canterbury.ac.nz
abstract =
We verify the correctness of Prim's, Kruskal's and
Borůvka's minimum spanning tree algorithms based on algebras for
aggregation and minimisation.
[Topological_Semantics]
title = Topological semantics for paraconsistent and paracomplete logics
author = David Fuenmayor <mailto:davfuenmayor@gmail.com>
topic = Logic/General logic
date = 2020-12-17
notify = davfuenmayor@gmail.com
abstract =
We introduce a generalized topological semantics for paraconsistent
and paracomplete logics by drawing upon early works on topological
Boolean algebras (cf. works by Kuratowski, Zarycki, McKinsey &
Tarski, etc.). In particular, this work exemplarily illustrates the
shallow semantical embeddings approach (<a
href="http://dx.doi.org/10.1007/s11787-012-0052-y">SSE</a>)
employing the proof assistant Isabelle/HOL. By means of the SSE
technique we can effectively harness theorem provers, model finders
and 'hammers' for reasoning with quantified non-classical
logics.
[CSP_RefTK]
title = The HOL-CSP Refinement Toolkit
author = Safouan Taha <mailto:safouan.taha@lri.fr>, Burkhart Wolff <https://www.lri.fr/~wolff/>, Lina Ye <mailto:lina.ye@lri.fr>
topic = Computer science/Concurrency/Process calculi, Computer science/Semantics
date = 2020-11-19
notify = wolff@lri.fr
abstract =
We use a formal development for CSP, called HOL-CSP2.0, to analyse a
family of refinement notions, comprising classic and new ones. This
analysis enables to derive a number of properties that allow to deepen
the understanding of these notions, in particular with respect to
specification decomposition principles for the case of infinite sets
of events. The established relations between the refinement relations
help to clarify some obscure points in the CSP literature, but also
provide a weapon for shorter refinement proofs. Furthermore, we
provide a framework for state-normalisation allowing to formally
reason on parameterised process architectures. As a result, we have a
modern environment for formal proofs of concurrent systems that allow
for the combination of general infinite processes with locally finite
ones in a logically safe way. We demonstrate these
verification-techniques for classical, generalised examples: The
CopyBuffer for arbitrary data and the Dijkstra's Dining
Philosopher Problem of arbitrary size.
[Hood_Melville_Queue]
title = Hood-Melville Queue
author = Alejandro Gómez-Londoño<mailto:alejandro.gomez@chalmers.se>
topic = Computer science/Data structures
date = 2021-01-18
notify = nipkow@in.tum.de
abstract =
This is a verified implementation of a constant time queue. The
original design is due to <a
href="https://doi.org/10.1016/0020-0190(81)90030-2">Hood
and Melville</a>. This formalization follows the presentation in
<em>Purely Functional Data Structures</em>by Okasaki.
[JinjaDCI]
title = JinjaDCI: a Java semantics with dynamic class initialization
author = Susannah Mansky <mailto:sjohnsn2@illinois.edu>
topic = Computer science/Programming languages/Language definitions
date = 2021-01-11
notify = sjohnsn2@illinois.edu, susannahej@gmail.com
abstract =
We extend Jinja to include static fields, methods, and instructions,
and dynamic class initialization, based on the Java SE 8
specification. This includes extension of definitions and proofs. This
work is partially described in Mansky and Gunter's paper at CPP
2019 and Mansky's doctoral thesis (UIUC, 2020).
[Blue_Eyes]
title = Solution to the xkcd Blue Eyes puzzle
author = Jakub Kądziołka <mailto:kuba@kadziolka.net>
topic = Logic/General logic/Logics of knowledge and belief
date = 2021-01-30
notify = kuba@kadziolka.net
-abstract =
- In a <a href="https://xkcd.com/blue_eyes.html">puzzle published by
+abstract =
+ In a <a href="https://xkcd.com/blue_eyes.html">puzzle published by
Randall Munroe</a>, perfect logicians forbidden
from communicating are stranded on an island, and may only leave once
they have figured out their own eye color. We present a method of
modeling the behavior of perfect logicians and formalize a solution of
the puzzle.
[Laws_of_Large_Numbers]
title = The Laws of Large Numbers
author = Manuel Eberl <https://www21.in.tum.de/~eberlm>
topic = Mathematics/Probability theory
date = 2021-02-10
notify = eberlm@in.tum.de
abstract =
<p>The Law of Large Numbers states that, informally, if one
performs a random experiment $X$ many times and takes the average of
the results, that average will be very close to the expected value
$E[X]$.</p> <p> More formally, let
$(X_i)_{i\in\mathbb{N}}$ be a sequence of independently identically
distributed random variables whose expected value $E[X_1]$ exists.
Denote the running average of $X_1, \ldots, X_n$ as $\overline{X}_n$.
Then:</p> <ul> <li>The Weak Law of Large Numbers
states that $\overline{X}_{n} \longrightarrow E[X_1]$ in probability
for $n\to\infty$, i.e. $\mathcal{P}(|\overline{X}_{n} - E[X_1]| >
\varepsilon) \longrightarrow 0$ as $n\to\infty$ for any $\varepsilon
> 0$.</li> <li>The Strong Law of Large Numbers states
that $\overline{X}_{n} \longrightarrow E[X_1]$ almost surely for
$n\to\infty$, i.e. $\mathcal{P}(\overline{X}_{n} \longrightarrow
E[X_1]) = 1$.</li> </ul> <p>In this entry, I
formally prove the strong law and from it the weak law. The approach
used for the proof of the strong law is a particularly quick and slick
one based on ergodic theory, which was formalised by Gouëzel in
another AFP entry.</p>
+
+[BTree]
+title = A Verified Imperative Implementation of B-Trees
+author = Niels Mündler <mailto:n.muendler@tum.de>
+topic = Computer science/Data structures
+date = 2021-02-24
+notify = n.muendler@tum.de
+abstract =
+ In this work, we use the interactive theorem prover Isabelle/HOL to
+ verify an imperative implementation of the classical B-tree data
+ structure invented by Bayer and McCreight [ACM 1970]. The
+ implementation supports set membership and insertion queries with
+ efficient binary search for intra-node navigation. This is
+ accomplished by first specifying the structure abstractly in the
+ functional modeling language HOL and proving functional correctness.
+ Using manual refinement, we derive an imperative implementation in
+ Imperative/HOL. We show the validity of this refinement using the
+ separation logic utilities from the <a
+ href="https://www.isa-afp.org/entries/Refine_Imperative_HOL.html">
+ Isabelle Refinement Framework </a> . The code can be exported to
+ the programming languages SML and Scala. We examine the runtime of all
+ operations indirectly by reproducing results of the logarithmic
+ relationship between height and the number of nodes. The results are
+ discussed in greater detail in the corresponding <a
+ href="https://mediatum.ub.tum.de/1596550">Bachelor's
+ Thesis</a>.
diff --git a/metadata/release-dates b/metadata/release-dates
--- a/metadata/release-dates
+++ b/metadata/release-dates
@@ -1,22 +1,23 @@
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
2020 = 2020-04-16
+2021 = 2021-02-21
diff --git a/metadata/releases b/metadata/releases
--- a/metadata/releases
+++ b/metadata/releases
@@ -1,4440 +1,5080 @@
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-Abortable_Linearizable_Modules-2020-04-18.tar.gz
+afp-Abortable_Linearizable_Modules-2021-02-23.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-Abs_Int_ITP2012-2020-04-18.tar.gz
+afp-Abs_Int_ITP2012-2021-02-23.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_Completeness-2020-04-18.tar.gz
+afp-Abstract_Completeness-2021-02-23.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-Hoare-Logics-2020-04-18.tar.gz
+afp-Abstract-Hoare-Logics-2021-02-23.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-Rewriting-2020-04-18.tar.gz
+afp-Abstract-Rewriting-2021-02-23.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-Abstract_Soundness-2020-04-18.tar.gz
+afp-Abstract_Soundness-2021-02-23.tar.gz
afp-Adaptive_State_Counting-2019-08-19.tar.gz
afp-Adaptive_State_Counting-2020-04-18.tar.gz
+afp-Adaptive_State_Counting-2021-02-23.tar.gz
+afp-ADS_Functor-2020-04-27.tar.gz
+afp-ADS_Functor-2021-02-23.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-Affine_Arithmetic-2020-04-18.tar.gz
+afp-Affine_Arithmetic-2021-02-23.tar.gz
afp-Aggregation_Algebras-2018-09-16.tar.gz
afp-Aggregation_Algebras-2019-06-11.tar.gz
afp-Aggregation_Algebras-2020-04-18.tar.gz
+afp-Aggregation_Algebras-2021-02-23.tar.gz
+afp-AI_Planning_Languages_Semantics-2020-10-30.tar.gz
+afp-AI_Planning_Languages_Semantics-2021-02-23.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-Akra_Bazzi-2020-04-18.tar.gz
+afp-Akra_Bazzi-2021-02-23.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_Numbers-2020-04-18.tar.gz
+afp-Algebraic_Numbers-2021-02-23.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-Algebraic_VCs-2020-04-18.tar.gz
+afp-Algebraic_VCs-2021-02-23.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-Allen_Calculus-2019-06-28.tar.gz
afp-Allen_Calculus-2020-04-18.tar.gz
+afp-Allen_Calculus-2021-02-23.tar.gz
+afp-Amicable_Numbers-2020-08-15.tar.gz
+afp-Amicable_Numbers-2021-02-23.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-Amortized_Complexity-2020-04-18.tar.gz
+afp-Amortized_Complexity-2021-02-23.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-AnselmGod-2020-04-18.tar.gz
+afp-AnselmGod-2021-02-23.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-AODV-2020-04-18.tar.gz
+afp-AODV-2021-02-23.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-Applicative_Lifting-2020-04-18.tar.gz
+afp-Applicative_Lifting-2021-02-23.tar.gz
afp-Approximation_Algorithms-2020-01-16.tar.gz
afp-Approximation_Algorithms-2020-04-18.tar.gz
+afp-Approximation_Algorithms-2021-02-23.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-Architectural_Design_Patterns-2020-04-18.tar.gz
+afp-Architectural_Design_Patterns-2021-02-23.tar.gz
afp-Aristotles_Assertoric_Syllogistic-2019-10-17.tar.gz
afp-Aristotles_Assertoric_Syllogistic-2020-04-18.tar.gz
+afp-Aristotles_Assertoric_Syllogistic-2021-02-23.tar.gz
afp-Arith_Prog_Rel_Primes-2020-02-10.tar.gz
afp-Arith_Prog_Rel_Primes-2020-04-18.tar.gz
+afp-Arith_Prog_Rel_Primes-2021-02-23.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-ArrowImpossibilityGS-2020-04-18.tar.gz
+afp-ArrowImpossibilityGS-2021-02-23.tar.gz
+afp-Attack_Trees-2021-02-23.tar.gz
afp-Auto2_HOL-2018-11-29.tar.gz
afp-Auto2_HOL-2019-06-11.tar.gz
afp-Auto2_HOL-2020-04-18.tar.gz
+afp-Auto2_HOL-2021-02-23.tar.gz
afp-Auto2_Imperative_HOL-2019-01-22.tar.gz
afp-Auto2_Imperative_HOL-2019-06-11.tar.gz
afp-Auto2_Imperative_HOL-2020-04-18.tar.gz
+afp-Auto2_Imperative_HOL-2021-02-23.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-AutoFocus-Stream-2020-04-18.tar.gz
+afp-AutoFocus-Stream-2021-02-23.tar.gz
+afp-Automated_Stateful_Protocol_Verification-2020-05-20.tar.gz
+afp-Automated_Stateful_Protocol_Verification-2021-02-23.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-Automatic_Refinement-2020-04-18.tar.gz
+afp-Automatic_Refinement-2021-02-23.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-AVL-Trees-2020-04-18.tar.gz
+afp-AVL-Trees-2021-02-23.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-AWN-2020-04-18.tar.gz
+afp-AWN-2021-02-23.tar.gz
afp-AxiomaticCategoryTheory-2018-05-23.tar.gz
afp-AxiomaticCategoryTheory-2018-08-16.tar.gz
afp-AxiomaticCategoryTheory-2019-06-11.tar.gz
afp-AxiomaticCategoryTheory-2020-04-18.tar.gz
+afp-AxiomaticCategoryTheory-2021-02-23.tar.gz
+afp-Banach_Steinhaus-2020-05-06.tar.gz
+afp-Banach_Steinhaus-2020-05-11.tar.gz
+afp-Banach_Steinhaus-2021-02-23.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-BDD-2020-04-18.tar.gz
+afp-BDD-2021-02-23.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-Bell_Numbers_Spivey-2020-04-18.tar.gz
+afp-Bell_Numbers_Spivey-2021-02-23.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-Berlekamp_Zassenhaus-2020-04-18.tar.gz
+afp-Berlekamp_Zassenhaus-2021-02-23.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-Bernoulli-2020-04-18.tar.gz
+afp-Bernoulli-2021-02-23.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-Bertrands_Postulate-2020-04-18.tar.gz
+afp-Bertrands_Postulate-2021-02-23.tar.gz
afp-Bicategory-2020-01-09.tar.gz
afp-Bicategory-2020-04-18.tar.gz
+afp-Bicategory-2021-02-23.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-BinarySearchTree-2020-04-18.tar.gz
+afp-BinarySearchTree-2021-02-23.tar.gz
afp-Binding_Syntax_Theory-2019-04-08.tar.gz
afp-Binding_Syntax_Theory-2019-06-11.tar.gz
afp-Binding_Syntax_Theory-2020-04-18.tar.gz
+afp-Binding_Syntax_Theory-2021-02-23.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-Heaps-2020-04-18.tar.gz
+afp-Binomial-Heaps-2021-02-23.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-Binomial-Queues-2020-04-18.tar.gz
+afp-Binomial-Queues-2021-02-23.tar.gz
+afp-BirdKMP-2020-09-02.tar.gz
+afp-BirdKMP-2021-02-23.tar.gz
+afp-Blue_Eyes-2021-02-01.tar.gz
+afp-Blue_Eyes-2021-02-23.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_CC-2020-04-18.tar.gz
+afp-BNF_CC-2021-02-23.tar.gz
afp-BNF_Operations-2018-08-16.tar.gz
afp-BNF_Operations-2019-06-11.tar.gz
afp-BNF_Operations-2020-04-18.tar.gz
+afp-BNF_Operations-2021-02-23.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-Bondy-2020-04-18.tar.gz
+afp-Bondy-2021-02-23.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-Boolean_Expression_Checkers-2020-04-18.tar.gz
+afp-Boolean_Expression_Checkers-2021-02-23.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-Bounded_Deducibility_Security-2020-04-18.tar.gz
+afp-Bounded_Deducibility_Security-2021-02-23.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-Buchi_Complementation-2020-04-18.tar.gz
+afp-Buchi_Complementation-2021-02-23.tar.gz
afp-Budan_Fourier-2018-09-04.tar.gz
afp-Budan_Fourier-2019-06-11.tar.gz
afp-Budan_Fourier-2020-04-18.tar.gz
+afp-Budan_Fourier-2021-02-23.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-Buffons_Needle-2020-04-18.tar.gz
+afp-Buffons_Needle-2021-02-23.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-Buildings-2020-04-18.tar.gz
+afp-Buildings-2021-02-23.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-BytecodeLogicJmlTypes-2020-04-18.tar.gz
+afp-BytecodeLogicJmlTypes-2021-02-23.tar.gz
afp-C2KA_DistributedSystems-2019-08-06.tar.gz
afp-C2KA_DistributedSystems-2020-04-18.tar.gz
+afp-C2KA_DistributedSystems-2021-02-23.tar.gz
afp-CakeML-2018-08-16.tar.gz
afp-CakeML-2019-06-11.tar.gz
afp-CakeML-2020-04-18.tar.gz
+afp-CakeML-2021-02-23.tar.gz
afp-CakeML_Codegen-2019-07-11.tar.gz
afp-CakeML_Codegen-2020-04-18.tar.gz
+afp-CakeML_Codegen-2021-02-23.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-Call_Arity-2020-04-18.tar.gz
+afp-Call_Arity-2021-02-23.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_Equiv_Relations-2020-04-18.tar.gz
+afp-Card_Equiv_Relations-2021-02-23.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_Multisets-2020-04-18.tar.gz
+afp-Card_Multisets-2021-02-23.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_Number_Partitions-2020-04-18.tar.gz
+afp-Card_Number_Partitions-2021-02-23.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-Card_Partitions-2020-04-18.tar.gz
+afp-Card_Partitions-2021-02-23.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-Cartan_FP-2020-04-18.tar.gz
+afp-Cartan_FP-2021-02-23.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-Case_Labeling-2020-04-18.tar.gz
+afp-Case_Labeling-2021-02-23.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-Catalan_Numbers-2020-04-18.tar.gz
+afp-Catalan_Numbers-2021-02-23.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-Category-2020-04-18.tar.gz
+afp-Category-2021-02-23.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-Category2-2020-04-18.tar.gz
+afp-Category2-2021-02-23.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-Category3-2020-04-18.tar.gz
+afp-Category3-2021-02-23.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-Cauchy-2020-04-18.tar.gz
+afp-Cauchy-2021-02-23.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_Automata-2020-04-18.tar.gz
+afp-CAVA_Automata-2021-02-23.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-CAVA_LTL_Modelchecker-2020-04-18.tar.gz
+afp-CAVA_LTL_Modelchecker-2021-02-23.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-Cayley_Hamilton-2020-04-18.tar.gz
+afp-Cayley_Hamilton-2021-02-23.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-CCS-2020-04-18.tar.gz
+afp-CCS-2021-02-23.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-Certification_Monads-2020-04-18.tar.gz
+afp-Certification_Monads-2021-02-23.tar.gz
+afp-Chandy_Lamport-2020-08-04.tar.gz
+afp-Chandy_Lamport-2021-02-23.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-Chord_Segments-2020-04-18.tar.gz
+afp-Chord_Segments-2021-02-23.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-Circus-2020-04-18.tar.gz
+afp-Circus-2021-02-23.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-CISC-Kernel-2020-04-18.tar.gz
+afp-CISC-Kernel-2021-02-23.tar.gz
afp-Clean-2019-10-16.tar.gz
afp-Clean-2020-04-18.tar.gz
+afp-Clean-2021-02-23.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-ClockSynchInst-2020-04-18.tar.gz
+afp-ClockSynchInst-2021-02-23.tar.gz
afp-Closest_Pair_Points-2020-01-14.tar.gz
afp-Closest_Pair_Points-2020-04-18.tar.gz
+afp-Closest_Pair_Points-2021-02-23.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-CofGroups-2020-04-18.tar.gz
+afp-CofGroups-2021-02-23.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-2020-04-18.tar.gz
+afp-Coinductive-2021-02-23.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-Coinductive_Languages-2020-04-18.tar.gz
+afp-Coinductive_Languages-2021-02-23.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-Collections-2020-04-18.tar.gz
+afp-Collections-2021-02-23.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-Comparison_Sort_Lower_Bound-2020-04-18.tar.gz
+afp-Comparison_Sort_Lower_Bound-2021-02-23.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-Compiling-Exceptions-Correctly-2020-04-18.tar.gz
+afp-Compiling-Exceptions-Correctly-2021-02-23.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-Completeness-2020-04-18.tar.gz
+afp-Completeness-2021-02-23.tar.gz
afp-Complete_Non_Orders-2019-06-28.tar.gz
afp-Complete_Non_Orders-2020-04-18.tar.gz
+afp-Complete_Non_Orders-2021-02-23.tar.gz
afp-Complex_Geometry-2020-01-17.tar.gz
afp-Complex_Geometry-2020-04-18.tar.gz
+afp-Complex_Geometry-2021-02-23.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-Complx-2020-04-18.tar.gz
+afp-Complx-2021-02-23.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-ComponentDependencies-2020-04-18.tar.gz
+afp-ComponentDependencies-2021-02-23.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-ConcurrentGC-2020-04-18.tar.gz
+afp-ConcurrentGC-2021-02-23.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-ConcurrentIMP-2020-04-18.tar.gz
+afp-ConcurrentIMP-2021-02-23.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_Ref_Alg-2020-04-18.tar.gz
+afp-Concurrent_Ref_Alg-2021-02-23.tar.gz
afp-Concurrent_Revisions-2019-01-03.tar.gz
afp-Concurrent_Revisions-2019-06-11.tar.gz
afp-Concurrent_Revisions-2020-04-18.tar.gz
+afp-Concurrent_Revisions-2021-02-23.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-Consensus_Refined-2020-04-18.tar.gz
+afp-Consensus_Refined-2021-02-23.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-Constructive_Cryptography-2020-04-18.tar.gz
+afp-Constructive_Cryptography-2021-02-23.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-Constructor_Funs-2020-04-18.tar.gz
+afp-Constructor_Funs-2021-02-23.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-Containers-2020-04-18.tar.gz
+afp-Containers-2021-02-23.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-CoreC++-2020-04-18.tar.gz
+afp-CoreC++-2021-02-23.tar.gz
afp-Core_DOM-2019-01-07.tar.gz
afp-Core_DOM-2019-06-11.tar.gz
afp-Core_DOM-2020-04-18.tar.gz
+afp-Core_DOM-2021-02-23.tar.gz
+afp-Core_SC_DOM-2020-11-26.tar.gz
+afp-Core_SC_DOM-2021-02-23.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-Count_Complex_Roots-2020-04-18.tar.gz
+afp-Count_Complex_Roots-2021-02-23.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-CRDT-2020-04-18.tar.gz
+afp-CRDT-2021-02-23.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-CryptHOL-2020-04-18.tar.gz
+afp-CryptHOL-2021-02-23.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-CryptoBasedCompositionalProperties-2020-04-18.tar.gz
+afp-CryptoBasedCompositionalProperties-2021-02-23.tar.gz
+afp-CSP_RefTK-2021-01-12.tar.gz
+afp-CSP_RefTK-2021-02-23.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-CYK-2020-04-18.tar.gz
+afp-CYK-2021-02-23.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-DataRefinementIBP-2020-04-18.tar.gz
+afp-DataRefinementIBP-2021-02-23.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-Datatype_Order_Generator-2020-04-18.tar.gz
+afp-Datatype_Order_Generator-2021-02-23.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-Decl_Sem_Fun_PL-2020-04-18.tar.gz
+afp-Decl_Sem_Fun_PL-2021-02-23.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-2020-04-18.tar.gz
+afp-Decreasing-Diagrams-2021-02-23.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-Decreasing-Diagrams-II-2020-04-18.tar.gz
+afp-Decreasing-Diagrams-II-2021-02-23.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-Deep_Learning-2020-04-18.tar.gz
+afp-Deep_Learning-2021-02-23.tar.gz
+afp-Delta_System_Lemma-2020-12-28.tar.gz
+afp-Delta_System_Lemma-2021-02-23.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-Density_Compiler-2020-04-18.tar.gz
+afp-Density_Compiler-2021-02-23.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_Refinement-2020-04-18.tar.gz
+afp-Dependent_SIFUM_Refinement-2021-02-23.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-Dependent_SIFUM_Type_Systems-2020-04-18.tar.gz
+afp-Dependent_SIFUM_Type_Systems-2021-02-23.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-Depth-First-Search-2020-04-18.tar.gz
+afp-Depth-First-Search-2021-02-23.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-Derangements-2020-04-18.tar.gz
+afp-Derangements-2021-02-23.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-Deriving-2020-04-18.tar.gz
+afp-Deriving-2021-02-23.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-Descartes_Sign_Rule-2020-04-18.tar.gz
+afp-Descartes_Sign_Rule-2021-02-23.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-DFS_Framework-2020-01-14.tar.gz
afp-DFS_Framework-2020-04-18.tar.gz
+afp-DFS_Framework-2021-02-23.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-Dict_Construction-2020-04-18.tar.gz
+afp-Dict_Construction-2021-02-23.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-Differential_Dynamic_Logic-2020-04-18.tar.gz
+afp-Differential_Dynamic_Logic-2021-02-23.tar.gz
afp-Differential_Game_Logic-2019-06-24.tar.gz
afp-Differential_Game_Logic-2020-04-18.tar.gz
+afp-Differential_Game_Logic-2021-02-23.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-Dijkstra_Shortest_Path-2020-04-18.tar.gz
+afp-Dijkstra_Shortest_Path-2021-02-23.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-Diophantine_Eqns_Lin_Hom-2020-04-18.tar.gz
+afp-Diophantine_Eqns_Lin_Hom-2021-02-23.tar.gz
afp-Dirichlet_L-2018-08-16.tar.gz
afp-Dirichlet_L-2019-06-11.tar.gz
afp-Dirichlet_L-2020-04-18.tar.gz
+afp-Dirichlet_L-2021-02-23.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-Dirichlet_Series-2020-04-18.tar.gz
+afp-Dirichlet_Series-2021-02-23.tar.gz
afp-DiscretePricing-2018-07-18.tar.gz
afp-DiscretePricing-2018-08-16.tar.gz
afp-DiscretePricing-2019-06-11.tar.gz
afp-DiscretePricing-2020-04-18.tar.gz
+afp-DiscretePricing-2021-02-23.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-Discrete_Summation-2020-04-18.tar.gz
+afp-Discrete_Summation-2021-02-23.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-DiskPaxos-2020-04-18.tar.gz
+afp-DiskPaxos-2021-02-23.tar.gz
+afp-DOM_Components-2021-02-23.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-DPT-SAT-Solver-2020-04-18.tar.gz
+afp-DPT-SAT-Solver-2021-02-23.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-DynamicArchitectures-2020-04-18.tar.gz
+afp-DynamicArchitectures-2021-02-23.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-Dynamic_Tables-2020-04-18.tar.gz
+afp-Dynamic_Tables-2021-02-23.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-Echelon_Form-2020-04-18.tar.gz
+afp-Echelon_Form-2021-02-23.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-EdmondsKarp_Maxflow-2020-04-18.tar.gz
+afp-EdmondsKarp_Maxflow-2021-02-23.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-Efficient-Mergesort-2020-04-18.tar.gz
+afp-Efficient-Mergesort-2021-02-23.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-Elliptic_Curves_Group_Law-2020-04-18.tar.gz
+afp-Elliptic_Curves_Group_Law-2021-02-23.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-Encodability_Process_Calculi-2020-04-18.tar.gz
+afp-Encodability_Process_Calculi-2021-02-23.tar.gz
afp-Epistemic_Logic-2018-10-29.tar.gz
afp-Epistemic_Logic-2019-06-11.tar.gz
afp-Epistemic_Logic-2020-04-18.tar.gz
+afp-Epistemic_Logic-2021-02-23.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-Ergodic_Theory-2020-04-18.tar.gz
+afp-Ergodic_Theory-2021-02-23.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-Error_Function-2020-04-18.tar.gz
+afp-Error_Function-2021-02-23.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-E_Transcendental-2020-04-18.tar.gz
+afp-E_Transcendental-2021-02-23.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_MacLaurin-2020-04-18.tar.gz
+afp-Euler_MacLaurin-2021-02-23.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-Euler_Partition-2020-04-18.tar.gz
+afp-Euler_Partition-2021-02-23.tar.gz
+afp-Extended_Finite_State_Machine_Inference-2020-09-19.tar.gz
+afp-Extended_Finite_State_Machine_Inference-2021-02-23.tar.gz
+afp-Extended_Finite_State_Machines-2020-09-19.tar.gz
+afp-Extended_Finite_State_Machines-2021-02-23.tar.gz
afp-Factored_Transition_System_Bounding-2018-10-16.tar.gz
afp-Factored_Transition_System_Bounding-2019-06-11.tar.gz
afp-Factored_Transition_System_Bounding-2020-04-18.tar.gz
+afp-Factored_Transition_System_Bounding-2021-02-23.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-Falling_Factorial_Sum-2020-04-18.tar.gz
+afp-Falling_Factorial_Sum-2021-02-23.tar.gz
afp-Farkas-2019-01-21.tar.gz
afp-Farkas-2019-06-11.tar.gz
afp-Farkas-2020-04-18.tar.gz
+afp-Farkas-2021-02-23.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-FeatherweightJava-2020-04-18.tar.gz
+afp-FeatherweightJava-2021-02-23.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-Featherweight_OCL-2020-04-18.tar.gz
+afp-Featherweight_OCL-2021-02-23.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-Fermat3_4-2020-04-18.tar.gz
+afp-Fermat3_4-2021-02-23.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-FFT-2020-04-18.tar.gz
+afp-FFT-2021-02-23.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-FileRefinement-2020-04-18.tar.gz
+afp-FileRefinement-2021-02-23.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-FinFun-2020-04-18.tar.gz
+afp-FinFun-2021-02-23.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-Finger-Trees-2020-04-18.tar.gz
+afp-Finger-Trees-2021-02-23.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-Finite_Automata_HF-2020-04-18.tar.gz
+afp-Finite_Automata_HF-2021-02-23.tar.gz
+afp-Finite-Map-Extras-2020-12-02.tar.gz
+afp-Finite-Map-Extras-2021-02-23.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_Order_Terms-2020-04-18.tar.gz
+afp-First_Order_Terms-2021-02-23.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-First_Welfare_Theorem-2020-04-18.tar.gz
+afp-First_Welfare_Theorem-2021-02-23.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-Fishburn_Impossibility-2020-04-18.tar.gz
+afp-Fishburn_Impossibility-2021-02-23.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-Fisher_Yates-2020-04-18.tar.gz
+afp-Fisher_Yates-2021-02-23.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-Flow_Networks-2020-01-14.tar.gz
afp-Flow_Networks-2020-04-18.tar.gz
+afp-Flow_Networks-2021-02-23.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-Floyd_Warshall-2020-04-18.tar.gz
+afp-Floyd_Warshall-2021-02-23.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-FLP-2020-04-18.tar.gz
+afp-FLP-2021-02-23.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-Flyspeck-Tame-2020-04-18.tar.gz
+afp-Flyspeck-Tame-2021-02-23.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-FocusStreamsCaseStudies-2020-04-18.tar.gz
+afp-FocusStreamsCaseStudies-2021-02-23.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-Fitting-2020-04-18.tar.gz
+afp-FOL-Fitting-2021-02-23.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-FOL_Harrison-2020-04-18.tar.gz
+afp-FOL_Harrison-2021-02-23.tar.gz
afp-FOL_Seq_Calc1-2019-07-18.tar.gz
afp-FOL_Seq_Calc1-2020-04-18.tar.gz
+afp-FOL_Seq_Calc1-2021-02-23.tar.gz
+afp-Forcing-2020-05-06.tar.gz
+afp-Forcing-2020-05-07.tar.gz
+afp-Forcing-2021-02-23.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-Formal_SSA-2020-04-18.tar.gz
+afp-Formal_SSA-2021-02-23.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-Formula_Derivatives-2020-04-18.tar.gz
+afp-Formula_Derivatives-2021-02-23.tar.gz
afp-Fourier-2019-09-11.tar.gz
afp-Fourier-2020-04-18.tar.gz
+afp-Fourier-2021-02-23.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-Boolean-Algebra-2020-04-18.tar.gz
+afp-Free-Boolean-Algebra-2021-02-23.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-Free-Groups-2020-04-18.tar.gz
+afp-Free-Groups-2021-02-23.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-Automata-2020-04-18.tar.gz
+afp-Functional-Automata-2021-02-23.tar.gz
afp-Functional_Ordered_Resolution_Prover-2018-11-29.tar.gz
afp-Functional_Ordered_Resolution_Prover-2019-06-11.tar.gz
afp-Functional_Ordered_Resolution_Prover-2020-04-18.tar.gz
+afp-Functional_Ordered_Resolution_Prover-2021-02-23.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-FunWithFunctions-2020-04-18.tar.gz
+afp-FunWithFunctions-2021-02-23.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-FunWithTilings-2020-04-18.tar.gz
+afp-FunWithTilings-2021-02-23.tar.gz
afp-Furstenberg_Topology-2020-03-27.tar.gz
afp-Furstenberg_Topology-2020-04-18.tar.gz
+afp-Furstenberg_Topology-2021-02-23.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-Gabow_SCC-2020-04-18.tar.gz
+afp-Gabow_SCC-2021-02-23.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-Game_Based_Crypto-2020-04-18.tar.gz
+afp-Game_Based_Crypto-2021-02-23.tar.gz
+afp-Gaussian_Integers-2020-04-30.tar.gz
+afp-Gaussian_Integers-2021-02-23.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-2020-04-18.tar.gz
+afp-Gauss_Jordan-2021-02-23.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-Gauss-Jordan-Elim-Fun-2020-01-14.tar.gz
afp-Gauss-Jordan-Elim-Fun-2020-04-18.tar.gz
+afp-Gauss-Jordan-Elim-Fun-2021-02-23.tar.gz
afp-Gauss_Sums-2020-01-10.tar.gz
afp-Gauss_Sums-2020-04-18.tar.gz
+afp-Gauss_Sums-2021-02-23.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-GenClock-2020-04-18.tar.gz
+afp-GenClock-2021-02-23.tar.gz
afp-Generalized_Counting_Sort-2019-12-09.tar.gz
afp-Generalized_Counting_Sort-2020-04-18.tar.gz
+afp-Generalized_Counting_Sort-2021-02-23.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-General-Triangle-2020-04-18.tar.gz
+afp-General-Triangle-2021-02-23.tar.gz
afp-Generic_Deriving-2018-11-21.tar.gz
afp-Generic_Deriving-2019-06-11.tar.gz
afp-Generic_Deriving-2020-04-18.tar.gz
+afp-Generic_Deriving-2021-02-23.tar.gz
afp-Generic_Join-2019-09-18.tar.gz
afp-Generic_Join-2020-04-18.tar.gz
+afp-Generic_Join-2021-02-23.tar.gz
afp-GewirthPGCProof-2018-10-31.tar.gz
afp-GewirthPGCProof-2019-06-11.tar.gz
afp-GewirthPGCProof-2020-04-18.tar.gz
+afp-GewirthPGCProof-2021-02-23.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-Girth_Chromatic-2020-04-18.tar.gz
+afp-Girth_Chromatic-2021-02-23.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-GoedelGod-2020-04-18.tar.gz
+afp-GoedelGod-2021-02-23.tar.gz
+afp-Goedel_HFSet_Semantic-2020-09-18.tar.gz
+afp-Goedel_HFSet_Semantic-2021-02-23.tar.gz
+afp-Goedel_HFSet_Semanticless-2020-09-18.tar.gz
+afp-Goedel_HFSet_Semanticless-2021-02-23.tar.gz
+afp-Goedel_Incompleteness-2020-09-18.tar.gz
+afp-Goedel_Incompleteness-2020-09-19.tar.gz
+afp-Goedel_Incompleteness-2021-02-23.tar.gz
afp-Goodstein_Lambda-2020-02-24.tar.gz
afp-Goodstein_Lambda-2020-04-18.tar.gz
+afp-Goodstein_Lambda-2021-02-23.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-GPU_Kernel_PL-2020-04-18.tar.gz
+afp-GPU_Kernel_PL-2021-02-23.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-GraphMarkingIBP-2020-04-18.tar.gz
+afp-GraphMarkingIBP-2021-02-23.tar.gz
afp-Graph_Saturation-2018-11-28.tar.gz
afp-Graph_Saturation-2019-06-11.tar.gz
afp-Graph_Saturation-2020-04-18.tar.gz
+afp-Graph_Saturation-2021-02-23.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-Graph_Theory-2020-04-18.tar.gz
+afp-Graph_Theory-2021-02-23.tar.gz
afp-Green-2018-01-12.tar.gz
afp-Green-2018-08-16.tar.gz
afp-Green-2019-06-11.tar.gz
afp-Green-2020-04-18.tar.gz
+afp-Green-2021-02-23.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-Groebner_Bases-2020-04-18.tar.gz
+afp-Groebner_Bases-2021-02-23.tar.gz
afp-Groebner_Macaulay-2019-06-17.tar.gz
afp-Groebner_Macaulay-2020-04-18.tar.gz
+afp-Groebner_Macaulay-2021-02-23.tar.gz
afp-Gromov_Hyperbolicity-2018-08-16.tar.gz
afp-Gromov_Hyperbolicity-2019-06-11.tar.gz
afp-Gromov_Hyperbolicity-2020-04-18.tar.gz
+afp-Gromov_Hyperbolicity-2021-02-23.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-Group-Ring-Module-2020-04-18.tar.gz
+afp-Group-Ring-Module-2021-02-23.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-Heard_Of-2020-04-18.tar.gz
+afp-Heard_Of-2021-02-23.tar.gz
afp-Hello_World-2020-03-23.tar.gz
afp-Hello_World-2020-04-18.tar.gz
+afp-Hello_World-2021-02-23.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-HereditarilyFinite-2020-04-18.tar.gz
+afp-HereditarilyFinite-2021-02-23.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-Hermite-2020-04-18.tar.gz
+afp-Hermite-2021-02-23.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-Hidden_Markov_Models-2020-04-18.tar.gz
+afp-Hidden_Markov_Models-2021-02-23.tar.gz
afp-Higher_Order_Terms-2019-01-15.tar.gz
afp-Higher_Order_Terms-2019-06-11.tar.gz
afp-Higher_Order_Terms-2020-04-18.tar.gz
+afp-Higher_Order_Terms-2021-02-23.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-Hoare_Time-2020-04-18.tar.gz
+afp-Hoare_Time-2021-02-23.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-HOLCF-Prelude-2020-04-18.tar.gz
+afp-HOLCF-Prelude-2021-02-23.tar.gz
afp-HOL-CSP-2019-04-29.tar.gz
afp-HOL-CSP-2019-06-11.tar.gz
afp-HOL-CSP-2020-04-18.tar.gz
+afp-HOL-CSP-2021-02-23.tar.gz
+afp-Hood_Melville_Queue-2021-02-23.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-HotelKeyCards-2020-04-18.tar.gz
+afp-HotelKeyCards-2021-02-23.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-HRB-Slicing-2020-04-18.tar.gz
+afp-HRB-Slicing-2021-02-23.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-Huffman-2020-04-18.tar.gz
+afp-Huffman-2021-02-23.tar.gz
afp-Hybrid_Logic-2020-01-07.tar.gz
afp-Hybrid_Logic-2020-04-18.tar.gz
+afp-Hybrid_Logic-2021-02-23.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-Hybrid_Multi_Lane_Spatial_Logic-2020-04-18.tar.gz
+afp-Hybrid_Multi_Lane_Spatial_Logic-2021-02-23.tar.gz
afp-Hybrid_Systems_VCs-2019-09-10.tar.gz
afp-Hybrid_Systems_VCs-2020-04-18.tar.gz
+afp-Hybrid_Systems_VCs-2021-02-23.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-HyperCTL-2020-04-18.tar.gz
+afp-HyperCTL-2021-02-23.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-IEEE_Floating_Point-2020-04-18.tar.gz
+afp-IEEE_Floating_Point-2021-02-23.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-IMAP-CRDT-2020-01-14.tar.gz
afp-IMAP-CRDT-2020-04-18.tar.gz
+afp-IMAP-CRDT-2021-02-23.tar.gz
afp-IMO2019-2019-08-06.tar.gz
afp-IMO2019-2020-04-18.tar.gz
+afp-IMO2019-2021-02-23.tar.gz
afp-IMP2-2019-01-15.tar.gz
afp-IMP2-2019-06-11.tar.gz
afp-IMP2-2020-04-18.tar.gz
+afp-IMP2-2021-02-23.tar.gz
afp-IMP2_Binary_Heap-2019-06-13.tar.gz
afp-IMP2_Binary_Heap-2020-04-18.tar.gz
+afp-IMP2_Binary_Heap-2021-02-23.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-Imperative_Insertion_Sort-2020-04-18.tar.gz
+afp-Imperative_Insertion_Sort-2021-02-23.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-Impossible_Geometry-2020-04-18.tar.gz
+afp-Impossible_Geometry-2021-02-23.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-Incompleteness-2020-04-18.tar.gz
+afp-Incompleteness-2021-02-23.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-Incredible_Proof_Machine-2020-04-18.tar.gz
+afp-Incredible_Proof_Machine-2021-02-23.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-Inductive_Confidentiality-2020-04-18.tar.gz
+afp-Inductive_Confidentiality-2021-02-23.tar.gz
+afp-Inductive_Inference-2020-09-02.tar.gz
+afp-Inductive_Inference-2021-02-23.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-2020-04-18.tar.gz
+afp-InformationFlowSlicing-2021-02-23.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-InformationFlowSlicing_Inter-2020-04-18.tar.gz
+afp-InformationFlowSlicing_Inter-2021-02-23.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-InfPathElimination-2020-04-18.tar.gz
+afp-InfPathElimination-2021-02-23.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-Integration-2020-04-18.tar.gz
+afp-Integration-2021-02-23.tar.gz
+afp-Interpreter_Optimizations-2021-02-23.tar.gz
afp-Interval_Arithmetic_Word32-2019-11-28.tar.gz
afp-Interval_Arithmetic_Word32-2020-04-18.tar.gz
+afp-Interval_Arithmetic_Word32-2021-02-23.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-IP_Addresses-2020-04-18.tar.gz
+afp-IP_Addresses-2021-02-23.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-Iptables_Semantics-2020-04-18.tar.gz
+afp-Iptables_Semantics-2021-02-23.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-Irrationality_J_Hancl-2020-04-18.tar.gz
+afp-Irrationality_J_Hancl-2021-02-23.tar.gz
+afp-Irrational_Series_Erdos_Straus-2020-05-13.tar.gz
+afp-Irrational_Series_Erdos_Straus-2020-05-14.tar.gz
+afp-Irrational_Series_Erdos_Straus-2021-02-23.tar.gz
afp-Isabelle_C-2019-12-19.tar.gz
afp-Isabelle_C-2020-04-18.tar.gz
+afp-Isabelle_C-2021-02-23.tar.gz
+afp-Isabelle_Marries_Dirac-2020-11-30.tar.gz
+afp-Isabelle_Marries_Dirac-2021-02-23.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-Isabelle_Meta_Model-2020-04-18.tar.gz
+afp-Isabelle_Meta_Model-2021-02-23.tar.gz
+afp-IsaGeoCoq-2021-02-01.tar.gz
+afp-IsaGeoCoq-2021-02-23.tar.gz
afp-Jacobson_Basic_Algebra-2019-09-01.tar.gz
afp-Jacobson_Basic_Algebra-2020-04-18.tar.gz
+afp-Jacobson_Basic_Algebra-2021-02-23.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-Jinja-2020-04-18.tar.gz
+afp-Jinja-2021-02-23.tar.gz
+afp-JinjaDCI-2021-01-13.tar.gz
+afp-JinjaDCI-2021-02-23.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-JinjaThreads-2020-04-18.tar.gz
+afp-JinjaThreads-2021-02-23.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-JiveDataStoreModel-2020-04-18.tar.gz
+afp-JiveDataStoreModel-2021-02-23.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_Hoelder-2020-04-18.tar.gz
+afp-Jordan_Hoelder-2021-02-23.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-Jordan_Normal_Form-2020-04-18.tar.gz
+afp-Jordan_Normal_Form-2021-02-23.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-KAD-2020-04-18.tar.gz
+afp-KAD-2021-02-23.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-KAT_and_DRA-2020-04-18.tar.gz
+afp-KAT_and_DRA-2021-02-23.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-KBPs-2020-04-18.tar.gz
+afp-KBPs-2021-02-23.tar.gz
afp-KD_Tree-2019-06-04.tar.gz
afp-KD_Tree-2019-06-11.tar.gz
afp-KD_Tree-2020-04-18.tar.gz
+afp-KD_Tree-2021-02-23.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-Key_Agreement_Strong_Adversaries-2020-04-18.tar.gz
+afp-Key_Agreement_Strong_Adversaries-2021-02-23.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-Kleene_Algebra-2020-04-18.tar.gz
+afp-Kleene_Algebra-2021-02-23.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-Knot_Theory-2020-04-18.tar.gz
+afp-Knot_Theory-2021-02-23.tar.gz
+afp-Knuth_Bendix_Order-2020-05-15.tar.gz
+afp-Knuth_Bendix_Order-2020-05-16.tar.gz
+afp-Knuth_Bendix_Order-2021-02-23.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-Knuth_Morris_Pratt-2020-04-18.tar.gz
+afp-Knuth_Morris_Pratt-2021-02-23.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-Koenigsberg_Friendship-2020-04-18.tar.gz
+afp-Koenigsberg_Friendship-2021-02-23.tar.gz
afp-Kruskal-2019-02-19.tar.gz
afp-Kruskal-2019-06-11.tar.gz
afp-Kruskal-2020-04-18.tar.gz
+afp-Kruskal-2021-02-23.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-Kuratowski_Closure_Complement-2020-04-18.tar.gz
+afp-Kuratowski_Closure_Complement-2021-02-23.tar.gz
afp-LambdaAuth-2019-05-15.tar.gz
afp-LambdaAuth-2019-06-11.tar.gz
afp-LambdaAuth-2020-04-18.tar.gz
+afp-LambdaAuth-2021-02-23.tar.gz
afp-Lambda_Free_EPO-2018-10-21.tar.gz
afp-Lambda_Free_EPO-2019-06-11.tar.gz
afp-Lambda_Free_EPO-2020-04-18.tar.gz
+afp-Lambda_Free_EPO-2021-02-23.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_KBOs-2020-04-18.tar.gz
+afp-Lambda_Free_KBOs-2021-02-23.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-Lambda_Free_RPOs-2020-04-18.tar.gz
+afp-Lambda_Free_RPOs-2021-02-23.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-LambdaMu-2020-04-18.tar.gz
+afp-LambdaMu-2021-02-23.tar.gz
+afp-Lambert_W-2020-04-29.tar.gz
+afp-Lambert_W-2020-05-12.tar.gz
+afp-Lambert_W-2021-02-23.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-Lam-ml-Normalization-2020-04-18.tar.gz
+afp-Lam-ml-Normalization-2021-02-23.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-Landau_Symbols-2020-04-18.tar.gz
+afp-Landau_Symbols-2021-02-23.tar.gz
afp-Laplace_Transform-2019-08-16.tar.gz
afp-Laplace_Transform-2020-04-18.tar.gz
+afp-Laplace_Transform-2021-02-23.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-Latin_Square-2020-04-18.tar.gz
+afp-Latin_Square-2021-02-23.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-LatticeProperties-2019-06-28.tar.gz
afp-LatticeProperties-2020-04-18.tar.gz
+afp-LatticeProperties-2021-02-23.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-Launchbury-2020-04-18.tar.gz
+afp-Launchbury-2021-02-23.tar.gz
+afp-Laws_of_Large_Numbers-2021-02-11.tar.gz
+afp-Laws_of_Large_Numbers-2021-02-23.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_Case-2020-04-18.tar.gz
+afp-Lazy_Case-2021-02-23.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-Lazy-Lists-II-2020-04-18.tar.gz
+afp-Lazy-Lists-II-2021-02-23.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-Lehmer-2020-04-18.tar.gz
+afp-Lehmer-2021-02-23.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-Lifting_Definition_Option-2020-04-18.tar.gz
+afp-Lifting_Definition_Option-2021-02-23.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-LightweightJava-2020-04-18.tar.gz
+afp-LightweightJava-2021-02-23.tar.gz
afp-Linear_Inequalities-2019-06-24.tar.gz
afp-Linear_Inequalities-2020-04-18.tar.gz
+afp-Linear_Inequalities-2021-02-23.tar.gz
afp-Linear_Programming-2019-09-23.tar.gz
afp-Linear_Programming-2020-04-18.tar.gz
+afp-Linear_Programming-2021-02-23.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-LinearQuantifierElim-2020-04-18.tar.gz
+afp-LinearQuantifierElim-2021-02-23.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-Linear_Recurrences-2020-04-20.tar.gz
+afp-Linear_Recurrences-2021-02-23.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-Liouville_Numbers-2020-04-20.tar.gz
+afp-Liouville_Numbers-2021-02-23.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-Index-2020-04-20.tar.gz
+afp-List-Index-2021-02-23.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-Infinite-2020-04-20.tar.gz
+afp-List-Infinite-2021-02-23.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_Interleaving-2020-04-20.tar.gz
+afp-List_Interleaving-2021-02-23.tar.gz
afp-List_Inversions-2019-02-21.tar.gz
afp-List_Inversions-2019-06-11.tar.gz
afp-List_Inversions-2020-04-20.tar.gz
+afp-List_Inversions-2021-02-23.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-List_Update-2020-04-20.tar.gz
+afp-List_Update-2021-02-23.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_Basis_Reduction-2020-04-20.tar.gz
+afp-LLL_Basis_Reduction-2021-02-23.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-LLL_Factorization-2020-04-20.tar.gz
+afp-LLL_Factorization-2021-02-23.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-Localization_Ring-2020-04-20.tar.gz
+afp-Localization_Ring-2021-02-23.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-LocalLexing-2020-04-20.tar.gz
+afp-LocalLexing-2021-02-23.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-Locally-Nameless-Sigma-2020-04-20.tar.gz
+afp-Locally-Nameless-Sigma-2021-02-23.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-LOFT-2020-04-20.tar.gz
+afp-LOFT-2021-02-23.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-Lowe_Ontological_Argument-2020-04-20.tar.gz
+afp-Lowe_Ontological_Argument-2021-02-23.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-Lower_Semicontinuous-2020-04-20.tar.gz
+afp-Lower_Semicontinuous-2021-02-23.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-Lp-2020-04-20.tar.gz
+afp-Lp-2021-02-23.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-2020-04-20.tar.gz
+afp-LTL-2021-02-23.tar.gz
afp-LTL_Master_Theorem-2019-04-17.tar.gz
afp-LTL_Master_Theorem-2019-06-11.tar.gz
afp-LTL_Master_Theorem-2020-04-20.tar.gz
+afp-LTL_Master_Theorem-2021-02-23.tar.gz
+afp-LTL_Normal_Form-2020-05-09.tar.gz
+afp-LTL_Normal_Form-2021-02-23.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_DRA-2020-04-20.tar.gz
+afp-LTL_to_DRA-2021-02-23.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-LTL_to_GBA-2020-04-20.tar.gz
+afp-LTL_to_GBA-2021-02-23.tar.gz
+afp-Lucas_Theorem-2020-04-21.tar.gz
+afp-Lucas_Theorem-2021-02-23.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-Markov_Models-2020-04-20.tar.gz
+afp-Markov_Models-2021-02-23.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-Marriage-2020-04-20.tar.gz
+afp-Marriage-2021-02-23.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-Mason_Stothers-2020-04-20.tar.gz
+afp-Mason_Stothers-2021-02-23.tar.gz
+afp-Matrices_for_ODEs-2020-05-09.tar.gz
+afp-Matrices_for_ODEs-2021-02-23.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-2020-04-20.tar.gz
+afp-Matrix-2021-02-23.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-Matrix_Tensor-2020-04-20.tar.gz
+afp-Matrix_Tensor-2021-02-23.tar.gz
afp-Matroids-2018-11-20.tar.gz
afp-Matroids-2019-06-11.tar.gz
afp-Matroids-2020-04-20.tar.gz
+afp-Matroids-2021-02-23.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-Max-Card-Matching-2020-04-20.tar.gz
+afp-Max-Card-Matching-2021-02-23.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-Median_Of_Medians_Selection-2020-04-20.tar.gz
+afp-Median_Of_Medians_Selection-2021-02-23.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-Menger-2020-04-20.tar.gz
+afp-Menger-2021-02-23.tar.gz
afp-Mersenne_Primes-2020-01-20.tar.gz
afp-Mersenne_Primes-2020-04-20.tar.gz
+afp-Mersenne_Primes-2021-02-23.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-MFMC_Countable-2020-04-20.tar.gz
+afp-MFMC_Countable-2021-02-23.tar.gz
afp-MFODL_Monitor_Optimized-2020-04-11.tar.gz
afp-MFODL_Monitor_Optimized-2020-04-12.tar.gz
afp-MFODL_Monitor_Optimized-2020-04-20.tar.gz
+afp-MFODL_Monitor_Optimized-2021-02-23.tar.gz
afp-MFOTL_Monitor-2019-07-05.tar.gz
afp-MFOTL_Monitor-2020-04-20.tar.gz
+afp-MFOTL_Monitor-2021-02-23.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-Minimal_SSA-2020-04-20.tar.gz
+afp-Minimal_SSA-2021-02-23.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-MiniML-2020-04-20.tar.gz
+afp-MiniML-2020-05-06.tar.gz
+afp-MiniML-2021-02-23.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-Minkowskis_Theorem-2020-04-20.tar.gz
+afp-Minkowskis_Theorem-2021-02-23.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-Minsky_Machines-2020-04-20.tar.gz
+afp-Minsky_Machines-2021-02-23.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-Modal_Logics_for_NTS-2020-04-20.tar.gz
+afp-Modal_Logics_for_NTS-2021-02-23.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-Modular_Assembly_Kit_Security-2020-04-20.tar.gz
+afp-Modular_Assembly_Kit_Security-2021-02-23.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_Memo_DP-2020-04-20.tar.gz
+afp-Monad_Memo_DP-2021-02-23.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-Monad_Normalisation-2020-04-20.tar.gz
+afp-Monad_Normalisation-2021-02-23.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-MonoBoolTranAlgebra-2020-04-20.tar.gz
+afp-MonoBoolTranAlgebra-2021-02-23.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-MonoidalCategory-2020-04-20.tar.gz
+afp-MonoidalCategory-2021-02-23.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-Monomorphic_Monad-2020-04-20.tar.gz
+afp-Monomorphic_Monad-2021-02-23.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-MSO_Regex_Equivalence-2020-04-20.tar.gz
+afp-MSO_Regex_Equivalence-2021-02-23.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-MuchAdoAboutTwo-2020-04-20.tar.gz
+afp-MuchAdoAboutTwo-2021-02-23.tar.gz
afp-Multi_Party_Computation-2019-05-10.tar.gz
afp-Multi_Party_Computation-2019-06-11.tar.gz
afp-Multi_Party_Computation-2020-04-20.tar.gz
+afp-Multi_Party_Computation-2021-02-23.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-Multirelations-2020-04-20.tar.gz
+afp-Multirelations-2021-02-23.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-Myhill-Nerode-2020-04-20.tar.gz
+afp-Myhill-Nerode-2021-02-23.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-Name_Carrying_Type_Inference-2020-04-20.tar.gz
+afp-Name_Carrying_Type_Inference-2021-02-23.tar.gz
+afp-Nash_Williams-2020-06-02.tar.gz
+afp-Nash_Williams-2021-02-23.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-Nat-Interval-Logic-2020-04-20.tar.gz
+afp-Nat-Interval-Logic-2021-02-23.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-Native_Word-2020-04-20.tar.gz
+afp-Native_Word-2021-02-23.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-Nested_Multisets_Ordinals-2020-04-20.tar.gz
+afp-Nested_Multisets_Ordinals-2021-02-23.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-Network_Security_Policy_Verification-2020-04-20.tar.gz
+afp-Network_Security_Policy_Verification-2021-02-23.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-Neumann_Morgenstern_Utility-2020-04-20.tar.gz
+afp-Neumann_Morgenstern_Utility-2021-02-23.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-No_FTL_observers-2020-04-20.tar.gz
+afp-No_FTL_observers-2021-02-23.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-Nominal2-2020-04-20.tar.gz
+afp-Nominal2-2021-02-23.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_Concurrent_Composition-2020-04-20.tar.gz
+afp-Noninterference_Concurrent_Composition-2021-02-23.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_CSP-2020-04-20.tar.gz
+afp-Noninterference_CSP-2021-02-23.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_Generic_Unwinding-2020-04-20.tar.gz
+afp-Noninterference_Generic_Unwinding-2021-02-23.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_Inductive_Unwinding-2020-04-20.tar.gz
+afp-Noninterference_Inductive_Unwinding-2021-02-23.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_Ipurge_Unwinding-2020-04-20.tar.gz
+afp-Noninterference_Ipurge_Unwinding-2021-02-23.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-Noninterference_Sequential_Composition-2020-04-20.tar.gz
+afp-Noninterference_Sequential_Composition-2021-02-23.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-NormByEval-2020-04-20.tar.gz
+afp-NormByEval-2021-02-23.tar.gz
afp-Nullstellensatz-2019-06-17.tar.gz
afp-Nullstellensatz-2020-04-20.tar.gz
+afp-Nullstellensatz-2021-02-23.tar.gz
afp-Octonions-2018-09-16.tar.gz
afp-Octonions-2019-06-11.tar.gz
afp-Octonions-2020-04-20.tar.gz
+afp-Octonions-2021-02-23.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-Open_Induction-2020-04-20.tar.gz
+afp-Open_Induction-2021-02-23.tar.gz
afp-OpSets-2018-05-25.tar.gz
afp-OpSets-2018-08-16.tar.gz
afp-OpSets-2019-06-11.tar.gz
afp-OpSets-2020-04-20.tar.gz
+afp-OpSets-2021-02-23.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-Optics-2020-04-20.tar.gz
+afp-Optics-2021-02-23.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-Optimal_BST-2020-04-20.tar.gz
+afp-Optimal_BST-2021-02-23.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-Orbit_Stabiliser-2020-04-20.tar.gz
+afp-Orbit_Stabiliser-2021-02-23.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-Ordered_Resolution_Prover-2020-04-20.tar.gz
+afp-Ordered_Resolution_Prover-2021-02-23.tar.gz
afp-Order_Lattice_Props-2018-12-19.tar.gz
afp-Order_Lattice_Props-2019-06-11.tar.gz
afp-Order_Lattice_Props-2019-06-28.tar.gz
afp-Order_Lattice_Props-2020-04-20.tar.gz
+afp-Order_Lattice_Props-2021-02-23.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-Ordinal-2020-04-20.tar.gz
+afp-Ordinal-2021-02-23.tar.gz
+afp-Ordinal_Partitions-2020-08-18.tar.gz
+afp-Ordinal_Partitions-2021-02-23.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-Ordinals_and_Cardinals-2020-04-20.tar.gz
+afp-Ordinals_and_Cardinals-2021-02-23.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-Ordinary_Differential_Equations-2020-04-20.tar.gz
+afp-Ordinary_Differential_Equations-2021-02-23.tar.gz
+afp-PAC_Checker-2020-08-31.tar.gz
+afp-PAC_Checker-2021-02-23.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-Pairing_Heap-2020-04-20.tar.gz
+afp-Pairing_Heap-2021-02-23.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-Paraconsistency-2020-04-20.tar.gz
+afp-Paraconsistency-2021-02-23.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-Parity_Game-2020-04-20.tar.gz
+afp-Parity_Game-2021-02-23.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_Function_MR-2020-04-20.tar.gz
+afp-Partial_Function_MR-2021-02-23.tar.gz
afp-Partial_Order_Reduction-2018-08-16.tar.gz
afp-Partial_Order_Reduction-2019-06-11.tar.gz
afp-Partial_Order_Reduction-2020-04-20.tar.gz
+afp-Partial_Order_Reduction-2021-02-23.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-Password_Authentication_Protocol-2020-04-20.tar.gz
+afp-Password_Authentication_Protocol-2021-02-23.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-PCF-2020-04-20.tar.gz
+afp-PCF-2021-02-23.tar.gz
afp-Pell-2018-06-25.tar.gz
afp-Pell-2018-08-16.tar.gz
afp-Pell-2019-06-11.tar.gz
afp-Pell-2020-04-20.tar.gz
+afp-Pell-2021-02-23.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-Perfect-Number-Thm-2020-04-20.tar.gz
+afp-Perfect-Number-Thm-2021-02-23.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-Perron_Frobenius-2020-04-20.tar.gz
+afp-Perron_Frobenius-2021-02-23.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-pGCL-2020-04-20.tar.gz
+afp-pGCL-2021-02-23.tar.gz
+afp-Physical_Quantities-2020-10-28.tar.gz
+afp-Physical_Quantities-2021-02-23.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_Calculus-2020-04-20.tar.gz
+afp-Pi_Calculus-2021-02-23.tar.gz
afp-Pi_Transcendental-2018-10-02.tar.gz
afp-Pi_Transcendental-2019-06-11.tar.gz
afp-Pi_Transcendental-2020-04-20.tar.gz
+afp-Pi_Transcendental-2021-02-23.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-Planarity_Certificates-2020-04-20.tar.gz
+afp-Planarity_Certificates-2021-02-23.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-PLM-2020-04-20.tar.gz
+afp-PLM-2021-02-23.tar.gz
afp-Poincare_Bendixson-2019-12-18.tar.gz
afp-Poincare_Bendixson-2020-04-20.tar.gz
+afp-Poincare_Bendixson-2021-02-23.tar.gz
afp-Poincare_Disc-2020-01-17.tar.gz
afp-Poincare_Disc-2020-04-20.tar.gz
+afp-Poincare_Disc-2021-02-23.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_Factorization-2020-04-20.tar.gz
+afp-Polynomial_Factorization-2021-02-23.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-Polynomial_Interpolation-2020-04-20.tar.gz
+afp-Polynomial_Interpolation-2021-02-23.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-Polynomials-2020-01-14.tar.gz
afp-Polynomials-2020-04-20.tar.gz
+afp-Polynomials-2021-02-23.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-POPLmark-deBruijn-2020-04-20.tar.gz
+afp-POPLmark-deBruijn-2021-02-23.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-Pop_Refinement-2020-04-20.tar.gz
+afp-Pop_Refinement-2021-02-23.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-Posix-Lexing-2020-04-20.tar.gz
+afp-Posix-Lexing-2021-02-23.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-Possibilistic_Noninterference-2020-04-20.tar.gz
+afp-Possibilistic_Noninterference-2021-02-23.tar.gz
+afp-Power_Sum_Polynomials-2020-04-30.tar.gz
+afp-Power_Sum_Polynomials-2021-02-23.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-Pratt_Certificate-2020-04-20.tar.gz
+afp-Pratt_Certificate-2021-02-23.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-Presburger-Automata-2020-04-20.tar.gz
+afp-Presburger-Automata-2021-02-23.tar.gz
afp-Prim_Dijkstra_Simple-2019-06-29.tar.gz
afp-Prim_Dijkstra_Simple-2020-04-20.tar.gz
+afp-Prim_Dijkstra_Simple-2021-02-23.tar.gz
afp-Prime_Distribution_Elementary-2019-02-22.tar.gz
afp-Prime_Distribution_Elementary-2019-06-11.tar.gz
afp-Prime_Distribution_Elementary-2020-04-20.tar.gz
+afp-Prime_Distribution_Elementary-2021-02-23.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_Harmonic_Series-2020-04-20.tar.gz
+afp-Prime_Harmonic_Series-2021-02-23.tar.gz
afp-Prime_Number_Theorem-2018-09-20.tar.gz
afp-Prime_Number_Theorem-2019-06-11.tar.gz
afp-Prime_Number_Theorem-2020-04-20.tar.gz
+afp-Prime_Number_Theorem-2021-02-23.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-Priority_Queue_Braun-2020-04-20.tar.gz
+afp-Priority_Queue_Braun-2021-02-23.tar.gz
afp-Priority_Search_Trees-2019-06-29.tar.gz
afp-Priority_Search_Trees-2020-04-20.tar.gz
+afp-Priority_Search_Trees-2021-02-23.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_Noninterference-2020-04-20.tar.gz
+afp-Probabilistic_Noninterference-2021-02-23.tar.gz
afp-Probabilistic_Prime_Tests-2019-02-15.tar.gz
afp-Probabilistic_Prime_Tests-2019-06-11.tar.gz
afp-Probabilistic_Prime_Tests-2020-04-20.tar.gz
+afp-Probabilistic_Prime_Tests-2021-02-23.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_System_Zoo-2020-04-20.tar.gz
+afp-Probabilistic_System_Zoo-2021-02-23.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_Timed_Automata-2020-04-20.tar.gz
+afp-Probabilistic_Timed_Automata-2021-02-23.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-Probabilistic_While-2020-04-20.tar.gz
+afp-Probabilistic_While-2021-02-23.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-Program-Conflict-Analysis-2020-04-20.tar.gz
+afp-Program-Conflict-Analysis-2021-02-23.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-Projective_Geometry-2020-04-20.tar.gz
+afp-Projective_Geometry-2021-02-23.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-Promela-2020-04-20.tar.gz
+afp-Promela-2021-02-23.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-Proof_Strategy_Language-2020-04-20.tar.gz
+afp-Proof_Strategy_Language-2021-02-23.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-Propositional_Proof_Systems-2020-04-20.tar.gz
+afp-Propositional_Proof_Systems-2021-02-23.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-PropResPI-2020-04-20.tar.gz
+afp-PropResPI-2021-02-23.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-Prpu_Maxflow-2020-01-14.tar.gz
afp-Prpu_Maxflow-2020-04-20.tar.gz
+afp-Prpu_Maxflow-2021-02-23.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-PSemigroupsConvolution-2020-04-20.tar.gz
+afp-PSemigroupsConvolution-2021-02-23.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-PseudoHoops-2020-04-20.tar.gz
+afp-PseudoHoops-2021-02-23.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-Psi_Calculi-2020-04-20.tar.gz
+afp-Psi_Calculi-2021-02-23.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-Ptolemys_Theorem-2020-04-20.tar.gz
+afp-Ptolemys_Theorem-2021-02-23.tar.gz
afp-QHLProver-2019-03-25.tar.gz
afp-QHLProver-2019-06-11.tar.gz
afp-QHLProver-2020-04-20.tar.gz
+afp-QHLProver-2021-02-23.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-QR_Decomposition-2020-04-20.tar.gz
+afp-QR_Decomposition-2021-02-23.tar.gz
afp-Quantales-2018-12-19.tar.gz
afp-Quantales-2019-06-11.tar.gz
afp-Quantales-2020-04-20.tar.gz
+afp-Quantales-2021-02-23.tar.gz
afp-Quaternions-2018-09-07.tar.gz
afp-Quaternions-2019-06-11.tar.gz
afp-Quaternions-2020-04-20.tar.gz
+afp-Quaternions-2021-02-23.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-Quick_Sort_Cost-2020-04-20.tar.gz
+afp-Quick_Sort_Cost-2021-02-23.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-Ramsey-Infinite-2020-04-20.tar.gz
+afp-Ramsey-Infinite-2021-02-23.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_BSTs-2020-04-20.tar.gz
+afp-Random_BSTs-2021-02-23.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-Random_Graph_Subgraph_Threshold-2020-04-20.tar.gz
+afp-Random_Graph_Subgraph_Threshold-2021-02-23.tar.gz
afp-Randomised_BSTs-2018-10-19.tar.gz
afp-Randomised_BSTs-2019-06-11.tar.gz
afp-Randomised_BSTs-2020-04-20.tar.gz
+afp-Randomised_BSTs-2021-02-23.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-Randomised_Social_Choice-2020-04-20.tar.gz
+afp-Randomised_Social_Choice-2021-02-23.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-Rank_Nullity_Theorem-2020-04-20.tar.gz
+afp-Rank_Nullity_Theorem-2021-02-23.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-Real_Impl-2020-04-20.tar.gz
+afp-Real_Impl-2021-02-23.tar.gz
+afp-Recursion-Addition-2020-05-13.tar.gz
+afp-Recursion-Addition-2021-02-23.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-Recursion-Theory-I-2020-04-20.tar.gz
+afp-Recursion-Theory-I-2021-02-23.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-Refine_Imperative_HOL-2020-04-20.tar.gz
+afp-Refine_Imperative_HOL-2021-02-23.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-RefinementReactive-2020-04-20.tar.gz
+afp-RefinementReactive-2021-02-23.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-Refine_Monadic-2020-04-20.tar.gz
+afp-Refine_Monadic-2021-02-23.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-Regex_Equivalence-2020-04-20.tar.gz
+afp-Regex_Equivalence-2021-02-23.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_Algebras-2020-04-20.tar.gz
+afp-Regular_Algebras-2021-02-23.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-Regular-Sets-2020-04-20.tar.gz
+afp-Regular-Sets-2021-02-23.tar.gz
+afp-Relational_Disjoint_Set_Forests-2020-08-26.tar.gz
+afp-Relational_Disjoint_Set_Forests-2021-02-23.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-Relation_Algebra-2020-04-20.tar.gz
+afp-Relation_Algebra-2021-02-23.tar.gz
afp-Relational-Incorrectness-Logic-2020-03-26.tar.gz
afp-Relational-Incorrectness-Logic-2020-04-20.tar.gz
+afp-Relational-Incorrectness-Logic-2021-02-23.tar.gz
+afp-Relational_Method-2020-12-07.tar.gz
+afp-Relational_Method-2020-12-08.tar.gz
+afp-Relational_Method-2021-02-23.tar.gz
+afp-Relational_Minimum_Spanning_Trees-2020-12-08.tar.gz
+afp-Relational_Minimum_Spanning_Trees-2021-02-23.tar.gz
+afp-Relational_Paths-2020-07-28.tar.gz
+afp-Relational_Paths-2021-02-23.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-Rep_Fin_Groups-2020-04-20.tar.gz
+afp-Rep_Fin_Groups-2021-02-23.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-Residuated_Lattices-2019-06-28.tar.gz
afp-Residuated_Lattices-2020-04-20.tar.gz
+afp-Residuated_Lattices-2021-02-23.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-Resolution_FOL-2020-04-20.tar.gz
+afp-Resolution_FOL-2021-02-23.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-Rewriting_Z-2020-04-20.tar.gz
+afp-Rewriting_Z-2021-02-23.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-Ribbon_Proofs-2020-04-20.tar.gz
+afp-Ribbon_Proofs-2021-02-23.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-RIPEMD-160-SPARK-2020-04-20.tar.gz
+afp-RIPEMD-160-SPARK-2021-02-23.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-Robbins-Conjecture-2020-04-20.tar.gz
+afp-Robbins-Conjecture-2021-02-23.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-ROBDD-2020-04-20.tar.gz
+afp-ROBDD-2021-02-23.tar.gz
+afp-Robinson_Arithmetic-2020-09-18.tar.gz
+afp-Robinson_Arithmetic-2021-02-23.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-Root_Balanced_Tree-2020-04-20.tar.gz
+afp-Root_Balanced_Tree-2021-02-23.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-Routing-2020-04-20.tar.gz
+afp-Routing-2021-02-23.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-Roy_Floyd_Warshall-2020-01-14.tar.gz
afp-Roy_Floyd_Warshall-2020-04-20.tar.gz
+afp-Roy_Floyd_Warshall-2021-02-23.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-RSAPSS-2020-04-20.tar.gz
+afp-RSAPSS-2021-02-23.tar.gz
+afp-Safe_Distance-2020-06-03.tar.gz
+afp-Safe_Distance-2021-02-23.tar.gz
afp-Safe_OCL-2019-03-14.tar.gz
afp-Safe_OCL-2019-06-11.tar.gz
afp-Safe_OCL-2020-04-20.tar.gz
+afp-Safe_OCL-2021-02-23.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-SATSolverVerification-2020-04-20.tar.gz
+afp-SATSolverVerification-2021-02-23.tar.gz
afp-Saturation_Framework-2020-04-10.tar.gz
afp-Saturation_Framework-2020-04-20.tar.gz
+afp-Saturation_Framework-2021-02-23.tar.gz
+afp-Saturation_Framework_Extensions-2021-02-23.tar.gz
+afp-SC_DOM_Components-2020-11-27.tar.gz
+afp-SC_DOM_Components-2021-02-23.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-SDS_Impossibility-2020-04-20.tar.gz
+afp-SDS_Impossibility-2021-02-23.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-Secondary_Sylow-2020-04-20.tar.gz
+afp-Secondary_Sylow-2021-02-23.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-Security_Protocol_Refinement-2020-04-20.tar.gz
+afp-Security_Protocol_Refinement-2021-02-23.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-Selection_Heap_Sort-2020-04-20.tar.gz
+afp-Selection_Heap_Sort-2021-02-23.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-SenSocialChoice-2020-04-20.tar.gz
+afp-SenSocialChoice-2021-02-23.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-Separata-2020-04-20.tar.gz
+afp-Separata-2021-02-23.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_Algebra-2020-04-20.tar.gz
+afp-Separation_Algebra-2021-02-23.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-Separation_Logic_Imperative_HOL-2020-04-20.tar.gz
+afp-Separation_Logic_Imperative_HOL-2021-02-23.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-SequentInvertibility-2020-04-20.tar.gz
+afp-SequentInvertibility-2021-02-23.tar.gz
+afp-Shadow_DOM-2021-02-23.tar.gz
+afp-Shadow_SC_DOM-2020-11-26.tar.gz
+afp-Shadow_SC_DOM-2021-02-23.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-Shivers-CFA-2020-04-20.tar.gz
+afp-Shivers-CFA-2021-02-23.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-ShortestPath-2020-04-20.tar.gz
+afp-ShortestPath-2021-02-23.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-Show-2020-04-20.tar.gz
+afp-Show-2021-02-23.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-SIFPL-2020-04-20.tar.gz
+afp-SIFPL-2021-02-23.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-SIFUM_Type_Systems-2020-04-20.tar.gz
+afp-SIFUM_Type_Systems-2021-02-23.tar.gz
afp-Sigma_Commit_Crypto-2019-10-08.tar.gz
afp-Sigma_Commit_Crypto-2020-04-20.tar.gz
+afp-Sigma_Commit_Crypto-2021-02-23.tar.gz
afp-Signature_Groebner-2018-09-20.tar.gz
afp-Signature_Groebner-2019-06-11.tar.gz
afp-Signature_Groebner-2020-04-20.tar.gz
+afp-Signature_Groebner-2021-02-23.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-Simpl-2020-04-20.tar.gz
+afp-Simpl-2021-02-23.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-Simple_Firewall-2020-04-20.tar.gz
+afp-Simple_Firewall-2021-02-23.tar.gz
afp-Simplex-2018-08-27.tar.gz
afp-Simplex-2019-06-11.tar.gz
afp-Simplex-2020-01-14.tar.gz
afp-Simplex-2020-04-20.tar.gz
+afp-Simplex-2021-02-23.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-Skew_Heap-2020-04-20.tar.gz
+afp-Skew_Heap-2021-02-23.tar.gz
afp-Skip_Lists-2020-01-10.tar.gz
afp-Skip_Lists-2020-04-20.tar.gz
+afp-Skip_Lists-2021-02-23.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-Slicing-2020-04-20.tar.gz
+afp-Slicing-2021-02-23.tar.gz
afp-Sliding_Window_Algorithm-2020-04-12.tar.gz
afp-Sliding_Window_Algorithm-2020-04-20.tar.gz
+afp-Sliding_Window_Algorithm-2021-02-23.tar.gz
+afp-Smith_Normal_Form-2020-05-25.tar.gz
+afp-Smith_Normal_Form-2021-02-23.tar.gz
afp-Smooth_Manifolds-2018-10-23.tar.gz
afp-Smooth_Manifolds-2019-06-11.tar.gz
afp-Smooth_Manifolds-2020-04-20.tar.gz
+afp-Smooth_Manifolds-2021-02-23.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-Sort_Encodings-2020-04-20.tar.gz
+afp-Sort_Encodings-2021-02-23.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-Source_Coding_Theorem-2020-04-20.tar.gz
+afp-Source_Coding_Theorem-2021-02-23.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-SPARCv8-2020-04-20.tar.gz
+afp-SPARCv8-2021-02-23.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-Special_Function_Bounds-2020-04-20.tar.gz
+afp-Special_Function_Bounds-2021-02-23.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-Splay_Tree-2020-04-20.tar.gz
+afp-Splay_Tree-2021-02-23.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-Sqrt_Babylonian-2020-04-20.tar.gz
+afp-Sqrt_Babylonian-2021-02-23.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-Stable_Matching-2020-04-20.tar.gz
+afp-Stable_Matching-2021-02-23.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-Statecharts-2020-04-20.tar.gz
+afp-Statecharts-2021-02-23.tar.gz
+afp-Stateful_Protocol_Composition_and_Typing-2020-05-20.tar.gz
+afp-Stateful_Protocol_Composition_and_Typing-2021-02-23.tar.gz
afp-Stellar_Quorums-2019-08-03.tar.gz
afp-Stellar_Quorums-2020-04-20.tar.gz
+afp-Stellar_Quorums-2021-02-23.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-Stern_Brocot-2020-04-20.tar.gz
+afp-Stern_Brocot-2021-02-23.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-Stewart_Apollonius-2020-04-20.tar.gz
+afp-Stewart_Apollonius-2021-02-23.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-Stirling_Formula-2020-04-20.tar.gz
+afp-Stirling_Formula-2021-02-23.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-Stochastic_Matrices-2020-04-20.tar.gz
+afp-Stochastic_Matrices-2021-02-23.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_Algebras-2019-06-28.tar.gz
afp-Stone_Algebras-2020-04-20.tar.gz
+afp-Stone_Algebras-2021-02-23.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_Kleene_Relation_Algebras-2020-04-20.tar.gz
+afp-Stone_Kleene_Relation_Algebras-2021-02-23.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-Stone_Relation_Algebras-2020-04-20.tar.gz
+afp-Stone_Relation_Algebras-2021-02-23.tar.gz
afp-Store_Buffer_Reduction-2019-01-11.tar.gz
afp-Store_Buffer_Reduction-2019-06-11.tar.gz
afp-Store_Buffer_Reduction-2020-04-20.tar.gz
+afp-Store_Buffer_Reduction-2021-02-23.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-2020-04-20.tar.gz
+afp-Stream-Fusion-2021-02-23.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-Stream_Fusion_Code-2020-04-20.tar.gz
+afp-Stream_Fusion_Code-2021-02-23.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-Strong_Security-2020-04-20.tar.gz
+afp-Strong_Security-2021-02-23.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_Sequences-2020-04-20.tar.gz
+afp-Sturm_Sequences-2021-02-23.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-Sturm_Tarski-2020-04-20.tar.gz
+afp-Sturm_Tarski-2021-02-23.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-Stuttering_Equivalence-2020-04-20.tar.gz
+afp-Stuttering_Equivalence-2021-02-23.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-Subresultants-2020-04-20.tar.gz
+afp-Subresultants-2021-02-23.tar.gz
afp-Subset_Boolean_Algebras-2020-01-31.tar.gz
afp-Subset_Boolean_Algebras-2020-04-20.tar.gz
+afp-Subset_Boolean_Algebras-2021-02-23.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-SumSquares-2020-04-20.tar.gz
+afp-SumSquares-2021-02-23.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-SuperCalc-2020-04-20.tar.gz
+afp-SuperCalc-2021-02-23.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-Surprise_Paradox-2020-04-20.tar.gz
+afp-Surprise_Paradox-2021-02-23.tar.gz
afp-Symmetric_Polynomials-2018-09-26.tar.gz
afp-Symmetric_Polynomials-2019-06-11.tar.gz
afp-Symmetric_Polynomials-2020-04-20.tar.gz
+afp-Symmetric_Polynomials-2021-02-23.tar.gz
+afp-Syntax_Independent_Logic-2020-09-18.tar.gz
+afp-Syntax_Independent_Logic-2021-02-23.tar.gz
afp-Szpilrajn-2019-07-28.tar.gz
afp-Szpilrajn-2020-04-20.tar.gz
+afp-Szpilrajn-2021-02-23.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-Tail_Recursive_Functions-2020-04-20.tar.gz
+afp-Tail_Recursive_Functions-2021-02-23.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-Tarskis_Geometry-2020-04-20.tar.gz
+afp-Tarskis_Geometry-2021-02-23.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-Taylor_Models-2020-04-20.tar.gz
+afp-Taylor_Models-2021-02-23.tar.gz
afp-TESL_Language-2019-07-31.tar.gz
afp-TESL_Language-2020-04-20.tar.gz
+afp-TESL_Language-2021-02-23.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-Timed_Automata-2020-04-20.tar.gz
+afp-Timed_Automata-2021-02-23.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-TLA-2020-04-20.tar.gz
+afp-TLA-2021-02-23.tar.gz
+afp-Topological_Semantics-2020-12-22.tar.gz
+afp-Topological_Semantics-2021-02-23.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-Topology-2020-04-20.tar.gz
+afp-Topology-2021-02-23.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-TortoiseHare-2020-04-20.tar.gz
+afp-TortoiseHare-2021-02-23.tar.gz
afp-Transcendence_Series_Hancl_Rucki-2019-03-28.tar.gz
afp-Transcendence_Series_Hancl_Rucki-2019-06-11.tar.gz
afp-Transcendence_Series_Hancl_Rucki-2020-04-20.tar.gz
+afp-Transcendence_Series_Hancl_Rucki-2021-02-23.tar.gz
afp-Transformer_Semantics-2018-12-19.tar.gz
afp-Transformer_Semantics-2019-06-11.tar.gz
afp-Transformer_Semantics-2020-04-20.tar.gz
+afp-Transformer_Semantics-2021-02-23.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-Transition_Systems_and_Automata-2020-04-20.tar.gz
+afp-Transition_Systems_and_Automata-2021-02-23.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-2020-04-20.tar.gz
+afp-Transitive-Closure-2021-02-23.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-Transitive-Closure-II-2020-04-20.tar.gz
+afp-Transitive-Closure-II-2021-02-23.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-Treaps-2020-04-20.tar.gz
+afp-Treaps-2021-02-23.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-Automata-2020-04-20.tar.gz
+afp-Tree-Automata-2021-02-23.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-Tree_Decomposition-2020-04-20.tar.gz
+afp-Tree_Decomposition-2021-02-23.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-Triangle-2020-04-20.tar.gz
+afp-Triangle-2021-02-23.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-Trie-2020-04-20.tar.gz
+afp-Trie-2021-02-23.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-Twelvefold_Way-2020-04-20.tar.gz
+afp-Twelvefold_Way-2021-02-23.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-Tycon-2020-04-20.tar.gz
+afp-Tycon-2021-02-23.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-Types_Tableaus_and_Goedels_God-2020-04-20.tar.gz
+afp-Types_Tableaus_and_Goedels_God-2021-02-23.tar.gz
afp-Universal_Turing_Machine-2019-02-12.tar.gz
afp-Universal_Turing_Machine-2019-06-11.tar.gz
afp-Universal_Turing_Machine-2020-04-20.tar.gz
+afp-Universal_Turing_Machine-2021-02-23.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-UpDown_Scheme-2020-04-20.tar.gz
+afp-UpDown_Scheme-2021-02-23.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-2020-04-20.tar.gz
+afp-UPF-2021-02-23.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-UPF_Firewall-2020-04-20.tar.gz
+afp-UPF_Firewall-2021-02-23.tar.gz
afp-UTP-2019-02-06.tar.gz
afp-UTP-2019-06-11.tar.gz
afp-UTP-2020-04-20.tar.gz
+afp-UTP-2021-02-23.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-Valuation-2020-04-20.tar.gz
+afp-Valuation-2021-02-23.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-VectorSpace-2020-04-20.tar.gz
+afp-VectorSpace-2021-02-23.tar.gz
afp-VeriComp-2020-02-25.tar.gz
afp-VeriComp-2020-04-20.tar.gz
+afp-VeriComp-2021-02-23.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-Verified-Prover-2020-04-20.tar.gz
+afp-Verified-Prover-2021-02-23.tar.gz
+afp-Verified_SAT_Based_AI_Planning-2020-11-03.tar.gz
+afp-Verified_SAT_Based_AI_Planning-2020-11-13.tar.gz
+afp-Verified_SAT_Based_AI_Planning-2021-02-23.tar.gz
afp-VerifyThis2018-2018-04-30.tar.gz
afp-VerifyThis2018-2018-08-16.tar.gz
afp-VerifyThis2018-2019-06-11.tar.gz
afp-VerifyThis2018-2020-04-20.tar.gz
+afp-VerifyThis2018-2021-02-23.tar.gz
afp-VerifyThis2019-2019-10-25.tar.gz
afp-VerifyThis2019-2020-04-20.tar.gz
+afp-VerifyThis2019-2021-02-23.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-Vickrey_Clarke_Groves-2020-04-20.tar.gz
+afp-Vickrey_Clarke_Groves-2021-02-23.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-VolpanoSmith-2020-04-20.tar.gz
+afp-VolpanoSmith-2021-02-23.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-WebAssembly-2020-04-20.tar.gz
+afp-WebAssembly-2021-02-23.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-Weight_Balanced_Trees-2020-04-20.tar.gz
+afp-Weight_Balanced_Trees-2021-02-23.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-Well_Quasi_Orders-2020-04-20.tar.gz
+afp-Well_Quasi_Orders-2021-02-23.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-WHATandWHERE_Security-2020-04-20.tar.gz
+afp-WHATandWHERE_Security-2021-02-23.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-Winding_Number_Eval-2020-04-20.tar.gz
+afp-Winding_Number_Eval-2021-02-23.tar.gz
afp-WOOT_Strong_Eventual_Consistency-2020-03-26.tar.gz
afp-WOOT_Strong_Eventual_Consistency-2020-04-20.tar.gz
+afp-WOOT_Strong_Eventual_Consistency-2021-02-23.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-Word_Lib-2020-04-20.tar.gz
+afp-Word_Lib-2021-02-23.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-WorkerWrapper-2020-04-20.tar.gz
+afp-WorkerWrapper-2021-02-23.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-XML-2020-04-20.tar.gz
+afp-XML-2021-02-23.tar.gz
afp-Zeta_3_Irrational-2019-12-28.tar.gz
afp-Zeta_3_Irrational-2020-04-20.tar.gz
+afp-Zeta_3_Irrational-2021-02-23.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
afp-Zeta_Function-2020-04-20.tar.gz
+afp-Zeta_Function-2021-02-23.tar.gz
afp-ZFC_in_HOL-2019-11-04.tar.gz
afp-ZFC_in_HOL-2020-04-20.tar.gz
+afp-ZFC_in_HOL-2021-02-23.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,58 @@
{% 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 Isabelle2020, 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>
+If you are using Isabelle2021, and have downloaded your AFP directory to
+<code>/home/myself/afp</code>, for Linux/Mac you can run the following command to make the AFP session ROOTS available to Isabelle:</p>
<p>
<pre class="code">
- echo "/home/myself/afp/thys" >> ~/.isabelle/Isabelle2020/ROOTS
+ echo "/home/myself/afp/thys" >> ~/.isabelle/Isabelle2021/ROOTS
</pre>
+This adds the path <code>/home/myself/afp/thys/</code> to the ROOTS file, which
+Isabelle will scan by default. You can also manually edit and/or create that
+ROOTS file. There are many other ways to achieve the same outcome, this is just
+one option.
+</p>
+<p>
+For Windows, the idea is the same just the path is slightly different. If the
+AFP is in <code>C:\afp</code>, you should be able to run the following in a
+Cygwin terminal.
+<pre class="code">
+ echo "/cygdrive/c/afp/thys" >> ~/.isabelle/Isabelle2021/ROOTS
+</pre>
+</p>
<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>&nbsp;</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/BTree/Array_SBlit.thy b/thys/BTree/Array_SBlit.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/Array_SBlit.thy
@@ -0,0 +1,269 @@
+theory Array_SBlit
+ imports "Separation_Logic_Imperative_HOL.Array_Blit"
+begin
+
+section "Same array Blit"
+
+text "The standard framework already provides a function to copy array
+ elements."
+
+term blit
+thm blit_rule
+thm blit.simps
+ (* Same array BLIT *)
+definition "sblit a s d l \<equiv> blit a s a d l"
+
+text "When copying values within arrays,
+ blit only works for moving elements to the left."
+
+lemma sblit_rule[sep_heap_rules]:
+ assumes LEN:
+ "si+len \<le> length lsrc"
+ and DST_SM: "di \<le> si"
+ shows
+ "< src \<mapsto>\<^sub>a lsrc >
+ sblit src si di len
+ <\<lambda>_. src \<mapsto>\<^sub>a (take di lsrc @ take len (drop si lsrc) @ drop (di+len) lsrc)
+ >"
+ unfolding sblit_def
+ using LEN DST_SM
+proof (induction len arbitrary: lsrc si di)
+ case 0 thus ?case by sep_auto
+next
+ case (Suc len)
+ note [sep_heap_rules] = Suc.IH
+
+ have [simp]: "\<And>x. lsrc ! si # take len (drop (Suc si) lsrc) @ x
+ = take (Suc len) (drop si lsrc) @ x"
+ apply simp
+ by (metis Suc.prems(1) add_Suc_right Cons_nth_drop_Suc
+ less_Suc_eq_le add.commute not_less_eq take_Suc_Cons
+ Nat.trans_le_add2)
+
+ from Suc.prems show ?case
+ by (sep_auto simp: take_update_last drop_upd_irrelevant)
+qed
+
+subsection "A reverse blit"
+
+text "The function rblit may be used to copy elements a defined offset to the right"
+
+(* Right BLIT or Reverse BLIT *)
+primrec rblit :: "_ array \<Rightarrow> nat \<Rightarrow> _ array \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow> unit Heap" where
+ "rblit _ _ _ _ 0 = return ()"
+| "rblit src si dst di (Suc l) = do {
+ x \<leftarrow> Array.nth src (si+l);
+ Array.upd (di+l) x dst;
+ rblit src si dst di l
+ }"
+
+text "For separated arrays it is equivalent to normal blit.
+ The proof follows similarly to the corresponding proof for blit."
+
+lemma rblit_rule[sep_heap_rules]:
+ assumes LEN: "si+len \<le> length lsrc" "di+len \<le> length ldst"
+ shows
+ "< src \<mapsto>\<^sub>a lsrc
+ * dst \<mapsto>\<^sub>a ldst >
+ rblit src si dst di len
+ <\<lambda>_. src \<mapsto>\<^sub>a lsrc
+ * dst \<mapsto>\<^sub>a (take di ldst @ take len (drop si lsrc) @ drop (di+len) ldst)
+ >"
+ using LEN
+proof (induction len arbitrary: ldst)
+ case 0 thus ?case by sep_auto
+next
+ case (Suc len)
+ note [sep_heap_rules] = Suc.IH
+
+ have [simp]: "drop (di + len) (ldst[di + len := lsrc ! (si + len)])
+ = lsrc ! (si + len) # drop (Suc (di + len)) ldst"
+ by (metis Cons_nth_drop_Suc Suc.prems(2) Suc_le_eq add_Suc_right drop_upd_irrelevant length_list_update lessI nth_list_update_eq)
+
+ have "take len (drop si lsrc) @ [lsrc ! (si + len)] = take (Suc len) (drop si lsrc)"
+ proof -
+ have "len < length (drop si lsrc)"
+ using Suc.prems(1) by force
+ then show "take len (drop si lsrc) @ [lsrc ! (si + len)] = take (Suc len) (drop si lsrc)"
+ by (metis (no_types) Suc.prems(1) add_leD1 nth_drop take_Suc_conv_app_nth)
+ qed
+ then have [simp]: "\<And>x. take len (drop si lsrc) @
+ lsrc ! (si + len) # x = take (Suc len) (drop si lsrc) @ x"
+ by simp
+ from Suc.prems show ?case
+ by (sep_auto simp: take_update_last drop_upd_irrelevant)
+qed
+
+definition "srblit a s d l \<equiv> rblit a s a d l"
+
+text "However, within arrays we can now copy to the right."
+
+lemma srblit_rule[sep_heap_rules]:
+ assumes LEN:
+ "di+len \<le> length lsrc"
+ and DST_GR: "di \<ge> si"
+ shows
+ "< src \<mapsto>\<^sub>a lsrc >
+ srblit src si di len
+ <\<lambda>_. src \<mapsto>\<^sub>a (take di lsrc @ take len (drop si lsrc) @ drop (di+len) lsrc)
+ >"
+ unfolding srblit_def
+ using LEN DST_GR
+proof (induction len arbitrary: lsrc si di)
+ case 0 thus ?case by sep_auto
+next
+ case (Suc len)
+ note [sep_heap_rules] = Suc.IH
+
+ have[simp]: "take len (drop si (lsrc[di + len := lsrc ! (si + len)]))
+ = take len (drop si lsrc)"
+ sledgehammer
+ by (metis Suc.prems(2) ab_semigroup_add_class.add.commute add_le_cancel_right take_drop take_update_cancel)
+ have [simp]: "drop (di + len) (lsrc[di + len := lsrc ! (si + len)])
+ = lsrc ! (si+len) # drop (Suc di + len) lsrc"
+ by (metis Suc.prems(1) add_Suc_right add_Suc_shift add_less_cancel_left append_take_drop_id le_imp_less_Suc le_refl plus_1_eq_Suc same_append_eq take_update_cancel upd_conv_take_nth_drop)
+ have "take len (drop si lsrc) @
+ [lsrc ! (si + len)] = take (Suc len) (drop si lsrc)"
+ proof -
+ have "len < length lsrc - si"
+ using Suc.prems(1) Suc.prems(2) by linarith
+ then show ?thesis
+ by (metis (no_types) Suc.prems(1) Suc.prems(2) add_leD1 le_add_diff_inverse length_drop nth_drop take_Suc_conv_app_nth)
+ qed
+ then have [simp]: "\<And>x. take len (drop si lsrc) @
+ lsrc ! (si + len) # x = take (Suc len) (drop si lsrc) @ x"
+ by simp
+ from Suc.prems show ?case
+ by (sep_auto simp: take_update_last drop_upd_irrelevant)
+qed
+
+subsection "Modeling target language blit"
+
+text "For convenience, a function that is oblivious to the direction of the shift
+ is defined."
+definition "safe_sblit a s d l \<equiv>
+ if s > d then
+ sblit a s d l
+ else
+ srblit a s d l
+"
+
+text "We obtain a heap rule similar to the one of blit,
+ but for copying within one array."
+
+lemma safe_sblit_rule[sep_heap_rules]:
+ assumes LEN:
+ "len > 0 \<longrightarrow> di+len \<le> length lsrc \<and> si+len \<le> length lsrc"
+ shows
+ "< src \<mapsto>\<^sub>a lsrc >
+ safe_sblit src si di len
+ <\<lambda>_. src \<mapsto>\<^sub>a (take di lsrc @ take len (drop si lsrc) @ drop (di+len) lsrc)
+ >"
+ unfolding safe_sblit_def
+ using LEN
+ apply(cases len)
+ apply(sep_auto simp add: sblit_def srblit_def)[]
+ apply sep_auto
+ done
+
+(* Compare this to blit_rule *)
+thm blit_rule
+thm safe_sblit_rule
+
+subsection "Code Generator Setup"
+
+text "Note that the requirement for correctness
+ is even weaker here than in SML.
+ We therefore manually handle the case where length is 0 (in which case nothing happens at all)."
+
+code_printing code_module "array_sblit" \<rightharpoonup> (SML)
+ \<open>
+ fun array_sblit src si di len = (
+ if len > 0 then
+ ArraySlice.copy {
+ di = IntInf.toInt di,
+ src = ArraySlice.slice (src,IntInf.toInt si,SOME (IntInf.toInt len)),
+ dst = src}
+ else ()
+ )
+\<close>
+
+definition safe_sblit' where
+ [code del]: "safe_sblit' src si di len
+ = safe_sblit src (nat_of_integer si) (nat_of_integer di)
+ (nat_of_integer len)"
+
+lemma [code]:
+ "safe_sblit src si di len
+ = safe_sblit' src (integer_of_nat si) (integer_of_nat di)
+ (integer_of_nat len)" by (simp add: safe_sblit'_def)
+
+(* TODO: Export to other languages: OCaml, Haskell *)
+code_printing constant safe_sblit' \<rightharpoonup>
+ (SML) "(fn/ ()/ => /array'_sblit _ _ _ _)"
+ and (Scala) "{ ('_: Unit)/=>/
+ def safescopy(src: Array['_], srci: Int, dsti: Int, len: Int) = {
+ if (len > 0)
+ System.arraycopy(src, srci, src, dsti, len)
+ else
+ ()
+ }
+ safescopy(_.array,_.toInt,_.toInt,_.toInt)
+ }"
+
+export_code safe_sblit checking SML Scala
+
+
+subsection "Derived operations"
+
+definition array_shr where
+ "array_shr a i k \<equiv> do {
+ l \<leftarrow> Array.len a;
+ safe_sblit a i (i+k) (l-(i+k))
+}"
+
+find_theorems "Array.len"
+
+lemma array_shr_rule[sep_heap_rules]:
+ "< src \<mapsto>\<^sub>a lsrc >
+ array_shr src i k
+ <\<lambda>_. src \<mapsto>\<^sub>a (take (i+k) lsrc @ take (length lsrc - (i+k)) (drop i lsrc))
+ >"
+ unfolding array_shr_def
+ by sep_auto
+
+lemma array_shr_rule_alt:
+ "< src \<mapsto>\<^sub>a lsrc >
+ array_shr src i k
+ <\<lambda>_. src \<mapsto>\<^sub>a (take (length lsrc) (take (i+k) lsrc @ (drop i lsrc)))
+ >"
+ by (sep_auto simp add: min_def)
+
+definition array_shl where
+ "array_shl a i k \<equiv> do {
+ l \<leftarrow> Array.len a;
+ safe_sblit a i (i-k) (l-i)
+}
+"
+
+lemma array_shl_rule[sep_heap_rules]:
+ "
+ < src \<mapsto>\<^sub>a lsrc >
+ array_shl src i k
+ <\<lambda>_. src \<mapsto>\<^sub>a (take (i-k) lsrc @ (drop i lsrc) @ drop (i - k + (length lsrc - i)) lsrc)
+ >"
+ unfolding array_shl_def
+ by sep_auto
+
+
+lemma array_shl_rule_alt:
+ "
+ \<lbrakk>i \<le> length lsrc; k \<le> i\<rbrakk> \<Longrightarrow>
+ < src \<mapsto>\<^sub>a lsrc >
+ array_shl src i k
+ <\<lambda>_. src \<mapsto>\<^sub>a (take (i-k) lsrc @ (drop i lsrc) @ drop (length lsrc - k) lsrc)
+ >"
+ by sep_auto
+
+
+end
\ No newline at end of file
diff --git a/thys/BTree/BTree.thy b/thys/BTree/BTree.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/BTree.thy
@@ -0,0 +1,255 @@
+theory BTree
+ imports Main "HOL-Data_Structures.Sorted_Less" "HOL-Data_Structures.Cmp"
+begin
+
+(* some setup to cover up the redefinition of sorted in Sorted_Less
+ but keep the lemmas *)
+hide_const (open) Sorted_Less.sorted
+abbreviation "sorted_less \<equiv> Sorted_Less.sorted"
+
+section "Definition of the B-Tree"
+
+subsection "Datatype definition"
+
+text "B-trees can be considered to have all data stored interleaved
+as child nodes and separating elements (also keys or indices).
+We define them to either be a Node that holds a list of pairs of children
+and indices or be a completely empty Leaf."
+
+
+datatype 'a btree = Leaf | Node "('a btree * 'a) list" "'a btree"
+
+type_synonym 'a btree_list = "('a btree * 'a) list"
+type_synonym 'a btree_pair = "('a btree * 'a)"
+
+abbreviation subtrees where "subtrees xs \<equiv> (map fst xs)"
+abbreviation separators where "separators xs \<equiv> (map snd xs)"
+
+subsection "Inorder and Set"
+
+text "The set of B-tree elements is defined automatically."
+
+thm btree.set
+value "set_btree (Node [(Leaf, (0::nat)), (Node [(Leaf, 1), (Leaf, 10)] Leaf, 12), (Leaf, 30), (Leaf, 100)] Leaf)"
+
+text "The inorder view is defined with the help of the concat function."
+
+fun inorder :: "'a btree \<Rightarrow> 'a list" where
+ "inorder Leaf = []" |
+ "inorder (Node ts t) = concat (map (\<lambda> (sub, sep). inorder sub @ [sep]) ts) @ inorder t"
+
+abbreviation "inorder_pair \<equiv> \<lambda>(sub,sep). inorder sub @ [sep]"
+abbreviation "inorder_list ts \<equiv> concat (map inorder_pair ts)"
+
+(* this abbreviation makes handling the list much nicer *)
+thm inorder.simps
+
+value "inorder (Node [(Leaf, (0::nat)), (Node [(Leaf, 1), (Leaf, 10)] Leaf, 12), (Leaf, 30), (Leaf, 100)] Leaf)"
+
+subsection "Height and Balancedness"
+
+class height =
+ fixes height :: "'a \<Rightarrow> nat"
+
+instantiation btree :: (type) height
+begin
+
+fun height_btree :: "'a btree \<Rightarrow> nat" where
+ "height Leaf = 0" |
+ "height (Node ts t) = Suc (Max (height ` (set (subtrees ts@[t]))))"
+
+instance ..
+
+end
+
+text "Balancedness is defined is close accordance to the definition by Ernst"
+
+fun bal:: "'a btree \<Rightarrow> bool" where
+ "bal Leaf = True" |
+ "bal (Node ts t) = (
+ (\<forall>sub \<in> set (subtrees ts). height sub = height t) \<and>
+ (\<forall>sub \<in> set (subtrees ts). bal sub) \<and> bal t
+ )"
+
+
+value "height (Node [(Leaf, (0::nat)), (Node [(Leaf, 1), (Leaf, 10)] Leaf, 12), (Leaf, 30), (Leaf, 100)] Leaf)"
+
+
+subsection "Order"
+
+text "The order of a B-tree is defined just as in the original paper by Bayer."
+
+(* alt1: following knuths definition to allow for any
+ natural number as order and resolve ambiguity *)
+(* alt2: use range [k,2*k] allowing for valid btrees
+ from k=1 onwards NOTE this is what I ended up implementing *)
+
+fun order:: "nat \<Rightarrow> 'a btree \<Rightarrow> bool" where
+ "order k Leaf = True" |
+ "order k (Node ts t) = (
+ (length ts \<ge> k) \<and>
+ (length ts \<le> 2*k) \<and>
+ (\<forall>sub \<in> set (subtrees ts). order k sub) \<and> order k t
+)"
+
+text \<open>The special condition for the root is called \textit{root\_order}\<close>
+
+(* the invariant for the root of the btree *)
+fun root_order:: "nat \<Rightarrow> 'a btree \<Rightarrow> bool" where
+ "root_order k Leaf = True" |
+ "root_order k (Node ts t) = (
+ (length ts > 0) \<and>
+ (length ts \<le> 2*k) \<and>
+ (\<forall>s \<in> set (subtrees ts). order k s) \<and> order k t
+)"
+
+
+subsection "Auxiliary Lemmas"
+
+(* auxiliary lemmas when handling sets *)
+lemma separators_split:
+ "set (separators (l@(a,b)#r)) = set (separators l) \<union> set (separators r) \<union> {b}"
+ by simp
+
+lemma subtrees_split:
+ "set (subtrees (l@(a,b)#r)) = set (subtrees l) \<union> set (subtrees r) \<union> {a}"
+ by simp
+
+(* height and set lemmas *)
+
+
+lemma finite_set_ins_swap:
+ assumes "finite A"
+ shows "max a (Max (Set.insert b A)) = max b (Max (Set.insert a A))"
+ using Max_insert assms max.commute max.left_commute by fastforce
+
+lemma finite_set_in_idem:
+ assumes "finite A"
+ shows "max a (Max (Set.insert a A)) = Max (Set.insert a A)"
+ using Max_insert assms max.commute max.left_commute by fastforce
+
+lemma height_Leaf: "height t = 0 \<longleftrightarrow> t = Leaf"
+ by (induction t) (auto)
+
+lemma height_btree_order:
+ "height (Node (ls@[a]) t) = height (Node (a#ls) t)"
+ by simp
+
+lemma height_btree_sub:
+ "height (Node ((sub,x)#ls) t) = max (height (Node ls t)) (Suc (height sub))"
+ by simp
+
+lemma height_btree_last:
+ "height (Node ((sub,x)#ts) t) = max (height (Node ts sub)) (Suc (height t))"
+ by (induction ts) auto
+
+
+lemma set_btree_inorder: "set (inorder t) = set_btree t"
+ apply(induction t)
+ apply(auto)
+ done
+
+
+lemma child_subset: "p \<in> set t \<Longrightarrow> set_btree (fst p) \<subseteq> set_btree (Node t n)"
+ apply(induction p arbitrary: t n)
+ apply(auto)
+ done
+
+lemma some_child_sub:
+ assumes "(sub,sep) \<in> set t"
+ shows "sub \<in> set (subtrees t)"
+ and "sep \<in> set (separators t)"
+ using assms by force+
+
+(* balancedness lemmas *)
+
+
+lemma bal_all_subtrees_equal: "bal (Node ts t) \<Longrightarrow> (\<forall>s1 \<in> set (subtrees ts). \<forall>s2 \<in> set (subtrees ts). height s1 = height s2)"
+ by (metis BTree.bal.simps(2))
+
+
+lemma fold_max_set: "\<forall>x \<in> set t. x = f \<Longrightarrow> fold max t f = f"
+ apply(induction t)
+ apply(auto simp add: max_def_raw)
+ done
+
+lemma height_bal_tree: "bal (Node ts t) \<Longrightarrow> height (Node ts t) = Suc (height t)"
+ by (induction ts) auto
+
+
+
+lemma bal_split_last:
+ assumes "bal (Node (ls@(sub,sep)#rs) t)"
+ shows "bal (Node (ls@rs) t)"
+ and "height (Node (ls@(sub,sep)#rs) t) = height (Node (ls@rs) t)"
+ using assms by auto
+
+
+lemma bal_split_right:
+ assumes "bal (Node (ls@rs) t)"
+ shows "bal (Node rs t)"
+ and "height (Node rs t) = height (Node (ls@rs) t)"
+ using assms by (auto simp add: image_constant_conv)
+
+lemma bal_split_left:
+ assumes "bal (Node (ls@(a,b)#rs) t)"
+ shows "bal (Node ls a)"
+ and "height (Node ls a) = height (Node (ls@(a,b)#rs) t)"
+ using assms by (auto simp add: image_constant_conv)
+
+
+lemma bal_substitute: "\<lbrakk>bal (Node (ls@(a,b)#rs) t); height t = height c; bal c\<rbrakk> \<Longrightarrow> bal (Node (ls@(c,b)#rs) t)"
+ unfolding bal.simps
+ by auto
+
+lemma bal_substitute_subtree: "\<lbrakk>bal (Node (ls@(a,b)#rs) t); height a = height c; bal c\<rbrakk> \<Longrightarrow> bal (Node (ls@(c,b)#rs) t)"
+ using bal_substitute
+ by auto
+
+lemma bal_substitute_separator: "bal (Node (ls@(a,b)#rs) t) \<Longrightarrow> bal (Node (ls@(a,c)#rs) t)"
+ unfolding bal.simps
+ by auto
+
+(* order lemmas *)
+
+lemma order_impl_root_order: "\<lbrakk>k > 0; order k t\<rbrakk> \<Longrightarrow> root_order k t"
+ apply(cases t)
+ apply(auto)
+ done
+
+
+(* sorted inorder implies that some sublists are sorted. This can be followed directly *)
+
+lemma sorted_inorder_list_separators: "sorted_less (inorder_list ts) \<Longrightarrow> sorted_less (separators ts)"
+ apply(induction ts)
+ apply (auto simp add: sorted_lems)
+ done
+
+corollary sorted_inorder_separators: "sorted_less (inorder (Node ts t)) \<Longrightarrow> sorted_less (separators ts)"
+ using sorted_inorder_list_separators sorted_wrt_append
+ by auto
+
+
+lemma sorted_inorder_list_subtrees:
+ "sorted_less (inorder_list ts) \<Longrightarrow> \<forall> sub \<in> set (subtrees ts). sorted_less (inorder sub)"
+ apply(induction ts)
+ apply (auto simp add: sorted_lems)+
+ done
+
+corollary sorted_inorder_subtrees: "sorted_less (inorder (Node ts t)) \<Longrightarrow> \<forall> sub \<in> set (subtrees ts). sorted_less (inorder sub)"
+ using sorted_inorder_list_subtrees sorted_wrt_append by auto
+
+lemma sorted_inorder_list_induct_subtree:
+ "sorted_less (inorder_list (ls@(sub,sep)#rs)) \<Longrightarrow> sorted_less (inorder sub)"
+ by (simp add: sorted_wrt_append)
+
+corollary sorted_inorder_induct_subtree:
+ "sorted_less (inorder (Node (ls@(sub,sep)#rs) t)) \<Longrightarrow> sorted_less (inorder sub)"
+ by (simp add: sorted_wrt_append)
+
+lemma sorted_inorder_induct_last: "sorted_less (inorder (Node ts t)) \<Longrightarrow> sorted_less (inorder t)"
+ by (simp add: sorted_wrt_append)
+
+
+
+end
\ No newline at end of file
diff --git a/thys/BTree/BTree_Height.thy b/thys/BTree/BTree_Height.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/BTree_Height.thy
@@ -0,0 +1,351 @@
+theory BTree_Height
+ imports BTree
+begin
+
+section "Maximum and minimum height"
+
+text "Textbooks usually provide some proofs relating the maxmimum and minimum height of the BTree
+for a given number of nodes. We therefore introduce this counting and show the respective proofs."
+
+subsection "Definition of node/size"
+
+thm BTree.btree.size
+ (* the automatically derived size is a bit weird for our purposes *)
+value "size (Node [(Leaf, (0::nat)), (Node [(Leaf, 1), (Leaf, 10)] Leaf, 12), (Leaf, 30), (Leaf, 100)] Leaf)"
+
+
+text "The default size function does not suit our needs as it regards the length of the list in each node.
+ We would like to count the number of nodes in the tree only, not regarding the number of keys."
+
+(* we want a different counting method,
+ namely only the number of nodes in a tree *)
+
+(* TODO what if we count Leafs as nodes? *)
+
+fun nodes::"'a btree \<Rightarrow> nat" where
+ "nodes Leaf = 0" |
+ "nodes (Node ts t) = 1 + (\<Sum>t\<leftarrow>subtrees ts. nodes t) + (nodes t)"
+
+value "nodes (Node [(Leaf, (0::nat)), (Node [(Leaf, 1), (Leaf, 10)] Leaf, 12), (Leaf, 30), (Leaf, 100)] Leaf)"
+
+
+(* maximum number of nodes for given height *)
+subsection "Maximum number of nodes for a given height"
+
+
+lemma sum_list_replicate: "sum_list (replicate n c) = n*c"
+ apply(induction n)
+ apply(auto simp add: ring_class.ring_distribs(2))
+ done
+
+abbreviation "bound k h \<equiv> ((k+1)^h - 1)"
+
+lemma nodes_height_upper_bound:
+ "\<lbrakk>order k t; bal t\<rbrakk> \<Longrightarrow> nodes t * (2*k) \<le> bound (2*k) (height t)"
+proof(induction t rule: nodes.induct)
+ case (2 ts t)
+ let ?sub_height = "((2 * k + 1) ^ height t - 1)"
+ have "sum_list (map nodes (subtrees ts)) * (2*k) =
+ sum_list (map (\<lambda>t. nodes t * (2 * k)) (subtrees ts))"
+ using sum_list_mult_const by metis
+ also have "\<dots> \<le> sum_list (map (\<lambda>x.?sub_height) (subtrees ts))"
+ using 2
+ using sum_list_mono[of "subtrees ts" "\<lambda>t. nodes t * (2 * k)" "\<lambda>x. bound (2 * k) (height t)"]
+ by (metis bal.simps(2) order.simps(2))
+ also have "\<dots> = sum_list (replicate (length ts) ?sub_height)"
+ using map_replicate_const[of ?sub_height "subtrees ts"] length_map
+ by simp
+ also have "\<dots> = (length ts)*(?sub_height)"
+ using sum_list_replicate by simp
+ also have "\<dots> \<le> (2*k)*(?sub_height)"
+ using "2.prems"(1)
+ by simp
+ finally have "sum_list (map nodes (subtrees ts))*(2*k) \<le> ?sub_height*(2*k)"
+ by simp
+ moreover have "(nodes t)*(2*k) \<le> ?sub_height"
+ using 2 by simp
+ ultimately have "(nodes (Node ts t))*(2*k) \<le>
+ 2*k
+ + ?sub_height * (2*k)
+ + ?sub_height"
+ unfolding nodes.simps add_mult_distrib
+ by linarith
+ also have "\<dots> = 2*k + (2*k)*((2 * k + 1) ^ height t) - 2*k + (2 * k + 1) ^ height t - 1"
+ by (simp add: diff_mult_distrib2 mult.assoc mult.commute)
+ also have "\<dots> = (2*k)*((2 * k + 1) ^ height t) + (2 * k + 1) ^ height t - 1"
+ by simp
+ also have "\<dots> = (2*k+1)^(Suc(height t)) - 1"
+ by simp
+ finally show ?case
+ by (metis "2.prems"(2) height_bal_tree)
+qed simp
+
+text "To verify our lower bound is sharp, we compare it to the height of artificially constructed
+full trees."
+
+fun full_node::"nat \<Rightarrow> 'a \<Rightarrow> nat \<Rightarrow> 'a btree" where
+ "full_node k c 0 = Leaf"|
+ "full_node k c (Suc n) = (Node (replicate (2*k) ((full_node k c n),c)) (full_node k c n))"
+
+value "let k = (2::nat) in map (\<lambda>x. nodes x * 2*k) (map (full_node k (1::nat)) [0,1,2,3,4])"
+value "let k = (2::nat) in map (\<lambda>x. ((2*k+(1::nat))^(x)-1)) [0,1,2,3,4]"
+
+lemma compow_comp_id: "c > 0 \<Longrightarrow> f \<circ> f = f \<Longrightarrow> (f ^^ c) = f"
+ apply(induction c)
+ apply auto
+ by fastforce
+
+(* required only for the fold definition of height *)
+lemma compow_id_point: "f x = x \<Longrightarrow> (f ^^ c) x = x"
+ apply(induction c)
+ apply auto
+ done
+
+lemma height_full_node: "height (full_node k a h) = h"
+ apply(induction k a h rule: full_node.induct)
+ apply (auto simp add: set_replicate_conv_if)
+ done
+
+lemma bal_full_node: "bal (full_node k a h)"
+ apply(induction k a h rule: full_node.induct)
+ apply auto
+ done
+
+lemma order_full_node: "order k (full_node k a h)"
+ apply(induction k a h rule: full_node.induct)
+ apply auto
+ done
+
+lemma full_btrees_sharp: "nodes (full_node k a h) * (2*k) = bound (2*k) h"
+ apply(induction k a h rule: full_node.induct)
+ apply (auto simp add: height_full_node algebra_simps sum_list_replicate)
+ done
+
+lemma upper_bound_sharp_node:
+ "t = full_node k a h \<Longrightarrow> height t = h \<and> order k t \<and> bal t \<and> bound (2*k) h = nodes t * (2*k)"
+ by (simp add: bal_full_node height_full_node order_full_node full_btrees_sharp)
+
+
+(* maximum number of nodes *)
+subsection "Maximum height for a given number of nodes"
+
+
+lemma nodes_height_lower_bound:
+ "\<lbrakk>order k t; bal t\<rbrakk> \<Longrightarrow> bound k (height t) \<le> nodes t * k"
+proof(induction t rule: nodes.induct)
+ case (2 ts t)
+ let ?sub_height = "((k + 1) ^ height t - 1)"
+ have "k*(?sub_height) \<le> (length ts)*(?sub_height)"
+ using "2.prems"(1)
+ by simp
+ also have "\<dots> = sum_list (replicate (length ts) ?sub_height)"
+ using sum_list_replicate by simp
+ also have "\<dots> = sum_list (map (\<lambda>x.?sub_height) (subtrees ts))"
+ using map_replicate_const[of ?sub_height "subtrees ts"] length_map
+ by simp
+ also have "\<dots> \<le> sum_list (map (\<lambda>t. nodes t * k) (subtrees ts))"
+ using 2
+ using sum_list_mono[of "subtrees ts" "\<lambda>x. bound k (height t)" "\<lambda>t. nodes t * k"]
+ by (metis bal.simps(2) order.simps(2))
+ also have "\<dots> = sum_list (map nodes (subtrees ts)) * k"
+ using sum_list_mult_const[of nodes k "subtrees ts"] by auto
+ finally have "sum_list (map nodes (subtrees ts))*k \<ge> ?sub_height*k"
+ by simp
+ moreover have "(nodes t)*k \<ge> ?sub_height"
+ using 2 by simp
+ ultimately have "(nodes (Node ts t))*k \<ge>
+ k
+ + ?sub_height * k
+ + ?sub_height"
+ unfolding nodes.simps add_mult_distrib
+ by linarith
+ also have
+ "k + ?sub_height * k + ?sub_height =
+ k + k*((k + 1) ^ height t) - k + (k + 1) ^ height t - 1"
+ by (simp add: diff_mult_distrib2 mult.assoc mult.commute)
+ also have "\<dots> = k*((k + 1) ^ height t) + (k + 1) ^ height t - 1"
+ by simp
+ also have "\<dots> = (k+1)^(Suc(height t)) - 1"
+ by simp
+ finally show ?case
+ by (metis "2.prems"(2) height_bal_tree)
+qed simp
+
+text "To verify our upper bound is sharp, we compare it to the height of artificially constructed
+minimally filled (=slim) trees."
+
+fun slim_node::"nat \<Rightarrow> 'a \<Rightarrow> nat \<Rightarrow> 'a btree" where
+ "slim_node k c 0 = Leaf"|
+ "slim_node k c (Suc n) = (Node (replicate k ((slim_node k c n),c)) (slim_node k c n))"
+
+value "let k = (2::nat) in map (\<lambda>x. nodes x * k) (map (slim_node k (1::nat)) [0,1,2,3,4])"
+value "let k = (2::nat) in map (\<lambda>x. ((k+1::nat)^(x)-1)) [0,1,2,3,4]"
+
+
+lemma height_slim_node: "height (slim_node k a h) = h"
+ apply(induction k a h rule: full_node.induct)
+ apply (auto simp add: set_replicate_conv_if)
+ done
+
+lemma bal_slim_node: "bal (slim_node k a h)"
+ apply(induction k a h rule: full_node.induct)
+ apply auto
+ done
+
+lemma order_slim_node: "order k (slim_node k a h)"
+ apply(induction k a h rule: full_node.induct)
+ apply auto
+ done
+
+lemma slim_nodes_sharp: "nodes (slim_node k a h) * k = bound k h"
+ apply(induction k a h rule: slim_node.induct)
+ apply (auto simp add: height_slim_node algebra_simps sum_list_replicate compow_id_point)
+ done
+
+lemma lower_bound_sharp_node:
+ "t = slim_node k a h \<Longrightarrow> height t = h \<and> order k t \<and> bal t \<and> bound k h = nodes t * k"
+ by (simp add: bal_slim_node height_slim_node order_slim_node slim_nodes_sharp)
+
+(* TODO results for root_order/bal *)
+text "Since BTrees have special roots, we need to show the overall nodes seperately"
+
+lemma nodes_root_height_lower_bound:
+ assumes "root_order k t"
+ and "bal t"
+ shows "2*((k+1)^(height t - 1) - 1) + (of_bool (t \<noteq> Leaf))*k \<le> nodes t * k"
+proof (cases t)
+ case (Node ts t)
+ let ?sub_height = "((k + 1) ^ height t - 1)"
+ from Node have "?sub_height \<le> length ts * ?sub_height"
+ using assms
+ by (simp add: Suc_leI)
+ also have "\<dots> = sum_list (replicate (length ts) ?sub_height)"
+ using sum_list_replicate
+ by simp
+ also have "\<dots> = sum_list (map (\<lambda>x. ?sub_height) (subtrees ts))"
+ using map_replicate_const[of ?sub_height "subtrees ts"] length_map
+ by simp
+ also have "\<dots> \<le> sum_list (map (\<lambda>t. nodes t * k) (subtrees ts))"
+ using Node
+ sum_list_mono[of "subtrees ts" "\<lambda>x. (k+1)^(height t) - 1" "\<lambda>x. nodes x * k"]
+ nodes_height_lower_bound assms
+ by fastforce
+ also have "\<dots> = sum_list (map nodes (subtrees ts)) * k"
+ using sum_list_mult_const[of nodes k "subtrees ts"] by simp
+ finally have "sum_list (map nodes (subtrees ts))*k \<ge> ?sub_height"
+ by simp
+
+ moreover have "(nodes t)*k \<ge> ?sub_height"
+ using Node assms nodes_height_lower_bound
+ by auto
+ ultimately have "(nodes (Node ts t))*k \<ge>
+ ?sub_height
+ + ?sub_height + k"
+ unfolding nodes.simps add_mult_distrib
+ by linarith
+ then show ?thesis
+ using Node assms(2) height_bal_tree by fastforce
+qed simp
+
+lemma nodes_root_height_upper_bound:
+ assumes "root_order k t"
+ and "bal t"
+ shows "nodes t * (2*k) \<le> (2*k+1)^(height t) - 1"
+proof(cases t)
+ case (Node ts t)
+ let ?sub_height = "((2 * k + 1) ^ height t - 1)"
+ have "sum_list (map nodes (subtrees ts)) * (2*k) =
+ sum_list (map (\<lambda>t. nodes t * (2 * k)) (subtrees ts))"
+ using sum_list_mult_const by metis
+ also have "\<dots> \<le> sum_list (map (\<lambda>x.?sub_height) (subtrees ts))"
+ using Node
+ sum_list_mono[of "subtrees ts" "\<lambda>x. nodes x * (2*k)" "\<lambda>x. (2*k+1)^(height t) - 1"]
+ nodes_height_upper_bound assms
+ by fastforce
+ also have "\<dots> = sum_list (replicate (length ts) ?sub_height)"
+ using map_replicate_const[of ?sub_height "subtrees ts"] length_map
+ by simp
+ also have "\<dots> = (length ts)*(?sub_height)"
+ using sum_list_replicate by simp
+ also have "\<dots> \<le> (2*k)*?sub_height"
+ using assms Node
+ by simp
+ finally have "sum_list (map nodes (subtrees ts))*(2*k) \<le> ?sub_height*(2*k)"
+ by simp
+ moreover have "(nodes t)*(2*k) \<le> ?sub_height"
+ using Node assms nodes_height_upper_bound
+ by auto
+ ultimately have "(nodes (Node ts t))*(2*k) \<le>
+ 2*k
+ + ?sub_height * (2*k)
+ + ?sub_height"
+ unfolding nodes.simps add_mult_distrib
+ by linarith
+ also have "\<dots> = 2*k + (2*k)*((2 * k + 1) ^ height t) - 2*k + (2 * k + 1) ^ height t - 1"
+ by (simp add: diff_mult_distrib2 mult.assoc mult.commute)
+ also have "\<dots> = (2*k)*((2 * k + 1) ^ height t) + (2 * k + 1) ^ height t - 1"
+ by simp
+ also have "\<dots> = (2*k+1)^(Suc(height t)) - 1"
+ by simp
+ finally show ?thesis
+ by (metis Node assms(2) height_bal_tree)
+qed simp
+
+lemma root_order_imp_divmuleq: "root_order k t \<Longrightarrow> (nodes t * k) div k = nodes t"
+ using root_order.elims(2) by fastforce
+
+lemma nodes_root_height_lower_bound_simp:
+ assumes "root_order k t"
+ and "bal t"
+ and "k > 0"
+ shows "(2*((k+1)^(height t - 1) - 1)) div k + (of_bool (t \<noteq> Leaf)) \<le> nodes t"
+proof (cases t)
+ case Node
+ have "(2*((k+1)^(height t - 1) - 1)) div k + (of_bool (t \<noteq> Leaf)) =
+(2*((k+1)^(height t - 1) - 1) + (of_bool (t \<noteq> Leaf))*k) div k"
+ using Node assms
+ using div_plus_div_distrib_dvd_left[of k k "(2 * Suc k ^ (height t - Suc 0) - Suc (Suc 0))"]
+ by (auto simp add: algebra_simps simp del: height_btree.simps)
+ also have "\<dots> \<le> (nodes t * k) div k"
+ using nodes_root_height_lower_bound[OF assms(1,2)] div_le_mono
+ by blast
+ also have "\<dots> = nodes t"
+ using root_order_imp_divmuleq[OF assms(1)]
+ by simp
+ finally show ?thesis .
+qed simp
+
+lemma nodes_root_height_upper_bound_simp:
+ assumes "root_order k t"
+ and "bal t"
+ shows "nodes t \<le> ((2*k+1)^(height t) - 1) div (2*k)"
+proof -
+ have "nodes t = (nodes t * (2*k)) div (2*k)"
+ using root_order_imp_divmuleq[OF assms(1)]
+ by simp
+ also have "\<dots> \<le> ((2*k+1)^(height t) - 1) div (2*k)"
+ using div_le_mono nodes_root_height_upper_bound[OF assms] by blast
+ finally show ?thesis .
+qed
+
+definition "full_tree = full_node"
+
+fun slim_tree where
+ "slim_tree k c 0 = Leaf" |
+ "slim_tree k c (Suc h) = Node [(slim_node k c h, c)] (slim_node k c h)"
+
+lemma lower_bound_sharp:
+ "k > 0 \<Longrightarrow> t = slim_tree k a h \<Longrightarrow> height t = h \<and> root_order k t \<and> bal t \<and> nodes t * k = 2*((k+1)^(height t - 1) - 1) + (of_bool (t \<noteq> Leaf))*k"
+ apply (cases h)
+ using slim_nodes_sharp[of k a]
+ apply (auto simp add: algebra_simps bal_slim_node height_slim_node order_slim_node)
+ done
+
+lemma upper_bound_sharp:
+ "k > 0 \<Longrightarrow> t = full_tree k a h \<Longrightarrow> height t = h \<and> root_order k t \<and> bal t \<and> ((2*k+1)^(height t) - 1) = nodes t * (2*k)"
+ unfolding full_tree_def
+ using order_impl_root_order[of k t]
+ by (simp add: bal_full_node height_full_node order_full_node full_btrees_sharp)
+
+
+end
\ No newline at end of file
diff --git a/thys/BTree/BTree_Imp.thy b/thys/BTree/BTree_Imp.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/BTree_Imp.thy
@@ -0,0 +1,66 @@
+theory BTree_Imp
+ imports
+ BTree
+ Partially_Filled_Array
+ Basic_Assn
+begin
+
+section "Imperative B-tree Definition"
+
+text "The heap data type definition. Anything stored on the heap always contains data,
+leafs are represented as None."
+
+datatype 'a btnode =
+ Btnode "('a btnode ref option*'a) pfarray" "'a btnode ref option"
+
+text \<open>Selector Functions\<close>
+primrec kvs :: "'a::heap btnode \<Rightarrow> ('a btnode ref option*'a) pfarray" where
+ [sep_dflt_simps]: "kvs (Btnode ts _) = ts"
+
+primrec last :: "'a::heap btnode \<Rightarrow> 'a btnode ref option" where
+ [sep_dflt_simps]: "last (Btnode _ t) = t"
+
+term arrays_update
+
+text \<open>Encoding to natural numbers, as required by Imperative/HOL\<close>
+ (* Note: should also work using the package "Deriving" *)
+fun
+ btnode_encode :: "'a::heap btnode \<Rightarrow> nat"
+ where
+ "btnode_encode (Btnode ts t) = to_nat (ts, t)"
+
+instance btnode :: (heap) heap
+ apply (rule heap_class.intro)
+ apply (rule countable_classI [of "btnode_encode"])
+ apply (metis btnode_encode.elims from_nat_to_nat fst_conv snd_conv)
+ ..
+
+text "The refinement relationship to abstract B-trees."
+
+fun btree_assn :: "nat \<Rightarrow> 'a::heap btree \<Rightarrow> 'a btnode ref option \<Rightarrow> assn" where
+ "btree_assn k Leaf None = emp" |
+ "btree_assn k (Node ts t) (Some a) =
+ (\<exists>\<^sub>A tsi ti tsi'.
+ a \<mapsto>\<^sub>r Btnode tsi ti
+ * btree_assn k t ti
+ * is_pfa (2*k) tsi' tsi
+ * list_assn ((btree_assn k) \<times>\<^sub>a id_assn) ts tsi'
+ )" |
+ "btree_assn _ _ _ = false"
+
+text "With the current definition of deletion, we would
+also need to directly reason on nodes and not only on references
+to them."
+
+fun btnode_assn :: "nat \<Rightarrow> 'a::heap btree \<Rightarrow> 'a btnode \<Rightarrow> assn" where
+ "btnode_assn k (Node ts t) (Btnode tsi ti) =
+ (\<exists>\<^sub>A tsi'.
+ btree_assn k t ti
+ * is_pfa (2*k) tsi' tsi
+ * list_assn ((btree_assn k) \<times>\<^sub>a id_assn) ts tsi'
+ )" |
+ "btnode_assn _ _ _ = false"
+
+abbreviation "blist_assn k \<equiv> list_assn ((btree_assn k) \<times>\<^sub>a id_assn)"
+
+end
\ No newline at end of file
diff --git a/thys/BTree/BTree_ImpSet.thy b/thys/BTree/BTree_ImpSet.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/BTree_ImpSet.thy
@@ -0,0 +1,902 @@
+theory BTree_ImpSet
+ imports
+ BTree_Imp
+ BTree_Set
+begin
+
+section "Imperative Set operations"
+
+subsection "Auxiliary operations"
+
+definition "split_relation xs \<equiv>
+ \<lambda>(as,bs) i. i \<le> length xs \<and> as = take i xs \<and> bs = drop i xs"
+
+lemma split_relation_alt:
+ "split_relation as (ls,rs) i = (as = ls@rs \<and> i = length ls)"
+ by (auto simp add: split_relation_def)
+
+
+lemma split_relation_length: "split_relation xs (ls,rs) (length xs) = (ls = xs \<and> rs = [])"
+ by (simp add: split_relation_def)
+
+(* auxiliary lemmas on assns *)
+(* simp? not sure if it always makes things more easy *)
+lemma list_assn_prod_map: "list_assn (A \<times>\<^sub>a B) xs ys = list_assn B (map snd xs) (map snd ys) * list_assn A (map fst xs) (map fst ys)"
+ apply(induct "(A \<times>\<^sub>a B)" xs ys rule: list_assn.induct)
+ apply(auto simp add: ab_semigroup_mult_class.mult.left_commute ent_star_mono star_aci(2) star_assoc)
+ done
+
+(* concrete *)
+lemma id_assn_list: "h \<Turnstile> list_assn id_assn (xs::'a list) ys \<Longrightarrow> xs = ys"
+ apply(induction "id_assn::('a \<Rightarrow> 'a \<Rightarrow> assn)" xs ys rule: list_assn.induct)
+ apply(auto simp add: less_Suc_eq_0_disj pure_def)
+ done
+
+
+lemma snd_map_help:
+ "x \<le> length tsi \<Longrightarrow>
+ (\<forall>j<x. snd (tsi ! j) = ((map snd tsi)!j))"
+ "x < length tsi \<Longrightarrow> snd (tsi!x) = ((map snd tsi)!x)"
+ by auto
+
+
+lemma split_ismeq: "((a::nat) \<le> b \<and> X) = ((a < b \<and> X) \<or> (a = b \<and> X))"
+ by auto
+
+lemma split_relation_map: "split_relation as (ls,rs) i \<Longrightarrow> split_relation (map f as) (map f ls, map f rs) i"
+ apply(induction as arbitrary: ls rs i)
+ apply(auto simp add: split_relation_def take_map drop_Cons')
+ apply(metis list.simps(9) take_map)
+ done
+
+lemma split_relation_access: "\<lbrakk>split_relation as (ls,rs) i; rs = r#rrs\<rbrakk> \<Longrightarrow> as!i = r"
+ by (simp add: split_relation_alt)
+
+
+
+lemma index_to_elem_all: "(\<forall>j<length xs. P (xs!j)) = (\<forall>x \<in> set xs. P x)"
+ by (simp add: all_set_conv_nth)
+
+lemma index_to_elem: "n < length xs \<Longrightarrow> (\<forall>j<n. P (xs!j)) = (\<forall>x \<in> set (take n xs). P x)"
+ by (simp add: all_set_conv_nth)
+ (* ----------------- *)
+
+definition split_half :: "('a::heap \<times> 'b::{heap}) pfarray \<Rightarrow> nat Heap"
+ where
+ "split_half a \<equiv> do {
+ l \<leftarrow> pfa_length a;
+ return (l div 2)
+}"
+
+lemma split_half_rule[sep_heap_rules]: "<
+ is_pfa c tsi a
+ * list_assn R ts tsi>
+ split_half a
+ <\<lambda>i.
+ is_pfa c tsi a
+ * list_assn R ts tsi
+ * \<up>(i = length ts div 2 \<and> split_relation ts (BTree_Set.split_half ts) i)>"
+ unfolding split_half_def split_relation_def
+ apply(rule hoare_triple_preI)
+ apply(sep_auto dest!: list_assn_len mod_starD)
+ done
+
+subsection "The imperative split locale"
+
+text "This locale extends the abstract split locale,
+assuming that we are provided with an imperative program
+that refines the abstract split function."
+
+
+locale imp_split = abs_split: BTree_Set.split split
+ for split::
+ "('a btree \<times> 'a::{heap,default,linorder}) list \<Rightarrow> 'a
+ \<Rightarrow> ('a btree \<times> 'a) list \<times> ('a btree \<times> 'a) list" +
+ fixes imp_split:: "('a btnode ref option \<times> 'a::{heap,default,linorder}) pfarray \<Rightarrow> 'a \<Rightarrow> nat Heap"
+ assumes imp_split_rule [sep_heap_rules]:"sorted_less (separators ts) \<Longrightarrow>
+ <is_pfa c tsi (a,n)
+ * blist_assn k ts tsi>
+ imp_split (a,n) p
+ <\<lambda>i.
+ is_pfa c tsi (a,n)
+ * blist_assn k ts tsi
+ * \<up>(split_relation ts (split ts p) i)>\<^sub>t"
+begin
+
+subsection "Membership"
+
+partial_function (heap) isin :: "'a btnode ref option \<Rightarrow> 'a \<Rightarrow> bool Heap"
+ where
+ "isin p x =
+ (case p of
+ None \<Rightarrow> return False |
+ (Some a) \<Rightarrow> do {
+ node \<leftarrow> !a;
+ i \<leftarrow> imp_split (kvs node) x;
+ tsl \<leftarrow> pfa_length (kvs node);
+ if i < tsl then do {
+ s \<leftarrow> pfa_get (kvs node) i;
+ let (sub,sep) = s in
+ if x = sep then
+ return True
+ else
+ isin sub x
+ } else
+ isin (last node) x
+ }
+)"
+
+subsection "Insertion"
+
+
+datatype 'b btupi =
+ T\<^sub>i "'b btnode ref option" |
+ Up\<^sub>i "'b btnode ref option" "'b" "'b btnode ref option"
+
+fun btupi_assn where
+ "btupi_assn k (abs_split.T\<^sub>i l) (T\<^sub>i li) =
+ btree_assn k l li" |
+ "btupi_assn k (abs_split.Up\<^sub>i l a r) (Up\<^sub>i li ai ri) =
+ btree_assn k l li * id_assn a ai * btree_assn k r ri" |
+ "btupi_assn _ _ _ = false"
+
+
+
+definition node\<^sub>i :: "nat \<Rightarrow> ('a btnode ref option \<times> 'a) pfarray \<Rightarrow> 'a btnode ref option \<Rightarrow> 'a btupi Heap" where
+ "node\<^sub>i k a ti \<equiv> do {
+ n \<leftarrow> pfa_length a;
+ if n \<le> 2*k then do {
+ a' \<leftarrow> pfa_shrink_cap (2*k) a;
+ l \<leftarrow> ref (Btnode a' ti);
+ return (T\<^sub>i (Some l))
+ }
+ else do {
+ b \<leftarrow> (pfa_empty (2*k) :: ('a btnode ref option \<times> 'a) pfarray Heap);
+ i \<leftarrow> split_half a;
+ m \<leftarrow> pfa_get a i;
+ b' \<leftarrow> pfa_drop a (i+1) b;
+ a' \<leftarrow> pfa_shrink i a;
+ a'' \<leftarrow> pfa_shrink_cap (2*k) a';
+ let (sub,sep) = m in do {
+ l \<leftarrow> ref (Btnode a'' sub);
+ r \<leftarrow> ref (Btnode b' ti);
+ return (Up\<^sub>i (Some l) sep (Some r))
+ }
+ }
+}"
+
+
+partial_function (heap) ins :: "nat \<Rightarrow> 'a \<Rightarrow> 'a btnode ref option \<Rightarrow> 'a btupi Heap"
+ where
+ "ins k x apo = (case apo of
+ None \<Rightarrow>
+ return (Up\<^sub>i None x None) |
+ (Some ap) \<Rightarrow> do {
+ a \<leftarrow> !ap;
+ i \<leftarrow> imp_split (kvs a) x;
+ tsl \<leftarrow> pfa_length (kvs a);
+ if i < tsl then do {
+ s \<leftarrow> pfa_get (kvs a) i;
+ let (sub,sep) = s in
+ if sep = x then
+ return (T\<^sub>i apo)
+ else do {
+ r \<leftarrow> ins k x sub;
+ case r of
+ (T\<^sub>i lp) \<Rightarrow> do {
+ pfa_set (kvs a) i (lp,sep);
+ return (T\<^sub>i apo)
+ } |
+ (Up\<^sub>i lp x' rp) \<Rightarrow> do {
+ pfa_set (kvs a) i (rp,sep);
+ if tsl < 2*k then do {
+ kvs' \<leftarrow> pfa_insert (kvs a) i (lp,x');
+ ap := (Btnode kvs' (last a));
+ return (T\<^sub>i apo)
+ } else do {
+ kvs' \<leftarrow> pfa_insert_grow (kvs a) i (lp,x');
+ node\<^sub>i k kvs' (last a)
+ }
+ }
+ }
+ }
+ else do {
+ r \<leftarrow> ins k x (last a);
+ case r of
+ (T\<^sub>i lp) \<Rightarrow> do {
+ ap := (Btnode (kvs a) lp);
+ return (T\<^sub>i apo)
+ } |
+ (Up\<^sub>i lp x' rp) \<Rightarrow>
+ if tsl < 2*k then do {
+ kvs' \<leftarrow> pfa_append (kvs a) (lp,x');
+ ap := (Btnode kvs' rp);
+ return (T\<^sub>i apo)
+ } else do {
+ kvs' \<leftarrow> pfa_append_grow' (kvs a) (lp,x');
+ node\<^sub>i k kvs' rp
+ }
+ }
+ }
+)"
+
+
+(*fun tree\<^sub>i::"'a up\<^sub>i \<Rightarrow> 'a btree" where
+ "tree\<^sub>i (T\<^sub>i sub) = sub" |
+ "tree\<^sub>i (Up\<^sub>i l a r) = (Node [(l,a)] r)"
+
+fun insert::"nat \<Rightarrow> 'a \<Rightarrow> 'a btree \<Rightarrow> 'a btree" where
+ "insert k x t = tree\<^sub>i (ins k x t)"
+*)
+
+definition insert :: "nat \<Rightarrow> ('a::{heap,default,linorder}) \<Rightarrow> 'a btnode ref option \<Rightarrow> 'a btnode ref option Heap" where
+ "insert \<equiv> \<lambda>k x ti. do {
+ ti' \<leftarrow> ins k x ti;
+ case ti' of
+ T\<^sub>i sub \<Rightarrow> return sub |
+ Up\<^sub>i l a r \<Rightarrow> do {
+ kvs \<leftarrow> pfa_init (2*k) (l,a) 1;
+ t' \<leftarrow> ref (Btnode kvs r);
+ return (Some t')
+ }
+}"
+
+subsection "Deletion"
+
+text "Note that the below operations have not been verified to
+refine the abstract set operations."
+
+
+(* rebalance middle tree gets a list of trees, an index pointing to
+the position of sub/sep and a last tree *)
+definition rebalance_middle_tree:: "nat \<Rightarrow> (('a::{default,heap,linorder}) btnode ref option \<times> 'a) pfarray \<Rightarrow> nat \<Rightarrow> 'a btnode ref option \<Rightarrow> 'a btnode Heap"
+ where
+ "rebalance_middle_tree \<equiv> \<lambda> k tsi i r_ti. (
+ case r_ti of
+ None \<Rightarrow> do {
+ return (Btnode tsi r_ti)
+ } |
+ Some p_t \<Rightarrow> do {
+ ti \<leftarrow> !p_t;
+ (r_sub,sep) \<leftarrow> pfa_get tsi i;
+ case r_sub of (Some p_sub) \<Rightarrow> do {
+ sub \<leftarrow> !p_sub;
+ l_sub \<leftarrow> pfa_length (kvs sub);
+ l_tts \<leftarrow> pfa_length (kvs ti);
+ if l_sub \<ge> k \<and> l_tts \<ge> k then do {
+ return (Btnode tsi r_ti)
+ } else do {
+ l_tsi \<leftarrow> pfa_length tsi;
+ if l_tsi = i then do {
+ mts' \<leftarrow> pfa_append_extend_grow (kvs sub) (last sub,sep) (kvs ti);
+ res_node\<^sub>i \<leftarrow> node\<^sub>i k mts' (last ti);
+ case res_node\<^sub>i of
+ T\<^sub>i u \<Rightarrow> return (Btnode tsi u) |
+ Up\<^sub>i l a r \<Rightarrow> do {
+ tsi' \<leftarrow> pfa_append tsi (l,a);
+ return (Btnode tsi' r)
+ }
+ } else do {
+ (r_rsub,rsep) \<leftarrow> pfa_get tsi (i+1);
+ case r_rsub of Some p_rsub \<Rightarrow> do {
+ rsub \<leftarrow> !p_rsub;
+ mts' \<leftarrow> pfa_append_extend_grow (kvs sub) (last sub,sep) (kvs rsub);
+ res_node\<^sub>i \<leftarrow> node\<^sub>i k mts' (last rsub);
+ case res_node\<^sub>i of
+ T\<^sub>i u \<Rightarrow> do {
+ tsi' \<leftarrow> pfa_set tsi (i+1) (u,rsep);
+ tsi'' \<leftarrow> pfa_delete tsi' i;
+ return (Btnode tsi'' r_ti)
+ } |
+ Up\<^sub>i l a r \<Rightarrow> do {
+ tsi' \<leftarrow> pfa_set tsi i (l,a);
+ tsi'' \<leftarrow> pfa_set tsi' (i+1) (r,rsep);
+ return (Btnode tsi'' r_ti)
+ }
+ }
+ }
+ }
+ }
+})
+"
+
+
+definition rebalance_last_tree:: "nat \<Rightarrow> (('a::{default,heap,linorder}) btnode ref option \<times> 'a) pfarray \<Rightarrow> 'a btnode ref option \<Rightarrow> 'a btnode Heap"
+ where
+ "rebalance_last_tree \<equiv> \<lambda>k tsi ti. do {
+ l_tsi \<leftarrow> pfa_length tsi;
+ rebalance_middle_tree k tsi (l_tsi-1) ti
+}"
+
+partial_function (heap) split_max ::"nat \<Rightarrow> ('a::{default,heap,linorder}) btnode ref option \<Rightarrow> ('a btnode ref option \<times> 'a) Heap"
+ where
+ "split_max k r_t = (case r_t of Some p_t \<Rightarrow> do {
+ t \<leftarrow> !p_t;
+ (case t of Btnode tsi r_ti \<Rightarrow>
+ case r_ti of None \<Rightarrow> do {
+ (sub,sep) \<leftarrow> pfa_last tsi;
+ tsi' \<leftarrow> pfa_butlast tsi;
+ p_t := Btnode tsi' sub;
+ return (Some p_t, sep)
+ } |
+ _ \<Rightarrow> do {
+ (sub,sep) \<leftarrow> split_max k r_ti;
+ p_t' \<leftarrow> rebalance_last_tree k tsi sub;
+ p_t := p_t';
+ return (Some p_t, sep)
+ })
+})
+"
+
+partial_function (heap) del ::"nat \<Rightarrow> 'a \<Rightarrow> ('a::{default,heap,linorder}) btnode ref option \<Rightarrow> 'a btnode ref option Heap"
+ where
+ "del k x ti = (case ti of None \<Rightarrow> return None |
+ Some p \<Rightarrow> do {
+ node \<leftarrow> !p;
+ i \<leftarrow> imp_split (kvs node) x;
+ tsl \<leftarrow> pfa_length (kvs node);
+ if i < tsl then do {
+ s \<leftarrow> pfa_get (kvs node) i;
+ let (sub,sep) = s in
+ if x \<noteq> sep then do {
+ sub' \<leftarrow> del k x sub;
+ kvs' \<leftarrow> pfa_set (kvs node) i (sub',sep);
+ node' \<leftarrow> rebalance_middle_tree k kvs' i (last node);
+ ti' \<leftarrow> ref node';
+ return (Some ti')
+ }
+ else if sub = None then do{
+ pfa_delete (kvs node) i;
+ return ti
+ }
+ else do {
+ sm \<leftarrow> split_max k sub;
+ kvs' \<leftarrow> pfa_set (kvs node) i sm;
+ node' \<leftarrow> rebalance_middle_tree k kvs' i (last node);
+ ti' \<leftarrow> ref node';
+ return (Some ti')
+ }
+ } else do {
+ t' \<leftarrow> del k x (last node);
+ node' \<leftarrow> rebalance_last_tree k (kvs node) t';
+ ti' \<leftarrow> ref node';
+ return (Some ti')
+ }
+})
+"
+
+partial_function (heap) reduce_root ::"('a::{default,heap,linorder}) btnode ref option \<Rightarrow> 'a btnode ref option Heap"
+ where
+ "reduce_root ti = (case ti of
+ None \<Rightarrow> return None |
+ Some p_t \<Rightarrow> do {
+ node \<leftarrow> !p_t;
+ tsl \<leftarrow> pfa_length (kvs node);
+ case tsl of 0 \<Rightarrow> return (last node) |
+ _ \<Rightarrow> return ti
+})"
+
+partial_function (heap) delete ::"nat \<Rightarrow> 'a \<Rightarrow> ('a::{default,heap,linorder}) btnode ref option \<Rightarrow> 'a btnode ref option Heap"
+ where
+ "delete k x ti = do {
+ ti' \<leftarrow> del k x ti;
+ reduce_root ti'
+}"
+
+subsection "Refinement of the abstract B-tree operations"
+
+definition empty ::"('a::{default,heap,linorder}) btnode ref option Heap"
+ where "empty = return None"
+
+
+lemma P_imp_Q_implies_P: "P \<Longrightarrow> (Q \<longrightarrow> P)"
+ by simp
+
+
+lemma "sorted_less (inorder t) \<Longrightarrow>
+ <btree_assn k t ti>
+ isin ti x
+ <\<lambda>r. btree_assn k t ti * \<up>(abs_split.isin t x = r)>\<^sub>t"
+proof(induction t x arbitrary: ti rule: abs_split.isin.induct)
+ case (1 x)
+ then show ?case
+ apply(subst isin.simps)
+ apply (cases ti)
+ apply (auto simp add: return_cons_rule)
+ done
+next
+ case (2 ts t x)
+ then obtain ls rs where list_split[simp]: "split ts x = (ls,rs)"
+ by (cases "split ts x")
+ then show ?case
+ proof (cases rs)
+ (* NOTE: induction condition trivial here *)
+ case [simp]: Nil
+ show ?thesis
+ apply(subst isin.simps)
+ apply(sep_auto)
+ using "2.prems" sorted_inorder_separators apply blast
+ apply(auto simp add: split_relation_def dest!: sym[of "[]"] mod_starD list_assn_len)[]
+ apply(rule hoare_triple_preI)
+ apply(auto simp add: split_relation_def dest!: sym[of "[]"] mod_starD list_assn_len)[]
+ using 2(3) apply(sep_auto heap: "2.IH"(1)[of ls "[]"] simp add: sorted_wrt_append)
+ done
+ next
+ case [simp]: (Cons h rrs)
+ obtain sub sep where h_split[simp]: "h = (sub,sep)"
+ by (cases h)
+ show ?thesis
+ proof (cases "sep = x")
+ (* NOTE: no induction required here, only vacuous counter cases generated *)
+ case [simp]: True
+ then show ?thesis
+ apply(simp split: list.splits prod.splits)
+ apply(subst isin.simps)
+ using "2.prems" sorted_inorder_separators apply(sep_auto)
+ apply(rule hoare_triple_preI)
+ apply(auto simp add: split_relation_alt list_assn_append_Cons_left dest!: mod_starD list_assn_len)[]
+ apply(rule hoare_triple_preI)
+ apply(auto simp add: split_relation_def dest!: sym[of "[]"] mod_starD list_assn_len)[]
+ done
+ next
+ case [simp]: False
+ show ?thesis
+ apply(simp split: list.splits prod.splits)
+ apply safe
+ using False apply simp
+ apply(subst isin.simps)
+ using "2.prems" sorted_inorder_separators
+ apply(sep_auto)
+ (*eliminate vacuous case*)
+ apply(auto simp add: split_relation_alt list_assn_append_Cons_left dest!: mod_starD list_assn_len)[]
+ (* simplify towards induction step *)
+ apply(auto simp add: split_relation_alt list_assn_append_Cons_left dest!: mod_starD list_assn_len)[]
+
+(* NOTE show that z = (suba, sepa) *)
+ apply(rule norm_pre_ex_rule)+
+ apply(rule hoare_triple_preI)
+ subgoal for p tsi n ti xsi suba sepa zs1 z zs2 _
+ apply(subgoal_tac "z = (suba, sepa)", simp)
+ using 2(3) apply(sep_auto
+ heap:"2.IH"(2)[of ls rs h rrs sub sep]
+ simp add: sorted_wrt_append)
+ using list_split Cons h_split apply simp_all
+ (* proof that previous assumptions hold later *)
+ apply(rule P_imp_Q_implies_P)
+ apply(rule ent_ex_postI[where x="(tsi,n)"])
+ apply(rule ent_ex_postI[where x="ti"])
+ apply(rule ent_ex_postI[where x="(zs1 @ (suba, sepa) # zs2)"])
+ apply(rule ent_ex_postI[where x="zs1"])
+ apply(rule ent_ex_postI[where x="z"])
+ apply(rule ent_ex_postI[where x="zs2"])
+ apply sep_auto
+ (* prove subgoal_tac assumption *)
+ apply (metis (no_types, lifting) list_assn_aux_ineq_len list_assn_len nth_append_length star_false_left star_false_right)
+ done
+ (* eliminate last vacuous case *)
+ apply(rule hoare_triple_preI)
+ apply(auto simp add: split_relation_def dest!: mod_starD list_assn_len)[]
+ done
+ qed
+ qed
+qed
+
+
+
+declare abs_split.node\<^sub>i.simps [simp add]
+lemma node\<^sub>i_rule: assumes c_cap: "2*k \<le> c" "c \<le> 4*k+1"
+ shows "<is_pfa c tsi (a,n) * list_assn ((btree_assn k) \<times>\<^sub>a id_assn) ts tsi * btree_assn k t ti>
+ node\<^sub>i k (a,n) ti
+ <\<lambda>r. btupi_assn k (abs_split.node\<^sub>i k ts t) r >\<^sub>t"
+proof (cases "length ts \<le> 2*k")
+ case [simp]: True
+ then show ?thesis
+ apply(subst node\<^sub>i_def)
+ apply(rule hoare_triple_preI)
+ apply(sep_auto dest!: mod_starD list_assn_len)
+ apply(sep_auto simp add: is_pfa_def)[]
+ using c_cap apply(sep_auto simp add: is_pfa_def)[]
+ apply(sep_auto dest!: mod_starD list_assn_len)[]
+ using True apply(sep_auto dest!: mod_starD list_assn_len)
+ done
+next
+ case [simp]: False
+ then obtain ls sub sep rs where
+ split_half_eq: "BTree_Set.split_half ts = (ls,(sub,sep)#rs)"
+ using abs_split.node\<^sub>i_cases by blast
+ then show ?thesis
+ apply(subst node\<^sub>i_def)
+ apply(rule hoare_triple_preI)
+ apply(sep_auto dest!: mod_starD list_assn_len)
+ apply(sep_auto simp add: split_relation_alt split_relation_length is_pfa_def dest!: mod_starD list_assn_len)
+
+ using False apply(sep_auto simp add: split_relation_alt )
+ using False apply(sep_auto simp add: is_pfa_def)[]
+ apply(sep_auto)[]
+ apply(sep_auto simp add: is_pfa_def split_relation_alt)[]
+ using c_cap apply(sep_auto simp add: is_pfa_def)[]
+ apply(sep_auto)[]
+ using c_cap apply(sep_auto simp add: is_pfa_def)[]
+ using c_cap apply(simp)
+ apply(vcg)
+ apply(simp)
+ apply(rule impI)
+ subgoal for _ _ _ _ rsa subi ba rn lsi al ar _
+ thm ent_ex_postI
+ thm ent_ex_postI[where x="take (length tsi div 2) tsi"]
+ (* instantiate right hand side *)
+ apply(rule ent_ex_postI[where x="(rsa,rn)"])
+ apply(rule ent_ex_postI[where x="ti"])
+ apply(rule ent_ex_postI[where x="(drop (Suc (length tsi div 2)) tsi)"])
+ apply(rule ent_ex_postI[where x="lsi"])
+ apply(rule ent_ex_postI[where x="subi"])
+ apply(rule ent_ex_postI[where x="take (length tsi div 2) tsi"])
+ (* introduce equality between equality of split tsi/ts and original lists *)
+ apply(simp add: split_relation_alt)
+ apply(subgoal_tac "tsi =
+ take (length tsi div 2) tsi @ (subi, ba) # drop (Suc (length tsi div 2)) tsi")
+ apply(rule back_subst[where a="blist_assn k ts (take (length tsi div 2) tsi @ (subi, ba) # (drop (Suc (length tsi div 2)) tsi))" and b="blist_assn k ts tsi"])
+ apply(rule back_subst[where a="blist_assn k (take (length tsi div 2) ts @ (sub, sep) # rs)" and b="blist_assn k ts"])
+ apply(subst list_assn_aux_append_Cons)
+ apply sep_auto
+ apply sep_auto
+ apply simp
+ apply simp
+ apply(rule back_subst[where a="tsi ! (length tsi div 2)" and b="(subi, ba)"])
+ apply(rule id_take_nth_drop)
+ apply simp
+ apply simp
+ done
+ done
+qed
+declare abs_split.node\<^sub>i.simps [simp del]
+
+
+lemma node\<^sub>i_no_split: "length ts \<le> 2*k \<Longrightarrow> abs_split.node\<^sub>i k ts t = abs_split.T\<^sub>i (Node ts t)"
+ by (simp add: abs_split.node\<^sub>i.simps)
+
+
+lemma node\<^sub>i_rule_app: "\<lbrakk>2*k \<le> c; c \<le> 4*k+1\<rbrakk> \<Longrightarrow>
+<is_pfa c (tsi' @ [(li, ai)]) (aa, al) *
+ blist_assn k ls tsi' *
+ btree_assn k l li *
+ id_assn a ai *
+ btree_assn k r ri> node\<^sub>i k (aa, al) ri
+ <btupi_assn k (abs_split.node\<^sub>i k (ls @ [(l, a)]) r)>\<^sub>t"
+proof -
+ note node\<^sub>i_rule[of k c "(tsi' @ [(li, ai)])" aa al "(ls @ [(l, a)])" r ri]
+ moreover assume "2*k \<le> c" "c \<le> 4*k+1"
+ ultimately show ?thesis
+ by (simp add: mult.left_assoc)
+qed
+
+lemma node\<^sub>i_rule_ins2: "\<lbrakk>2*k \<le> c; c \<le> 4*k+1; length ls = length lsi\<rbrakk> \<Longrightarrow>
+ <is_pfa c (lsi @ (li, ai) # (ri,a'i) # rsi) (aa, al) *
+ blist_assn k ls lsi *
+ btree_assn k l li *
+ id_assn a ai *
+ btree_assn k r ri *
+ id_assn a' a'i *
+ blist_assn k rs rsi *
+ btree_assn k t ti> node\<^sub>i k (aa, al)
+ ti <btupi_assn k (abs_split.node\<^sub>i k (ls @ (l, a) # (r,a') # rs) t)>\<^sub>t"
+proof -
+ assume [simp]: "2*k \<le> c" "c \<le> 4*k+1" "length ls = length lsi"
+ moreover note node\<^sub>i_rule[of k c "(lsi @ (li, ai) # (ri,a'i) # rsi)" aa al "(ls @ (l, a) # (r,a') # rs)" t ti]
+ ultimately show ?thesis
+ by (simp add: mult.left_assoc list_assn_aux_append_Cons)
+qed
+
+lemma ins_rule:
+ "sorted_less (inorder t) \<Longrightarrow> <btree_assn k t ti>
+ ins k x ti
+ <\<lambda>r. btupi_assn k (abs_split.ins k x t) r>\<^sub>t"
+proof (induction k x t arbitrary: ti rule: abs_split.ins.induct)
+ case (1 k x)
+ then show ?case
+ apply(subst ins.simps)
+ apply (sep_auto simp add: pure_app_eq)
+ done
+next
+ case (2 k x ts t)
+ obtain ls rrs where list_split: "split ts x = (ls,rrs)"
+ by (cases "split ts x")
+ have [simp]: "sorted_less (separators ts)"
+ using "2.prems" sorted_inorder_separators by simp
+ have [simp]: "sorted_less (inorder t)"
+ using "2.prems" sorted_inorder_induct_last by simp
+ show ?case
+ proof (cases rrs)
+ case Nil
+ then show ?thesis
+ proof (cases "abs_split.ins k x t")
+ case (T\<^sub>i a)
+ then show ?thesis
+ apply(subst ins.simps)
+ apply(sep_auto)
+ subgoal for p tsil tsin tti
+ using Nil list_split
+ by (simp add: list_assn_aux_ineq_len split_relation_alt)
+ subgoal for p tsil tsin tti tsi' i tsin' _ sub sep
+ apply(rule hoare_triple_preI)
+ using Nil list_split
+ by (simp add: list_assn_aux_ineq_len split_relation_alt)
+ subgoal for p tsil tsin tti tsi'
+ thm "2.IH"(1)[of ls rrs tti]
+ using Nil list_split T\<^sub>i apply(sep_auto split!: list.splits simp add: split_relation_alt
+ heap add: "2.IH"(1)[of ls rrs tti])
+ subgoal for ai
+ apply(cases ai)
+ apply sep_auto
+ apply sep_auto
+ done
+ done
+ done
+ next
+ case (Up\<^sub>i l a r)
+ then show ?thesis
+ apply(subst ins.simps)
+ apply(sep_auto)
+ subgoal for p tsil tsin tti
+ using Nil list_split
+ by (simp add: list_assn_aux_ineq_len split_relation_alt)
+ subgoal for p tsil tsin tti tsi' i tsin' _ sub sep
+ using Nil list_split
+ by (simp add: list_assn_aux_ineq_len split_relation_alt)
+ subgoal for p tsil tsin tti tsi' i tsin'
+ thm "2.IH"(1)[of ls rrs tti]
+ using Nil list_split Up\<^sub>i apply(sep_auto split!: list.splits
+ simp add: split_relation_alt
+ heap add: "2.IH"(1)[of ls rrs tti])
+ subgoal for ai
+ apply(cases ai)
+ apply sep_auto
+ apply(rule hoare_triple_preI)
+ apply(sep_auto)
+ apply(auto dest!: mod_starD simp add: is_pfa_def)[]
+ apply (sep_auto)
+ subgoal for li ai ri (* no split case *)
+ apply(subgoal_tac "length (ls @ [(l,a)]) \<le> 2*k")
+ apply(simp add: node\<^sub>i_no_split)
+ apply(rule ent_ex_postI[where x="(tsil,Suc tsin)"])
+ apply(rule ent_ex_postI[where x="ri"])
+ apply(rule ent_ex_postI[where x="tsi' @ [(li, ai)]"])
+ apply(sep_auto)
+ apply (sep_auto dest!: mod_starD list_assn_len simp add: is_pfa_def)
+ done
+ (* split case*)
+ apply(sep_auto heap add: node\<^sub>i_rule_app)
+ done
+ done
+ done
+ qed
+ next
+ case (Cons a rs)
+ obtain sub sep where a_split: "a = (sub,sep)"
+ by (cases a)
+ then have [simp]: "sorted_less (inorder sub)"
+ using "2.prems" abs_split.split_axioms list_split Cons sorted_inorder_induct_subtree split_def
+ by fastforce
+ then show ?thesis
+ proof(cases "x = sep")
+ case True
+ show ?thesis
+ apply(subst ins.simps)
+ apply(sep_auto)
+ subgoal for p tsil tsin tti tsi j subi
+ using Cons list_split a_split True
+ by sep_auto
+ subgoal for p tsil tsin tti tsi j _ _ subi sepi
+ apply(rule hoare_triple_preI)
+ using Cons list_split a_split True
+ apply(subgoal_tac "sepi = sep")
+ apply (sep_auto simp add: split_relation_alt)
+ apply(sep_auto simp add: list_assn_prod_map dest!: mod_starD id_assn_list)
+ by (metis length_map snd_conv snd_map_help(2) split_relation_access)
+ subgoal for p tsil tsin tti tsi j
+ apply(rule hoare_triple_preI)
+ using Cons list_split
+ by (sep_auto simp add: split_relation_alt dest!: mod_starD list_assn_len)
+ done
+ next
+ case False
+ then show ?thesis
+ proof (cases "abs_split.ins k x sub")
+ case (T\<^sub>i a')
+ then show ?thesis
+ apply(auto simp add: Cons list_split a_split False)
+ using False apply simp
+ apply(subst ins.simps)
+ apply vcg
+ apply auto
+ apply(rule norm_pre_ex_rule)+
+ (* at this point, we want to introduce the split, and after that tease the
+ hoare triple assumptions out of the bracket, s.t. we don't split twice *)
+ apply vcg
+ apply sep_auto
+ using list_split Cons
+ apply(simp add: split_relation_alt list_assn_append_Cons_left)
+ apply (rule impI)
+ apply(rule norm_pre_ex_rule)+
+ apply(rule hoare_triple_preI)
+ apply sep_auto
+ (* discard wrong branch *)
+ subgoal for p tsil tsin ti zs1 subi sepi zs2 _ _ suba
+ apply(subgoal_tac "sepi = x")
+ using list_split Cons a_split
+ apply(auto dest!: mod_starD )[]
+ apply(auto dest!: mod_starD list_assn_len)[]
+ done
+ (* actual induction branch *)
+ subgoal for p tsil tsin ti zs1 subi sepi zs2 _ _ n z suba sepa
+ apply (cases a, simp)
+ apply(subgoal_tac "subi = suba", simp)
+ using list_split a_split T\<^sub>i False
+ apply (vcg heap: 2)
+ apply(auto split!: btupi.splits)
+ (* careful progression for manual value insertion *)
+ apply vcg
+ apply simp
+ apply vcg
+ apply simp
+ subgoal for a'i q r
+ apply(rule impI)
+ apply(simp add: list_assn_append_Cons_left)
+ apply(rule ent_ex_postI[where x="(tsil,tsin)"])
+ apply(rule ent_ex_postI[where x="ti"])
+ apply(rule ent_ex_postI[where x="(zs1 @ (a'i, sepi) # zs2)"])
+ apply(rule ent_ex_postI[where x="zs1"])
+ apply(rule ent_ex_postI[where x="(a'i,sep)"])
+ apply(rule ent_ex_postI[where x="zs2"])
+ apply sep_auto
+ apply (simp add: pure_app_eq)
+ apply(sep_auto dest!: mod_starD list_assn_len)[]
+ done
+ apply (metis list_assn_aux_ineq_len Pair_inject list_assn_len nth_append_length star_false_left star_false_right)
+ done
+ subgoal for p tsil tsin ti zs1 subi sepi zs2 _ _ suba
+ apply(auto dest!: mod_starD list_assn_len)[]
+ done
+ done
+ next
+ case (Up\<^sub>i l w r)
+ then show ?thesis
+ apply(auto simp add: Cons list_split a_split False)
+ using False apply simp
+ apply(subst ins.simps)
+ apply vcg
+ apply auto
+ apply(rule norm_pre_ex_rule)+
+ (* at this point, we want to introduce the split, and after that tease the
+ hoare triple assumptions out of the bracket, s.t. we don't split twice *)
+ apply vcg
+ apply sep_auto
+ using list_split Cons
+ apply(simp add: split_relation_alt list_assn_append_Cons_left)
+ apply (rule impI)
+ apply(rule norm_pre_ex_rule)+
+ apply(rule hoare_triple_preI)
+ apply sep_auto
+ (* discard wrong branch *)
+ subgoal for p tsil tsin ti zs1 subi sepi zs2 _ _ suba
+ apply(subgoal_tac "sepi = x")
+ using list_split Cons a_split
+ apply(auto dest!: mod_starD )[]
+ apply(auto dest!: mod_starD list_assn_len)[]
+ done
+ (* actual induction branch *)
+ subgoal for p tsil tsin ti zs1 subi sepi zs2 _ _ n z suba sepa
+ apply(subgoal_tac "subi = suba", simp)
+ thm 2(2)[of ls rrs a rs sub sep]
+ using list_split a_split Cons Up\<^sub>i False
+ apply (sep_auto heap: 2(2))
+ apply(auto split!: btupi.splits)
+ (* careful progression for manual value insertion *)
+ apply vcg
+ apply simp
+ subgoal for li wi ri u (* no split case *)
+ apply (cases u,simp)
+ apply (sep_auto dest!: mod_starD list_assn_len heap: pfa_insert_grow_rule)
+ apply (simp add: is_pfa_def)[]
+ apply (metis le_less_linear length_append length_take less_not_refl min.absorb2 trans_less_add1)
+ apply(simp add: is_pfa_def)
+ apply (metis add_Suc_right length_Cons length_append length_take min.absorb2)
+ apply(sep_auto split: prod.splits dest!: mod_starD list_assn_len)[]
+ (* no split case *)
+ apply(subgoal_tac "length (ls @ [(l,w)]) \<le> 2*k")
+ apply(simp add: node\<^sub>i_no_split)
+ apply(rule ent_ex_postI[where x="(tsil,Suc tsin)"])
+ apply(rule ent_ex_postI[where x="ti"])
+ apply(rule ent_ex_postI[where x="(zs1 @ (li, wi) # (ri, sep) # zs2)"])
+ apply(sep_auto dest!: mod_starD list_assn_len)
+ apply (sep_auto dest!: mod_starD list_assn_len simp add: is_pfa_def)
+ done
+ apply vcg
+ apply simp
+ subgoal for x21 x22 x23 u (* split case *)
+ apply (cases u,simp)
+ thm pfa_insert_grow_rule[where ?l="((zs1 @ (suba, sepi) # zs2)[length ls := (x23, sepa)])"]
+ apply (sep_auto dest!: mod_starD list_assn_len heap: pfa_insert_grow_rule)
+ apply (simp add: is_pfa_def)[]
+ apply (metis le_less_linear length_append length_take less_not_refl min.absorb2 trans_less_add1)
+ apply(auto split: prod.splits dest!: mod_starD list_assn_len)[]
+
+ apply (vcg heap: node\<^sub>i_rule_ins2)
+ apply simp
+ apply simp
+ apply simp
+ apply sep_auto
+ done
+ apply(auto dest!: mod_starD list_assn_len)[]
+ done
+ subgoal for p tsil tsin ti zs1 subi sepi zs2 _ _ suba
+ apply(auto dest!: mod_starD list_assn_len)[]
+ done
+ done
+ qed
+ qed
+ qed
+qed
+
+text "The imperative insert refines the abstract insert."
+
+lemma insert_rule:
+ assumes "k > 0" "sorted_less (inorder t)"
+ shows "<btree_assn k t ti>
+ insert k x ti
+ <\<lambda>r. btree_assn k (abs_split.insert k x t) r>\<^sub>t"
+ unfolding insert_def
+ apply(cases "abs_split.ins k x t")
+ apply(sep_auto split!: btupi.splits heap: ins_rule[OF assms(2)])
+ using assms
+ apply(vcg heap: ins_rule[OF assms(2)])
+ apply(simp split!: btupi.splits)
+ apply(vcg)
+ apply auto[]
+ apply vcg
+ apply auto[]
+ subgoal for l a r li ai ri tsa tsn ti
+ apply(rule ent_ex_postI[where x="(tsa,tsn)"])
+ apply(rule ent_ex_postI[where x="ri"])
+ apply(rule ent_ex_postI[where x="[(li, ai)]"])
+ apply sep_auto
+ done
+ done
+
+text "The \"pure\" resulting rule follows automatically."
+lemma insert_rule':
+ shows "<btree_assn (Suc k) t ti * \<up>(abs_split.invar_inorder (Suc k) t \<and> sorted_less (inorder t))>
+ insert (Suc k) x ti
+ <\<lambda>ri.\<exists>\<^sub>Ar. btree_assn (Suc k) r ri * \<up>(abs_split.invar_inorder (Suc k) r \<and> sorted_less (inorder r) \<and> inorder r = (ins_list x (inorder t)))>\<^sub>t"
+ using abs_split.insert_bal abs_split.insert_order abs_split.insert_inorder
+ by (sep_auto heap: insert_rule simp add: sorted_ins_list)
+
+
+lemma node\<^sub>i_rule_ins: "\<lbrakk>2*k \<le> c; c \<le> 4*k+1; length ls = length lsi\<rbrakk> \<Longrightarrow>
+ <is_pfa c (lsi @ (li, ai) # rsi) (aa, al) *
+ blist_assn k ls lsi *
+ btree_assn k l li *
+ id_assn a ai *
+ blist_assn k rs rsi *
+ btree_assn k t ti> node\<^sub>i k (aa, al)
+ ti <btupi_assn k (abs_split.node\<^sub>i k (ls @ (l, a) # rs) t)>\<^sub>t"
+proof -
+ assume [simp]: "2*k \<le> c" "c \<le> 4*k+1" "length ls = length lsi"
+ moreover note node\<^sub>i_rule[of k c "(lsi @ (li, ai) # rsi)" aa al "(ls @ (l, a) # rs)" t ti]
+ ultimately show ?thesis
+ by (simp add: mult.left_assoc list_assn_aux_append_Cons)
+qed
+
+
+lemma empty_rule:
+ shows "<emp>
+ empty
+ <\<lambda>r. btree_assn k (abs_split.empty_btree) r>"
+ apply(subst empty_def)
+ apply(sep_auto simp add: abs_split.empty_btree_def)
+ done
+
+end
+
+end
+
diff --git a/thys/BTree/BTree_ImpSplit.thy b/thys/BTree/BTree_ImpSplit.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/BTree_ImpSplit.thy
@@ -0,0 +1,419 @@
+theory BTree_ImpSplit
+ imports
+ BTree_ImpSet
+ BTree_Split
+ Imperative_Loops
+begin
+
+section "Imperative split operations"
+
+text "So far, we have only given a functional specification of a possible split.
+ We will now provide imperative split functions that refine the functional specification.
+ However, rather than tracing the execution of the abstract specification,
+ the imperative versions are implemented using while-loops."
+
+
+subsection "Linear split"
+
+text "The linear split is the most simple split function for binary trees.
+ It serves a good example on how to use while-loops in Imperative/HOL
+ and how to prove Hoare-Triples about its application using loop invariants."
+
+definition lin_split :: "('a::heap \<times> 'b::{heap,linorder}) pfarray \<Rightarrow> 'b \<Rightarrow> nat Heap"
+ where
+ "lin_split \<equiv> \<lambda> (a,n) p. do {
+
+ i \<leftarrow> heap_WHILET
+ (\<lambda>i. if i<n then do {
+ (_,s) \<leftarrow> Array.nth a i;
+ return (s<p)
+ } else return False)
+ (\<lambda>i. return (i+1))
+ 0;
+
+ return i
+}"
+
+
+lemma lin_split_rule: "
+< is_pfa c xs (a,n)>
+ lin_split (a,n) p
+ <\<lambda>i. is_pfa c xs (a,n) * \<up>(i\<le>n \<and> (\<forall>j<i. snd (xs!j) < p) \<and> (i<n \<longrightarrow> snd (xs!i)\<ge>p))>\<^sub>t"
+ unfolding lin_split_def
+
+ supply R = heap_WHILET_rule''[where
+ R = "measure (\<lambda>i. n - i)"
+ and I = "\<lambda>i. is_pfa c xs (a,n) * \<up>(i\<le>n \<and> (\<forall>j<i. snd (xs!j) < p))"
+ and b = "\<lambda>i. i<n \<and> snd (xs!i) < p"
+ and Q="\<lambda>i. is_pfa c xs (a,n) * \<up>(i\<le>n \<and> (\<forall>j<i. snd (xs!j) < p) \<and> (i<n \<longrightarrow> snd (xs!i)\<ge>p))"
+ ]
+ thm R
+
+ apply (sep_auto decon: R simp: less_Suc_eq is_pfa_def) []
+ apply (metis nth_take snd_eqD)
+ apply (metis nth_take snd_eqD)
+ apply (sep_auto simp: is_pfa_def less_Suc_eq)+
+ apply (metis nth_take)
+ apply(sep_auto simp: is_pfa_def)
+ apply (metis le_simps(3) less_Suc_eq less_le_trans nth_take)
+ apply(sep_auto simp: is_pfa_def)+
+ done
+
+subsection "Binary split"
+
+text "To obtain an efficient B-Tree implementation, we prefer a binary split
+function.
+To explore the searching procedure
+and the resulting proof, we first implement the split on singleton arrays."
+
+definition bin'_split :: "'b::{heap,linorder} array_list \<Rightarrow> 'b \<Rightarrow> nat Heap"
+ where
+ "bin'_split \<equiv> \<lambda>(a,n) p. do {
+ (low',high') \<leftarrow> heap_WHILET
+ (\<lambda>(low,high). return (low < high))
+ (\<lambda>(low,high). let mid = ((low + high) div 2) in
+ do {
+ s \<leftarrow> Array.nth a mid;
+ if p < s then
+ return (low, mid)
+ else if p > s then
+ return (mid+1, high)
+ else return (mid,mid)
+ })
+ (0::nat,n);
+ return low'
+}"
+
+
+thm sorted_wrt_nth_less
+
+(* alternative: replace (\<forall>j<l. xs!j < p) by (l > 0 \<longrightarrow> xs!(l-1) < p)*)
+lemma bin'_split_rule: "
+sorted_less xs \<Longrightarrow>
+< is_pfa c xs (a,n)>
+ bin'_split (a,n) p
+ <\<lambda>l. is_pfa c xs (a,n) * \<up>(l \<le> n \<and> (\<forall>j<l. xs!j < p) \<and> (l<n \<longrightarrow> xs!l\<ge>p)) >\<^sub>t"
+ unfolding bin'_split_def
+
+ supply R = heap_WHILET_rule''[where
+ R = "measure (\<lambda>(l,h). h-l)"
+ and I = "\<lambda>(l,h). is_pfa c xs (a,n) * \<up>(l\<le>h \<and> h \<le> n \<and> (\<forall>j<l. xs!j < p) \<and> (h<n \<longrightarrow> xs!h\<ge>p))"
+ and b = "\<lambda>(l,h). l<h"
+ and Q="\<lambda>(l,h). is_pfa c xs (a,n) * \<up>(l \<le> n \<and> (\<forall>j<l. xs!j < p) \<and> (l<n \<longrightarrow> xs!l\<ge>p))"
+ ]
+ thm R
+
+ apply (sep_auto decon: R simp: less_Suc_eq is_pfa_def) []
+ subgoal for l' aa l'a aaa ba j
+ proof -
+ assume 0: "n \<le> length l'a"
+ assume a: "l'a ! ((aa + n) div 2) < p"
+ moreover assume "aa < n"
+ ultimately have b: "((aa+n)div 2) < n"
+ by linarith
+ then have "(take n l'a) ! ((aa + n) div 2) < p"
+ using a by auto
+ moreover assume "sorted_less (take n l'a)"
+ ultimately have "\<And>j. j < (aa+n)div 2 \<Longrightarrow> (take n l'a) ! j < (take n l'a) ! ((aa + n) div 2)"
+ using
+ sorted_wrt_nth_less[where ?P="(<)" and xs="(take n l'a)" and ?j="((aa + n) div 2)"]
+ a b "0" by auto
+ moreover fix j assume "j < (aa+n) div 2"
+ ultimately show "l'a ! j < p" using "0" b
+ using \<open>take n l'a ! ((aa + n) div 2) < p\<close> dual_order.strict_trans by auto
+ qed
+ subgoal for l' aa b l'a aaa ba j
+ proof -
+ assume t0: "n \<le> length l'a"
+ assume t1: "aa < b"
+ assume a: "l'a ! ((aa + b) div 2) < p"
+ moreover assume "b \<le> n"
+ ultimately have b: "((aa+b)div 2) < n" using t1
+ by linarith
+ then have "(take n l'a) ! ((aa + b) div 2) < p"
+ using a by auto
+ moreover assume "sorted_less (take n l'a)"
+ ultimately have "\<And>j. j < (aa+b)div 2 \<Longrightarrow> (take n l'a) ! j < (take n l'a) ! ((aa + b) div 2)"
+ using
+ sorted_wrt_nth_less[where ?P="(<)" and xs="(take n l'a)" and ?j="((aa + b) div 2)"]
+ a b t0 by auto
+ moreover fix j assume "j < (aa+b) div 2"
+ ultimately show "l'a ! j < p" using t0 b
+ using \<open>take n l'a ! ((aa + b) div 2) < p\<close> dual_order.strict_trans by auto
+ qed
+ apply sep_auto
+ apply (metis le_less nth_take)
+ apply (metis le_less nth_take)
+ apply sep_auto
+ subgoal for l' aa l'a aaa ba j
+ proof -
+ assume t0: "aa < n"
+ assume t1: " n \<le> length l'a"
+ assume t4: "sorted_less (take n l'a)"
+ assume t5: "j < (aa + n) div 2"
+ have "(aa+n) div 2 < n" using t0 by linarith
+ then have "(take n l'a) ! j < (take n l'a) ! ((aa + n) div 2)"
+ using t0 sorted_wrt_nth_less[where xs="take n l'a" and ?j="((aa + n) div 2)"]
+ t1 t4 t5 by auto
+ then show ?thesis
+ using \<open>(aa + n) div 2 < n\<close> t5 by auto
+ qed
+ subgoal for l' aa b l'a aaa ba j
+ proof -
+ assume t0: "aa < b"
+ assume t1: " n \<le> length l'a"
+ assume t3: "b \<le> n"
+ assume t4: "sorted_less (take n l'a)"
+ assume t5: "j < (aa + b) div 2"
+ have "(aa+b) div 2 < n" using t3 t0 by linarith
+ then have "(take n l'a) ! j < (take n l'a) ! ((aa + b) div 2)"
+ using t0 sorted_wrt_nth_less[where xs="take n l'a" and ?j="((aa + b) div 2)"]
+ t1 t4 t5 by auto
+ then show ?thesis
+ using \<open>(aa + b) div 2 < n\<close> t5 by auto
+ qed
+ apply (metis nth_take order_mono_setup.refl)
+ apply sep_auto
+ apply (sep_auto simp add: is_pfa_def)
+ done
+
+text "Then, using the same loop invariant, a binary split for B-tree-like arrays
+is derived in a straightforward manner."
+
+
+definition bin_split :: "('a::heap \<times> 'b::{heap,linorder}) pfarray \<Rightarrow> 'b \<Rightarrow> nat Heap"
+ where
+ "bin_split \<equiv> \<lambda>(a,n) p. do {
+ (low',high') \<leftarrow> heap_WHILET
+ (\<lambda>(low,high). return (low < high))
+ (\<lambda>(low,high). let mid = ((low + high) div 2) in
+ do {
+ (_,s) \<leftarrow> Array.nth a mid;
+ if p < s then
+ return (low, mid)
+ else if p > s then
+ return (mid+1, high)
+ else return (mid,mid)
+ })
+ (0::nat,n);
+ return low'
+}"
+
+
+thm nth_take
+
+lemma nth_take_eq: "take n ls = take n ls' \<Longrightarrow> i < n \<Longrightarrow> ls!i = ls'!i"
+ by (metis nth_take)
+
+lemma map_snd_sorted_less: "\<lbrakk>sorted_less (map snd xs); i < j; j < length xs\<rbrakk>
+ \<Longrightarrow> snd (xs ! i) < snd (xs ! j)"
+ by (metis (mono_tags, hide_lams) length_map less_trans nth_map sorted_wrt_iff_nth_less)
+
+lemma map_snd_sorted_lesseq: "\<lbrakk>sorted_less (map snd xs); i \<le> j; j < length xs\<rbrakk>
+ \<Longrightarrow> snd (xs ! i) \<le> snd (xs ! j)"
+ by (metis eq_iff less_imp_le map_snd_sorted_less order.not_eq_order_implies_strict)
+
+lemma bin_split_rule: "
+sorted_less (map snd xs) \<Longrightarrow>
+< is_pfa c xs (a,n)>
+ bin_split (a,n) p
+ <\<lambda>l. is_pfa c xs (a,n) * \<up>(l \<le> n \<and> (\<forall>j<l. snd(xs!j) < p) \<and> (l<n \<longrightarrow> snd(xs!l)\<ge>p)) >\<^sub>t"
+ (* this works in principle, as demonstrated above *)
+ unfolding bin_split_def
+
+ supply R = heap_WHILET_rule''[where
+ R = "measure (\<lambda>(l,h). h-l)"
+ and I = "\<lambda>(l,h). is_pfa c xs (a,n) * \<up>(l\<le>h \<and> h \<le> n \<and> (\<forall>j<l. snd (xs!j) < p) \<and> (h<n \<longrightarrow> snd (xs!h)\<ge>p))"
+ and b = "\<lambda>(l,h). l<h"
+ and Q="\<lambda>(l,h). is_pfa c xs (a,n) * \<up>(l \<le> n \<and> (\<forall>j<l. snd (xs!j) < p) \<and> (l<n \<longrightarrow> snd (xs!l)\<ge>p))"
+ ]
+ thm R
+
+ apply (sep_auto decon: R simp: less_Suc_eq is_pfa_def) []
+
+ apply(auto dest!: sndI nth_take_eq[of n _ _ "(_ + _) div 2"])[]
+ apply(auto dest!: sndI nth_take_eq[of n _ _ "(_ + _) div 2"])[]
+ apply (sep_auto dest!: sndI )
+ subgoal for ls i ls' _ _ j
+ using map_snd_sorted_lesseq[of "take n ls'" j "(i + n) div 2"]
+ less_mult_imp_div_less apply(auto)[]
+ done
+ subgoal for ls i j ls' _ _ j'
+ using map_snd_sorted_lesseq[of "take n ls'" j' "(i + j) div 2"]
+ less_mult_imp_div_less apply(auto)[]
+ done
+ apply sep_auto
+ subgoal for ls i ls' _ _ j
+ using map_snd_sorted_less[of "take n ls'" j "(i + n) div 2"]
+ less_mult_imp_div_less
+ apply(auto)[]
+ done
+ subgoal for ls i j ls' _ _ j'
+ using map_snd_sorted_less[of "take n ls'" j' "(i + j) div 2"]
+ less_mult_imp_div_less
+ apply(auto)[]
+ done
+ apply (metis le_less nth_take_eq)
+ apply sep_auto
+ apply (sep_auto simp add: is_pfa_def)
+ done
+
+
+subsection "Refinement of an abstract split"
+
+text "We provide a certain abstract split function
+that is particularly easy to analyse. The idea of this function is due to Peter Lammich."
+
+definition "abs_split xs x = (takeWhile (\<lambda>(_,s). s<x) xs, dropWhile (\<lambda>(_,s). s<x) xs)"
+
+interpretation btree_abs_search: split abs_split
+ unfolding abs_split_def sym[OF linear_split_alt]
+ by unfold_locales
+
+text \<open>Any function that yields the heap rule
+we have obtained for bin\_split and lin\_split also
+refines this abstract split.\<close>
+
+locale imp_split_smeq =
+ fixes split_fun :: "('a::{heap,default,linorder} btnode ref option \<times> 'a) array \<times> nat \<Rightarrow> 'a \<Rightarrow> nat Heap"
+ assumes split_rule: "sorted_less (separators xs) \<Longrightarrow>
+ <is_pfa c xs (a, n)>
+ split_fun (a, n) (p::'a)
+ <\<lambda>r. is_pfa c xs (a, n) *
+ \<up> (r \<le> n \<and>
+ (\<forall>j<r. snd (xs ! j) < p) \<and>
+ (r < n \<longrightarrow> p \<le> snd (xs ! r)))>\<^sub>t"
+begin
+
+
+lemma abs_split_full: "\<forall>(_,s) \<in> set xs. s < p \<Longrightarrow> abs_split xs p = (xs,[])"
+ by (simp add: abs_split_def)
+
+
+lemma abs_split_split:
+ assumes "n < length xs"
+ and "(\<forall>(_,s) \<in> set (take n xs). s < p)"
+ and " (case (xs!n) of (_,s) \<Rightarrow> \<not>(s < p))"
+ shows "abs_split xs p = (take n xs, drop n xs)"
+ using assms apply (auto simp add: abs_split_def)
+ apply (metis (mono_tags, lifting) id_take_nth_drop old.prod.case takeWhile_eq_all_conv takeWhile_tail)
+ by (metis (no_types, lifting) Cons_nth_drop_Suc case_prod_conv dropWhile.simps(2) dropWhile_append2 id_take_nth_drop)
+
+
+lemma split_rule_abs_split:
+ shows
+ "sorted_less (separators ts) \<Longrightarrow> <
+ is_pfa c tsi (a,n)
+ * list_assn (A \<times>\<^sub>a id_assn) ts tsi>
+ split_fun (a,n) p
+ <\<lambda>i.
+ is_pfa c tsi (a,n)
+ * list_assn (A \<times>\<^sub>a id_assn) ts tsi
+ * \<up>(split_relation ts (abs_split ts p) i)>\<^sub>t"
+ apply(rule hoare_triple_preI)
+ apply (sep_auto heap: split_rule dest!: mod_starD id_assn_list
+ simp add: list_assn_prod_map split_ismeq)
+ apply(auto simp add: is_pfa_def)
+proof -
+
+ fix h l' assume heap_init:
+ "h \<Turnstile> a \<mapsto>\<^sub>a l'"
+ "map snd ts = (map snd (take n l'))"
+ "n \<le> length l'"
+
+
+ show full_thm: "\<forall>j<n. snd (l' ! j) < p \<Longrightarrow>
+ split_relation ts (abs_split ts p) n"
+ proof -
+ assume sm_list: "\<forall>j<n. snd (l' ! j) < p"
+ then have "\<forall>j < length (map snd (take n l')). ((map snd (take n l'))!j) < p"
+ by simp
+ then have "\<forall>j<length (map snd ts). ((map snd ts)!j) < p"
+ using heap_init by simp
+ then have "\<forall>(_,s) \<in> set ts. s < p"
+ by (metis case_prod_unfold in_set_conv_nth length_map nth_map)
+ then have "abs_split ts p = (ts, [])"
+ using abs_split_full[of ts p] by simp
+ then show "split_relation ts (abs_split ts p) n"
+ using split_relation_length
+ by (metis heap_init(2) heap_init(3) length_map length_take min.absorb2)
+
+ qed
+ then show "\<forall>j<n. snd (l' ! j) < p \<Longrightarrow>
+ p \<le> snd (take n l' ! n) \<Longrightarrow>
+ split_relation ts (abs_split ts p) n"
+ by simp
+
+ show part_thm: "\<And>x. x < n \<Longrightarrow>
+ \<forall>j<x. snd (l' ! j) < p \<Longrightarrow>
+ p \<le> snd (l' ! x) \<Longrightarrow> split_relation ts (abs_split ts p) x"
+ proof -
+ fix x assume x_sm_len: "x < n"
+ moreover assume sm_list: "\<forall>j<x. snd (l' ! j) < p"
+ ultimately have "\<forall>j<x. ((map snd l') ! j) < p"
+ using heap_init
+ by auto
+ then have "\<forall>j<x. ((map snd ts)!j) < p"
+ using heap_init x_sm_len
+ by auto
+ moreover have x_sm_len_ts: "x < n"
+ using heap_init x_sm_len by auto
+ ultimately have "\<forall>(_,x) \<in> set (take x ts). x < p"
+ by (auto simp add: in_set_conv_nth min.absorb2)+
+ moreover assume "p \<le> snd (l' ! x)"
+ then have "case l'!x of (_,s) \<Rightarrow> \<not>(s < p)"
+ by (simp add: case_prod_unfold)
+ then have "case ts!x of (_,s) \<Rightarrow> \<not>(s < p)"
+ using heap_init x_sm_len x_sm_len_ts
+ by (metis (mono_tags, lifting) case_prod_unfold length_map length_take min.absorb2 nth_take snd_map_help(2))
+ ultimately have "abs_split ts p = (take x ts, drop x ts)"
+ using x_sm_len_ts abs_split_split[of x ts p] heap_init
+ by (metis length_map length_take min.absorb2)
+ then show "split_relation ts (abs_split ts p) x"
+ using x_sm_len_ts
+ by (metis append_take_drop_id heap_init(2) heap_init(3) length_map length_take less_imp_le_nat min.absorb2 split_relation_alt)
+ qed
+qed
+
+
+sublocale imp_split abs_split split_fun
+ apply(unfold_locales)
+ apply(sep_auto heap: split_rule_abs_split)
+ done
+
+end
+
+subsection "Obtaining executable code"
+
+text "In order to obtain fully defined functions,
+we need to plug our split function implementations
+into the locales we introduced previously."
+
+interpretation btree_imp_linear_split: imp_split_smeq lin_split
+ apply unfold_locales
+ apply(sep_auto heap: lin_split_rule)
+ done
+
+
+text "Obtaining actual code turns out to be slightly more difficult
+ due to the use of locales. However, we successfully obtain
+the B-tree insertion and membership query with binary search splitting."
+
+global_interpretation btree_imp_binary_split: imp_split_smeq bin_split
+ defines btree_isin = btree_imp_binary_split.isin
+ and btree_ins = btree_imp_binary_split.ins
+ and btree_insert = btree_imp_binary_split.insert
+ and btree_empty = btree_imp_binary_split.empty
+ apply unfold_locales
+ apply(sep_auto heap: bin_split_rule)
+ done
+
+thm btree_imp_binary_split.ins.simps
+declare btree_imp_binary_split.ins.simps[code] btree_imp_binary_split.isin.simps[code]
+
+export_code btree_empty btree_isin btree_insert checking SML Scala
+export_code btree_empty btree_isin btree_insert in SML module_name BTreeInsert
+export_code btree_empty btree_isin btree_insert in Scala module_name BTreeInsert
+
+end
+
diff --git a/thys/BTree/BTree_Set.thy b/thys/BTree/BTree_Set.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/BTree_Set.thy
@@ -0,0 +1,1931 @@
+theory BTree_Set
+ imports BTree
+ "HOL-Data_Structures.Set_Specs"
+begin
+
+section "Set interpretation"
+
+subsection "Auxiliary functions"
+
+fun split_half:: "('a btree\<times>'a) list \<Rightarrow> (('a btree\<times>'a) list \<times> ('a btree\<times>'a) list)" where
+ "split_half xs = (take (length xs div 2) xs, drop (length xs div 2) xs)"
+
+
+lemma drop_not_empty: "xs \<noteq> [] \<Longrightarrow> drop (length xs div 2) xs \<noteq> []"
+ apply(induction xs)
+ apply(auto split!: list.splits)
+ done
+
+lemma split_half_not_empty: "length xs \<ge> 1 \<Longrightarrow> \<exists>ls sub sep rs. split_half xs = (ls,(sub,sep)#rs)"
+ using drop_not_empty
+ by (metis (no_types, hide_lams) drop0 drop_eq_Nil eq_snd_iff hd_Cons_tl le_trans not_one_le_zero split_half.simps)
+
+subsection "The split function locale"
+
+text "Here, we abstract away the inner workings of the split function
+ for B-tree operations."
+
+(* TODO what if we define a function "list_split" that returns
+ a split list for mapping arbitrary f (separators) and g (subtrees)
+s.th. f :: 'a \<Rightarrow> ('b::linorder) and g :: 'a \<Rightarrow> 'a btree
+this would allow for key,pointer pairs to be inserted into the tree *)
+(* TODO what if the keys are the pointers? *)
+locale split =
+ fixes split :: "('a btree\<times>'a::linorder) list \<Rightarrow> 'a \<Rightarrow> (('a btree\<times>'a) list \<times> ('a btree\<times>'a) list)"
+ assumes split_req:
+ "\<lbrakk>split xs p = (ls,rs)\<rbrakk> \<Longrightarrow> xs = ls @ rs"
+ "\<lbrakk>split xs p = (ls@[(sub,sep)],rs); sorted_less (separators xs)\<rbrakk> \<Longrightarrow> sep < p"
+ "\<lbrakk>split xs p = (ls,(sub,sep)#rs); sorted_less (separators xs)\<rbrakk> \<Longrightarrow> p \<le> sep"
+begin
+
+lemmas split_conc = split_req(1)
+lemmas split_sorted = split_req(2,3)
+
+
+lemma [termination_simp]:"(ls, (sub, sep) # rs) = split ts y \<Longrightarrow>
+ size sub < Suc (size_list (\<lambda>x. Suc (size (fst x))) ts + size l)"
+ using split_conc[of ts y ls "(sub,sep)#rs"] by auto
+
+
+fun invar_inorder where "invar_inorder k t = (bal t \<and> root_order k t)"
+
+definition "empty_btree = Leaf"
+
+subsection "Membership"
+
+fun isin:: "'a btree \<Rightarrow> 'a \<Rightarrow> bool" where
+ "isin (Leaf) y = False" |
+ "isin (Node ts t) y = (
+ case split ts y of (_,(sub,sep)#rs) \<Rightarrow> (
+ if y = sep then
+ True
+ else
+ isin sub y
+ )
+ | (_,[]) \<Rightarrow> isin t y
+ )"
+
+subsection "Insertion"
+
+text "The insert function requires an auxiliary data structure
+and auxiliary invariant functions."
+
+datatype 'b up\<^sub>i = T\<^sub>i "'b btree" | Up\<^sub>i "'b btree" 'b "'b btree"
+
+fun order_up\<^sub>i where
+ "order_up\<^sub>i k (T\<^sub>i sub) = order k sub" |
+ "order_up\<^sub>i k (Up\<^sub>i l a r) = (order k l \<and> order k r)"
+
+fun root_order_up\<^sub>i where
+ "root_order_up\<^sub>i k (T\<^sub>i sub) = root_order k sub" |
+ "root_order_up\<^sub>i k (Up\<^sub>i l a r) = (order k l \<and> order k r)"
+
+
+fun height_up\<^sub>i where
+ "height_up\<^sub>i (T\<^sub>i t) = height t" |
+ "height_up\<^sub>i (Up\<^sub>i l a r) = max (height l) (height r)"
+
+fun bal_up\<^sub>i where
+ "bal_up\<^sub>i (T\<^sub>i t) = bal t" |
+ "bal_up\<^sub>i (Up\<^sub>i l a r) = (height l = height r \<and> bal l \<and> bal r)"
+
+fun inorder_up\<^sub>i where
+ "inorder_up\<^sub>i (T\<^sub>i t) = inorder t" |
+ "inorder_up\<^sub>i (Up\<^sub>i l a r) = inorder l @ [a] @ inorder r"
+
+
+text "The following function merges two nodes and returns separately split nodes
+ if an overflow occurs"
+
+fun node\<^sub>i:: "nat \<Rightarrow> ('a btree \<times> 'a) list \<Rightarrow> 'a btree \<Rightarrow> 'a up\<^sub>i" where
+ "node\<^sub>i k ts t = (
+ if length ts \<le> 2*k then T\<^sub>i (Node ts t)
+ else (
+ case split_half ts of (ls, (sub,sep)#rs) \<Rightarrow>
+ Up\<^sub>i (Node ls sub) sep (Node rs t)
+ )
+ )"
+
+
+fun ins:: "nat \<Rightarrow> 'a \<Rightarrow> 'a btree \<Rightarrow> 'a up\<^sub>i" where
+ "ins k x Leaf = (Up\<^sub>i Leaf x Leaf)" |
+ "ins k x (Node ts t) = (
+ case split ts x of
+ (ls,(sub,sep)#rs) \<Rightarrow>
+ (if sep = x then
+ T\<^sub>i (Node ts t)
+ else
+ (case ins k x sub of
+ Up\<^sub>i l a r \<Rightarrow>
+ node\<^sub>i k (ls @ (l,a)#(r,sep)#rs) t |
+ T\<^sub>i a \<Rightarrow>
+ T\<^sub>i (Node (ls @ (a,sep) # rs) t))) |
+ (ls, []) \<Rightarrow>
+ (case ins k x t of
+ Up\<^sub>i l a r \<Rightarrow>
+ node\<^sub>i k (ls@[(l,a)]) r |
+ T\<^sub>i a \<Rightarrow>
+ T\<^sub>i (Node ls a)
+ )
+)"
+
+
+
+fun tree\<^sub>i::"'a up\<^sub>i \<Rightarrow> 'a btree" where
+ "tree\<^sub>i (T\<^sub>i sub) = sub" |
+ "tree\<^sub>i (Up\<^sub>i l a r) = (Node [(l,a)] r)"
+
+fun insert::"nat \<Rightarrow> 'a \<Rightarrow> 'a btree \<Rightarrow> 'a btree" where
+ "insert k x t = tree\<^sub>i (ins k x t)"
+
+subsection "Deletion"
+
+text "The following deletion method is inspired by Bayer (70) and Fielding (??).
+Rather than stealing only a single node from the neighbour,
+the neighbour is fully merged with the potentially underflowing node.
+If the resulting node is still larger than allowed, the merged node is split
+again, using the rules known from insertion splits.
+If the resulting node has admissable size, it is simply kept in the tree."
+
+fun rebalance_middle_tree where
+ "rebalance_middle_tree k ls Leaf sep rs Leaf = (
+ Node (ls@(Leaf,sep)#rs) Leaf
+)" |
+ "rebalance_middle_tree k ls (Node mts mt) sep rs (Node tts tt) = (
+ if length mts \<ge> k \<and> length tts \<ge> k then
+ Node (ls@(Node mts mt,sep)#rs) (Node tts tt)
+ else (
+ case rs of [] \<Rightarrow> (
+ case node\<^sub>i k (mts@(mt,sep)#tts) tt of
+ T\<^sub>i u \<Rightarrow>
+ Node ls u |
+ Up\<^sub>i l a r \<Rightarrow>
+ Node (ls@[(l,a)]) r) |
+ (Node rts rt,rsep)#rs \<Rightarrow> (
+ case node\<^sub>i k (mts@(mt,sep)#rts) rt of
+ T\<^sub>i u \<Rightarrow>
+ Node (ls@(u,rsep)#rs) (Node tts tt) |
+ Up\<^sub>i l a r \<Rightarrow>
+ Node (ls@(l,a)#(r,rsep)#rs) (Node tts tt))
+))"
+
+text "Deletion"
+
+text "All trees are merged with the right neighbour on underflow.
+Obviously for the last tree this would not work since it has no right neighbour.
+Therefore this tree, as the only exception, is merged with the left neighbour.
+However since we it does not make a difference, we treat the situation
+as if the second to last tree underflowed."
+
+fun rebalance_last_tree where
+ "rebalance_last_tree k ts t = (
+case last ts of (sub,sep) \<Rightarrow>
+ rebalance_middle_tree k (butlast ts) sub sep [] t
+)"
+
+text "Rather than deleting the minimal key from the right subtree,
+we remove the maximal key of the left subtree.
+This is due to the fact that the last tree can easily be accessed
+and the left neighbour is way easier to access than the right neighbour,
+it resides in the same pair as the separating element to be removed."
+
+
+
+fun split_max where
+ "split_max k (Node ts t) = (case t of Leaf \<Rightarrow> (
+ let (sub,sep) = last ts in
+ (Node (butlast ts) sub, sep)
+)|
+_ \<Rightarrow>
+case split_max k t of (sub, sep) \<Rightarrow>
+ (rebalance_last_tree k ts sub, sep)
+)"
+
+fun del where
+ "del k x Leaf = Leaf" |
+ "del k x (Node ts t) = (
+ case split ts x of
+ (ls,[]) \<Rightarrow>
+ rebalance_last_tree k ls (del k x t)
+ | (ls,(sub,sep)#rs) \<Rightarrow> (
+ if sep \<noteq> x then
+ rebalance_middle_tree k ls (del k x sub) sep rs t
+ else if sub = Leaf then
+ Node (ls@rs) t
+ else let (sub_s, max_s) = split_max k sub in
+ rebalance_middle_tree k ls sub_s max_s rs t
+ )
+)"
+
+fun reduce_root where
+ "reduce_root Leaf = Leaf" |
+ "reduce_root (Node ts t) = (case ts of
+ [] \<Rightarrow> t |
+ _ \<Rightarrow> (Node ts t)
+)"
+
+
+fun delete where "delete k x t = reduce_root (del k x t)"
+
+
+text "An invariant for intermediate states at deletion.
+In particular we allow for an underflow to 0 subtrees."
+
+fun almost_order where
+ "almost_order k Leaf = True" |
+ "almost_order k (Node ts t) = (
+ (length ts \<le> 2*k) \<and>
+ (\<forall>s \<in> set (subtrees ts). order k s) \<and>
+ order k t
+)"
+
+
+text "A recursive property of the \"spine\" we want to walk along for splitting
+ off the maximum of the left subtree."
+
+fun nonempty_lasttreebal where
+ "nonempty_lasttreebal Leaf = True" |
+ "nonempty_lasttreebal (Node ts t) = (
+ (\<exists>ls tsub tsep. ts = (ls@[(tsub,tsep)]) \<and> height tsub = height t) \<and>
+ nonempty_lasttreebal t
+ )"
+
+subsection "Proofs of functional correctness"
+
+lemma split_set:
+ assumes "split ts z = (ls,(a,b)#rs)"
+ shows "(a,b) \<in> set ts"
+ and "(x,y) \<in> set ls \<Longrightarrow> (x,y) \<in> set ts"
+ and "(x,y) \<in> set rs \<Longrightarrow> (x,y) \<in> set ts"
+ and "set ls \<union> set rs \<union> {(a,b)} = set ts"
+ and "\<exists>x \<in> set ts. b \<in> Basic_BNFs.snds x"
+ using split_conc assms by fastforce+
+
+lemma split_length:
+ "split ts x = (ls, rs) \<Longrightarrow> length ls + length rs = length ts"
+ by (auto dest: split_conc)
+
+
+text "Isin proof"
+
+thm isin_simps
+ (* copied from comment in List_Ins_Del *)
+lemma sorted_ConsD: "sorted_less (y # xs) \<Longrightarrow> x \<le> y \<Longrightarrow> x \<notin> set xs"
+ by (auto simp: sorted_Cons_iff)
+
+lemma sorted_snocD: "sorted_less (xs @ [y]) \<Longrightarrow> y \<le> x \<Longrightarrow> x \<notin> set xs"
+ by (auto simp: sorted_snoc_iff)
+
+
+lemmas isin_simps2 = sorted_lems sorted_ConsD sorted_snocD
+ (*-----------------------------*)
+
+lemma isin_sorted: "sorted_less (xs@a#ys) \<Longrightarrow>
+ (x \<in> set (xs@a#ys)) = (if x < a then x \<in> set xs else x \<in> set (a#ys))"
+ by (auto simp: isin_simps2)
+
+(* lift to split *)
+
+
+lemma isin_sorted_split:
+ assumes "sorted_less (inorder (Node ts t))"
+ and "split ts x = (ls, rs)"
+ shows "x \<in> set (inorder (Node ts t)) = (x \<in> set (inorder_list rs @ inorder t))"
+proof (cases ls)
+ case Nil
+ then have "ts = rs"
+ using assms by (auto dest!: split_conc)
+ then show ?thesis by simp
+next
+ case Cons
+ then obtain ls' sub sep where ls_tail_split: "ls = ls' @ [(sub,sep)]"
+ by (metis list.simps(3) rev_exhaust surj_pair)
+ then have "sep < x"
+ using split_req(2)[of ts x ls' sub sep rs]
+ using sorted_inorder_separators[OF assms(1)]
+ using assms
+ by simp
+ then show ?thesis
+ using assms(1) split_conc[OF assms(2)] ls_tail_split
+ using isin_sorted[of "inorder_list ls' @ inorder sub" sep "inorder_list rs @ inorder t" x]
+ by auto
+qed
+
+lemma isin_sorted_split_right:
+ assumes "split ts x = (ls, (sub,sep)#rs)"
+ and "sorted_less (inorder (Node ts t))"
+ and "sep \<noteq> x"
+ shows "x \<in> set (inorder_list ((sub,sep)#rs) @ inorder t) = (x \<in> set (inorder sub))"
+proof -
+ from assms have "x < sep"
+ proof -
+ from assms have "sorted_less (separators ts)"
+ by (simp add: sorted_inorder_separators)
+ then show ?thesis
+ using split_req(3)
+ using assms
+ by fastforce
+ qed
+ moreover have "sorted_less (inorder_list ((sub,sep)#rs) @ inorder t)"
+ using assms sorted_wrt_append split_conc
+ by fastforce
+ ultimately show ?thesis
+ using isin_sorted[of "inorder sub" "sep" "inorder_list rs @ inorder t" x]
+ by simp
+qed
+
+
+theorem isin_set_inorder: "sorted_less (inorder t) \<Longrightarrow> isin t x = (x \<in> set (inorder t))"
+proof(induction t x rule: isin.induct)
+ case (2 ts t x)
+ then obtain ls rs where list_split: "split ts x = (ls, rs)"
+ by (meson surj_pair)
+ then have list_conc: "ts = ls @ rs"
+ using split_conc by auto
+ show ?case
+ proof (cases rs)
+ case Nil
+ then have "isin (Node ts t) x = isin t x"
+ by (simp add: list_split)
+ also have "\<dots> = (x \<in> set (inorder t))"
+ using "2.IH"(1) list_split Nil
+ using "2.prems" sorted_inorder_induct_last by auto
+ also have "\<dots> = (x \<in> set (inorder (Node ts t)))"
+ using isin_sorted_split[of ts t x ls rs]
+ using "2.prems" list_split list_conc Nil
+ by simp
+ finally show ?thesis .
+ next
+ case (Cons a list)
+ then obtain sub sep where a_split: "a = (sub,sep)"
+ by (cases a)
+ then show ?thesis
+ proof (cases "x = sep")
+ case True
+ then show ?thesis
+ using list_conc Cons a_split list_split
+ by auto
+ next
+ case False
+ then have "isin (Node ts t) x = isin sub x"
+ using list_split Cons a_split False
+ by auto
+ also have "\<dots> = (x \<in> set (inorder sub))"
+ using "2.IH"(2)
+ using "2.prems" False a_split list_conc list_split local.Cons sorted_inorder_induct_subtree by fastforce
+ also have "\<dots> = (x \<in> set (inorder (Node ts t)))"
+ using isin_sorted_split[OF "2.prems" list_split]
+ using isin_sorted_split_right "2.prems" list_split Cons a_split False
+ by simp
+ finally show ?thesis .
+ qed
+ qed
+qed auto
+
+
+
+
+(* TODO way to use this for custom case distinction? *)
+lemma node\<^sub>i_cases: "length xs \<le> k \<or> (\<exists>ls sub sep rs. split_half xs = (ls,(sub,sep)#rs))"
+proof -
+ have "\<not> length xs \<le> k \<Longrightarrow> length xs \<ge> 1"
+ by linarith
+ then show ?thesis
+ using split_half_not_empty
+ by blast
+qed
+
+
+lemma root_order_tree\<^sub>i: "root_order_up\<^sub>i (Suc k) t = root_order (Suc k) (tree\<^sub>i t)"
+ apply (cases t)
+ apply auto
+ done
+
+lemma node\<^sub>i_root_order:
+ assumes "length ts > 0"
+ and "length ts \<le> 4*k+1"
+ and "\<forall>x \<in> set (subtrees ts). order k x"
+ and "order k t"
+ shows "root_order_up\<^sub>i k (node\<^sub>i k ts t)"
+proof (cases "length ts \<le> 2*k")
+ case True
+ then show ?thesis
+ using assms
+ by (simp add: node\<^sub>i.simps)
+next
+ case False
+ then obtain ls sub sep rs where split_half_ts:
+ "take (length ts div 2) ts = ls"
+ "drop (length ts div 2) ts = (sub,sep)#rs"
+ using split_half_not_empty[of ts]
+ by auto
+ then have length_rs: "length rs = length ts - (length ts div 2) - 1"
+ using length_drop
+ by (metis One_nat_def add_diff_cancel_right' list.size(4))
+ also have "\<dots> \<le> 4*k - ((4*k + 1) div 2)"
+ using assms(2) by simp
+ also have "\<dots> = 2*k"
+ by auto
+ finally have "length rs \<le> 2*k"
+ by simp
+ moreover have "length rs \<ge> k"
+ using False length_rs by simp
+ moreover have "set ((sub,sep)#rs) \<subseteq> set ts"
+ by (metis split_half_ts(2) set_drop_subset)
+ ultimately have o_r: "order k sub" "order k (Node rs t)"
+ using split_half_ts assms by auto
+ moreover have "length ls \<ge> k"
+ using length_take assms split_half_ts False
+ by auto
+ moreover have "length ls \<le> 2*k"
+ using assms(2) split_half_ts
+ by auto
+ ultimately have o_l: "order k (Node ls sub)"
+ using set_take_subset assms split_half_ts
+ by fastforce
+ from o_r o_l show ?thesis
+ by (simp add: node\<^sub>i.simps False split_half_ts)
+qed
+
+lemma node\<^sub>i_order_helper:
+ assumes "length ts \<ge> k"
+ and "length ts \<le> 4*k+1"
+ and "\<forall>x \<in> set (subtrees ts). order k x"
+ and "order k t"
+ shows "case (node\<^sub>i k ts t) of T\<^sub>i t \<Rightarrow> order k t | _ \<Rightarrow> True"
+proof (cases "length ts \<le> 2*k")
+ case True
+ then show ?thesis
+ using assms
+ by (simp add: node\<^sub>i.simps)
+next
+ case False
+ then obtain sub sep rs where
+ "drop (length ts div 2) ts = (sub,sep)#rs"
+ using split_half_not_empty[of ts]
+ by auto
+ then show ?thesis
+ using assms by (simp add: node\<^sub>i.simps)
+qed
+
+
+lemma node\<^sub>i_order:
+ assumes "length ts \<ge> k"
+ and "length ts \<le> 4*k+1"
+ and "\<forall>x \<in> set (subtrees ts). order k x"
+ and "order k t"
+ shows "order_up\<^sub>i k (node\<^sub>i k ts t)"
+
+ apply(cases "node\<^sub>i k ts t")
+ using node\<^sub>i_root_order node\<^sub>i_order_helper assms apply fastforce
+ apply (metis node\<^sub>i_root_order assms(2,3,4) le0 length_greater_0_conv
+ list.size(3) node\<^sub>i.simps order_up\<^sub>i.simps(2) root_order_up\<^sub>i.simps(2) up\<^sub>i.distinct(1))
+ done
+
+(* explicit proof *)
+lemma ins_order:
+ "order k t \<Longrightarrow> order_up\<^sub>i k (ins k x t)"
+proof(induction k x t rule: ins.induct)
+ case (2 k x ts t)
+ then obtain ls rs where split_res: "split ts x = (ls, rs)"
+ by (meson surj_pair)
+ then have split_app: "ls@rs = ts"
+ using split_conc
+ by simp
+
+ show ?case
+ proof (cases rs)
+ case Nil
+ then have "order_up\<^sub>i k (ins k x t)"
+ using 2 split_res
+ by simp
+ then show ?thesis
+ using Nil 2 split_app split_res Nil node\<^sub>i_order
+ by (auto split!: up\<^sub>i.splits simp del: node\<^sub>i.simps)
+ next
+ case (Cons a list)
+ then obtain sub sep where a_prod: "a = (sub, sep)"
+ by (cases a)
+ then show ?thesis
+ proof (cases "x = sep")
+ case True
+ then show ?thesis
+ using 2 a_prod Cons split_res
+ by simp
+ next
+ case False
+ then have "order_up\<^sub>i k (ins k x sub)"
+ using "2.IH"(2) "2.prems" a_prod local.Cons split_app split_res by auto
+ then show ?thesis
+ using 2 split_app Cons length_append node\<^sub>i_order a_prod split_res
+ by (auto split!: up\<^sub>i.splits simp del: node\<^sub>i.simps simp add: order_impl_root_order)
+ qed
+ qed
+qed simp
+
+
+(* notice this is almost a duplicate of ins_order *)
+lemma ins_root_order:
+ assumes "root_order k t"
+ shows "root_order_up\<^sub>i k (ins k x t)"
+proof(cases t)
+ case (Node ts t)
+ then obtain ls rs where split_res: "split ts x = (ls, rs)"
+ by (meson surj_pair)
+ then have split_app: "ls@rs = ts"
+ using split_conc
+ by fastforce
+
+ show ?thesis
+ proof (cases rs)
+ case Nil
+ then have "order_up\<^sub>i k (ins k x t)" using Node assms split_res
+ by (simp add: ins_order)
+ then show ?thesis
+ using Nil Node split_app split_res assms node\<^sub>i_root_order
+ by (auto split!: up\<^sub>i.splits simp del: node\<^sub>i.simps simp add: order_impl_root_order)
+ next
+ case (Cons a list)
+ then obtain sub sep where a_prod: "a = (sub, sep)"
+ by (cases a)
+ then show ?thesis
+ proof (cases "x = sep")
+ case True
+ then show ?thesis using assms Node a_prod Cons split_res
+ by simp
+ next
+ case False
+ then have "order_up\<^sub>i k (ins k x sub)"
+ using Node a_prod assms ins_order local.Cons split_app by auto
+ then show ?thesis
+ using assms split_app Cons length_append Node node\<^sub>i_root_order a_prod split_res
+ by (auto split!: up\<^sub>i.splits simp del: node\<^sub>i.simps simp add: order_impl_root_order)
+ qed
+ qed
+qed simp
+
+
+
+lemma height_list_split: "height_up\<^sub>i (Up\<^sub>i (Node ls a) b (Node rs t)) = height (Node (ls@(a,b)#rs) t) "
+ by (induction ls) (auto simp add: max.commute)
+
+lemma node\<^sub>i_height: "height_up\<^sub>i (node\<^sub>i k ts t) = height (Node ts t)"
+proof(cases "length ts \<le> 2*k")
+ case False
+ then obtain ls sub sep rs where
+ split_half_ts: "split_half ts = (ls, (sub, sep) # rs)"
+ by (meson node\<^sub>i_cases)
+ then have "node\<^sub>i k ts t = Up\<^sub>i (Node ls (sub)) sep (Node rs t)"
+ using False by simp
+ then show ?thesis
+ using split_half_ts
+ by (metis append_take_drop_id fst_conv height_list_split snd_conv split_half.elims)
+qed simp
+
+
+
+lemma bal_up\<^sub>i_tree: "bal_up\<^sub>i t = bal (tree\<^sub>i t)"
+ apply(cases t)
+ apply auto
+ done
+
+lemma bal_list_split: "bal (Node (ls@(a,b)#rs) t) \<Longrightarrow> bal_up\<^sub>i (Up\<^sub>i (Node ls a) b (Node rs t))"
+ by (auto simp add: image_constant_conv)
+
+lemma node\<^sub>i_bal:
+ assumes "bal (Node ts t)"
+ shows "bal_up\<^sub>i (node\<^sub>i k ts t)"
+ using assms
+proof(cases "length ts \<le> 2*k")
+ case False
+ then obtain ls sub sep rs where
+ split_half_ts: "split_half ts = (ls, (sub, sep) # rs)"
+ by (meson node\<^sub>i_cases)
+ then have "bal (Node (ls@(sub,sep)#rs) t)"
+ using assms append_take_drop_id[where n="length ts div 2" and xs=ts]
+ by auto
+ then show ?thesis
+ using split_half_ts assms False
+ by (auto simp del: bal.simps bal_up\<^sub>i.simps dest!: bal_list_split[of ls sub sep rs t])
+qed simp
+
+lemma height_up\<^sub>i_merge: "height_up\<^sub>i (Up\<^sub>i l a r) = height t \<Longrightarrow> height (Node (ls@(t,x)#rs) tt) = height (Node (ls@(l,a)#(r,x)#rs) tt)"
+ by simp
+
+lemma ins_height: "height_up\<^sub>i (ins k x t) = height t"
+proof(induction k x t rule: ins.induct)
+ case (2 k x ts t)
+ then obtain ls rs where split_list: "split ts x = (ls,rs)"
+ by (meson surj_pair)
+ then have split_append: "ls@rs = ts"
+ using split_conc
+ by auto
+ then show ?case
+ proof (cases rs)
+ case Nil
+ then have height_sub: "height_up\<^sub>i (ins k x t) = height t"
+ using 2 by (simp add: split_list)
+ then show ?thesis
+ proof (cases "ins k x t")
+ case (T\<^sub>i a)
+ then have "height (Node ts t) = height (Node ts a)"
+ using height_sub
+ by simp
+ then show ?thesis
+ using T\<^sub>i Nil split_list split_append
+ by simp
+ next
+ case (Up\<^sub>i l a r)
+ then have "height (Node ls t) = height (Node (ls@[(l,a)]) r)"
+ using height_btree_order height_sub by (induction ls) auto
+ then show ?thesis using 2 Nil split_list Up\<^sub>i split_append
+ by (simp del: node\<^sub>i.simps add: node\<^sub>i_height)
+ qed
+ next
+ case (Cons a list)
+ then obtain sub sep where a_split: "a = (sub,sep)"
+ by (cases a)
+ then show ?thesis
+ proof (cases "x = sep")
+ case True
+ then show ?thesis
+ using Cons a_split 2 split_list
+ by (simp del: height_btree.simps)
+ next
+ case False
+ then have height_sub: "height_up\<^sub>i (ins k x sub) = height sub"
+ by (metis "2.IH"(2) a_split Cons split_list)
+ then show ?thesis
+ proof (cases "ins k x sub")
+ case (T\<^sub>i a)
+ then have "height a = height sub"
+ using height_sub by auto
+ then have "height (Node (ls@(sub,sep)#rs) t) = height (Node (ls@(a,sep)#rs) t)"
+ by auto
+ then show ?thesis
+ using T\<^sub>i height_sub False Cons 2 split_list a_split split_append
+ by (auto simp add: image_Un max.commute finite_set_ins_swap)
+ next
+ case (Up\<^sub>i l a r)
+ then have "height (Node (ls@(sub,sep)#list) t) = height (Node (ls@(l,a)#(r,sep)#list) t)"
+ using height_up\<^sub>i_merge height_sub
+ by fastforce
+ then show ?thesis
+ using Up\<^sub>i False Cons 2 split_list a_split split_append
+ by (auto simp del: node\<^sub>i.simps simp add: node\<^sub>i_height image_Un max.commute finite_set_ins_swap)
+ qed
+ qed
+ qed
+qed simp
+
+
+(* the below proof is overly complicated as a number of lemmas regarding height are missing *)
+lemma ins_bal: "bal t \<Longrightarrow> bal_up\<^sub>i (ins k x t)"
+proof(induction k x t rule: ins.induct)
+ case (2 k x ts t)
+ then obtain ls rs where split_res: "split ts x = (ls, rs)"
+ by (meson surj_pair)
+ then have split_app: "ls@rs = ts"
+ using split_conc
+ by fastforce
+
+ show ?case
+ proof (cases rs)
+ case Nil
+ then show ?thesis
+ proof (cases "ins k x t")
+ case (T\<^sub>i a)
+ then have "bal (Node ls a)" unfolding bal.simps
+ by (metis "2.IH"(1) "2.prems" append_Nil2 bal.simps(2) bal_up\<^sub>i.simps(1) height_up\<^sub>i.simps(1) ins_height local.Nil split_app split_res)
+ then show ?thesis
+ using Nil T\<^sub>i 2 split_res
+ by simp
+ next
+ case (Up\<^sub>i l a r)
+ then have
+ "(\<forall>x\<in>set (subtrees (ls@[(l,a)])). bal x)"
+ "(\<forall>x\<in>set (subtrees ls). height r = height x)"
+ using 2 Up\<^sub>i Nil split_res split_app
+ by simp_all (metis height_up\<^sub>i.simps(2) ins_height max_def)
+ then show ?thesis unfolding ins.simps
+ using Up\<^sub>i Nil 2 split_res
+ by (simp del: node\<^sub>i.simps add: node\<^sub>i_bal)
+ qed
+ next
+ case (Cons a list)
+ then obtain sub sep where a_prod: "a = (sub, sep)" by (cases a)
+ then show ?thesis
+ proof (cases "x = sep")
+ case True
+ then show ?thesis
+ using a_prod 2 split_res Cons by simp
+ next
+ case False
+ then have "bal_up\<^sub>i (ins k x sub)" using 2 split_res
+ using a_prod local.Cons split_app by auto
+ show ?thesis
+ proof (cases "ins k x sub")
+ case (T\<^sub>i x1)
+ then have "height x1 = height t"
+ by (metis "2.prems" a_prod add_diff_cancel_left' bal_split_left(1) bal_split_left(2) height_bal_tree height_up\<^sub>i.simps(1) ins_height local.Cons plus_1_eq_Suc split_app)
+ then show ?thesis
+ using split_app Cons T\<^sub>i 2 split_res a_prod
+ by auto
+ next
+ case (Up\<^sub>i l a r)
+ (* The only case where explicit reasoning is required - likely due to the insertion of 2 elements in the list *)
+ then have
+ "\<forall>x \<in> set (subtrees (ls@(l,a)#(r,sep)#list)). bal x"
+ using Up\<^sub>i split_app Cons 2 \<open>bal_up\<^sub>i (ins k x sub)\<close> by auto
+ moreover have "\<forall>x \<in> set (subtrees (ls@(l,a)#(r,sep)#list)). height x = height t"
+ using False Up\<^sub>i split_app Cons 2 \<open>bal_up\<^sub>i (ins k x sub)\<close> ins_height split_res a_prod
+ apply auto
+ by (metis height_up\<^sub>i.simps(2) sup.idem sup_nat_def)
+ ultimately show ?thesis using Up\<^sub>i Cons 2 split_res a_prod
+ by (simp del: node\<^sub>i.simps add: node\<^sub>i_bal)
+ qed
+ qed
+ qed
+qed simp
+
+(* ins acts as ins_list wrt inorder *)
+
+(* "simple enough" to be automatically solved *)
+lemma node\<^sub>i_inorder: "inorder_up\<^sub>i (node\<^sub>i k ts t) = inorder (Node ts t)"
+ apply(cases "length ts \<le> 2*k")
+ apply (auto split!: list.splits)
+ (* we want to only transform in one direction here.. *)
+ supply R = sym[OF append_take_drop_id, of "map _ ts" "(length ts div 2)"]
+ thm R
+ apply(subst R)
+ apply (simp del: append_take_drop_id add: take_map drop_map)
+ done
+
+corollary node\<^sub>i_inorder_simps:
+ "node\<^sub>i k ts t = T\<^sub>i t' \<Longrightarrow> inorder t' = inorder (Node ts t)"
+ "node\<^sub>i k ts t = Up\<^sub>i l a r \<Longrightarrow> inorder l @ a # inorder r = inorder (Node ts t)"
+ apply (metis inorder_up\<^sub>i.simps(1) node\<^sub>i_inorder)
+ by (metis append_Cons inorder_up\<^sub>i.simps(2) node\<^sub>i_inorder self_append_conv2)
+
+
+lemma ins_sorted_inorder: "sorted_less (inorder t) \<Longrightarrow> (inorder_up\<^sub>i (ins k (x::('a::linorder)) t)) = ins_list x (inorder t)"
+ apply(induction k x t rule: ins.induct)
+ using split_axioms apply (auto split!: prod.splits list.splits up\<^sub>i.splits simp del: node\<^sub>i.simps
+ simp add: node\<^sub>i_inorder node\<^sub>i_inorder_simps)
+ (* from here on we prefer an explicit proof, showing how to apply the IH *)
+ oops
+
+
+(* specialize ins_list_sorted since it is cumbersome to express
+ "inorder_list ts" as "xs @ [a]" and always having to use the implicit properties of split*)
+
+lemma ins_list_split:
+ assumes "split ts x = (ls, rs)"
+ and "sorted_less (inorder (Node ts t))"
+ shows "ins_list x (inorder (Node ts t)) = inorder_list ls @ ins_list x (inorder_list rs @ inorder t)"
+proof (cases ls)
+ case Nil
+ then show ?thesis
+ using assms by (auto dest!: split_conc)
+next
+ case Cons
+ then obtain ls' sub sep where ls_tail_split: "ls = ls' @ [(sub,sep)]"
+ by (metis list.distinct(1) rev_exhaust surj_pair)
+ moreover have "sep < x"
+ using split_req(2)[of ts x ls' sub sep rs]
+ using sorted_inorder_separators
+ using assms(1) assms(2) ls_tail_split
+ by auto
+ moreover have "sorted_less (inorder_list ls)"
+ using assms sorted_wrt_append split_conc by fastforce
+ ultimately show ?thesis using assms(2) split_conc[OF assms(1)]
+ using ins_list_sorted[of "inorder_list ls' @ inorder sub" sep]
+ by auto
+qed
+
+lemma ins_list_split_right_general:
+ assumes "split ts x = (ls, (sub,sep)#rs)"
+ and "sorted_less (inorder_list ts)"
+ and "sep \<noteq> x"
+ shows "ins_list x (inorder_list ((sub,sep)#rs) @ zs) = ins_list x (inorder sub) @ sep # inorder_list rs @ zs"
+proof -
+ from assms have "x < sep"
+ proof -
+ from assms have "sorted_less (separators ts)"
+ by (simp add: sorted_inorder_list_separators)
+ then show ?thesis
+ using split_req(3)
+ using assms
+ by fastforce
+ qed
+ moreover have "sorted_less (inorder_pair (sub,sep))"
+ by (metis (no_types, lifting) assms(1) assms(2) concat.simps(2) concat_append list.simps(9) map_append sorted_wrt_append split_conc)
+ ultimately show ?thesis
+ using ins_list_sorted[of "inorder sub" "sep"]
+ by auto
+qed
+
+(* this fits the actual use cases better *)
+corollary ins_list_split_right:
+ assumes "split ts x = (ls, (sub,sep)#rs)"
+ and "sorted_less (inorder (Node ts t))"
+ and "sep \<noteq> x"
+ shows "ins_list x (inorder_list ((sub,sep)#rs) @ inorder t) = ins_list x (inorder sub) @ sep # inorder_list rs @ inorder t"
+ using assms sorted_wrt_append split.ins_list_split_right_general split_axioms by fastforce
+
+
+(* a simple lemma, missing from the standard as of now *)
+lemma ins_list_idem_eq_isin: "sorted_less xs \<Longrightarrow> x \<in> set xs \<longleftrightarrow> (ins_list x xs = xs)"
+ apply(induction xs)
+ apply auto
+ done
+
+lemma ins_list_contains_idem: "\<lbrakk>sorted_less xs; x \<in> set xs\<rbrakk> \<Longrightarrow> (ins_list x xs = xs)"
+ using ins_list_idem_eq_isin by auto
+
+
+declare node\<^sub>i.simps [simp del]
+declare node\<^sub>i_inorder [simp add]
+
+lemma ins_inorder: "sorted_less (inorder t) \<Longrightarrow> (inorder_up\<^sub>i (ins k x t)) = ins_list x (inorder t)"
+proof(induction k x t rule: ins.induct)
+ case (1 k x)
+ then show ?case by auto
+next
+ case (2 k x ts t)
+ then obtain ls rs where list_split: "split ts x = (ls,rs)"
+ by (cases "split ts x")
+ then have list_conc: "ts = ls@rs"
+ using split.split_conc split_axioms by blast
+ then show ?case
+ proof (cases rs)
+ case Nil
+ then show ?thesis
+ proof (cases "ins k x t")
+ case (T\<^sub>i a)
+ then have IH:"inorder a = ins_list x (inorder t)"
+ using "2.IH"(1) "2.prems" list_split local.Nil sorted_inorder_induct_last
+ by auto
+
+ have "inorder_up\<^sub>i (ins k x (Node ts t)) = inorder_list ls @ inorder a"
+ using list_split T\<^sub>i Nil by (auto simp add: list_conc)
+ also have "\<dots> = inorder_list ls @ (ins_list x (inorder t))"
+ by (simp add: IH)
+ also have "\<dots> = ins_list x (inorder (Node ts t))"
+ using ins_list_split
+ using "2.prems" list_split Nil by auto
+ finally show ?thesis .
+ next
+ case (Up\<^sub>i l a r)
+ then have IH:"inorder_up\<^sub>i (Up\<^sub>i l a r) = ins_list x (inorder t)"
+ using "2.IH"(1) "2.prems" list_split local.Nil sorted_inorder_induct_last by auto
+
+ have "inorder_up\<^sub>i (ins k x (Node ts t)) = inorder_list ls @ inorder_up\<^sub>i (Up\<^sub>i l a r)"
+ using list_split Up\<^sub>i Nil by (auto simp add: list_conc)
+ also have "\<dots> = inorder_list ls @ ins_list x (inorder t)"
+ using IH by simp
+ also have "\<dots> = ins_list x (inorder (Node ts t))"
+ using ins_list_split
+ using "2.prems" list_split local.Nil by auto
+ finally show ?thesis .
+ qed
+ next
+ case (Cons h list)
+ then obtain sub sep where h_split: "h = (sub,sep)"
+ by (cases h)
+
+ then have sorted_inorder_sub: "sorted_less (inorder sub)"
+ using "2.prems" list_conc local.Cons sorted_inorder_induct_subtree
+ by fastforce
+ then show ?thesis
+ proof(cases "x = sep")
+ case True
+ then have "x \<in> set (inorder (Node ts t))"
+ using list_conc h_split Cons by simp
+ then have "ins_list x (inorder (Node ts t)) = inorder (Node ts t)"
+ using "2.prems" ins_list_contains_idem by blast
+ also have "\<dots> = inorder_up\<^sub>i (ins k x (Node ts t))"
+ using list_split h_split Cons True by auto
+ finally show ?thesis by simp
+ next
+ case False
+ then show ?thesis
+ proof (cases "ins k x sub")
+ case (T\<^sub>i a)
+ then have IH:"inorder a = ins_list x (inorder sub)"
+ using "2.IH"(2) "2.prems" list_split Cons sorted_inorder_sub h_split False
+ by auto
+ have "inorder_up\<^sub>i (ins k x (Node ts t)) = inorder_list ls @ inorder a @ sep # inorder_list list @ inorder t"
+ using h_split False list_split T\<^sub>i Cons by simp
+ also have "\<dots> = inorder_list ls @ ins_list x (inorder sub) @ sep # inorder_list list @ inorder t"
+ using IH by simp
+ also have "\<dots> = ins_list x (inorder (Node ts t))"
+ using ins_list_split ins_list_split_right
+ using list_split "2.prems" Cons h_split False by auto
+ finally show ?thesis .
+ next
+ case (Up\<^sub>i l a r)
+ then have IH:"inorder_up\<^sub>i (Up\<^sub>i l a r) = ins_list x (inorder sub)"
+ using "2.IH"(2) False h_split list_split local.Cons sorted_inorder_sub
+ by auto
+ have "inorder_up\<^sub>i (ins k x (Node ts t)) = inorder_list ls @ inorder l @ a # inorder r @ sep # inorder_list list @ inorder t"
+ using h_split False list_split Up\<^sub>i Cons by simp
+ also have "\<dots> = inorder_list ls @ ins_list x (inorder sub) @ sep # inorder_list list @ inorder t"
+ using IH by simp
+ also have "\<dots> = ins_list x (inorder (Node ts t))"
+ using ins_list_split ins_list_split_right
+ using list_split "2.prems" Cons h_split False by auto
+ finally show ?thesis .
+ qed
+ qed
+ qed
+qed
+
+declare node\<^sub>i.simps [simp add]
+declare node\<^sub>i_inorder [simp del]
+
+
+thm ins.induct
+thm btree.induct
+
+(* wrapped up insert invariants *)
+
+lemma tree\<^sub>i_bal: "bal_up\<^sub>i u \<Longrightarrow> bal (tree\<^sub>i u)"
+ apply(cases u)
+ apply(auto)
+ done
+
+lemma tree\<^sub>i_order: "\<lbrakk>k > 0; root_order_up\<^sub>i k u\<rbrakk> \<Longrightarrow> root_order k (tree\<^sub>i u)"
+ apply(cases u)
+ apply(auto simp add: order_impl_root_order)
+ done
+
+lemma tree\<^sub>i_inorder: "inorder_up\<^sub>i u = inorder (tree\<^sub>i u)"
+ apply (cases u)
+ apply auto
+ done
+
+lemma insert_bal: "bal t \<Longrightarrow> bal (insert k x t)"
+ using ins_bal
+ by (simp add: tree\<^sub>i_bal)
+
+lemma insert_order: "\<lbrakk>k > 0; root_order k t\<rbrakk> \<Longrightarrow> root_order k (insert k x t)"
+ using ins_root_order
+ by (simp add: tree\<^sub>i_order)
+
+
+lemma insert_inorder: "sorted_less (inorder t) \<Longrightarrow> inorder (insert k x t) = ins_list x (inorder t)"
+ using ins_inorder
+ by (simp add: tree\<^sub>i_inorder)
+
+text "Deletion proofs"
+
+thm list.simps
+
+
+
+lemma rebalance_middle_tree_height:
+ assumes "height t = height sub"
+ and "case rs of (rsub,rsep) # list \<Rightarrow> height rsub = height t | [] \<Rightarrow> True"
+ shows "height (rebalance_middle_tree k ls sub sep rs t) = height (Node (ls@(sub,sep)#rs) t)"
+proof (cases "height t")
+ case 0
+ then have "t = Leaf" "sub = Leaf" using height_Leaf assms by auto
+ then show ?thesis by simp
+next
+ case (Suc nat)
+ then obtain tts tt where t_node: "t = Node tts tt"
+ using height_Leaf by (cases t) simp
+ then obtain mts mt where sub_node: "sub = Node mts mt"
+ using assms by (cases sub) simp
+ then show ?thesis
+ proof (cases "length mts \<ge> k \<and> length tts \<ge> k")
+ case False
+ then show ?thesis
+ proof (cases rs)
+ case Nil
+ then have "height_up\<^sub>i (node\<^sub>i k (mts@(mt,sep)#tts) tt) = height (Node (mts@(mt,sep)#tts) tt)"
+ using node\<^sub>i_height by blast
+ also have "\<dots> = max (height t) (height sub)"
+ by (metis assms(1) height_up\<^sub>i.simps(2) height_list_split sub_node t_node)
+ finally have height_max: "height_up\<^sub>i (node\<^sub>i k (mts @ (mt, sep) # tts) tt) = max (height t) (height sub)" by simp
+ then show ?thesis
+ proof (cases "node\<^sub>i k (mts@(mt,sep)#tts) tt")
+ case (T\<^sub>i u)
+ then have "height u = max (height t) (height sub)" using height_max by simp
+ then have "height (Node ls u) = height (Node (ls@[(sub,sep)]) t)"
+ by (induction ls) (auto simp add: max.commute)
+ then show ?thesis using Nil False T\<^sub>i
+ by (simp add: sub_node t_node)
+ next
+ case (Up\<^sub>i l a r)
+ then have "height (Node (ls@[(sub,sep)]) t) = height (Node (ls@[(l,a)]) r)"
+ using assms(1) height_max by (induction ls) auto
+ then show ?thesis
+ using Up\<^sub>i Nil sub_node t_node by auto
+ qed
+ next
+ case (Cons a list)
+ then obtain rsub rsep where a_split: "a = (rsub, rsep)"
+ by (cases a)
+ then obtain rts rt where r_node: "rsub = Node rts rt"
+ using assms(2) Cons height_Leaf Suc by (cases rsub) simp_all
+
+ then have "height_up\<^sub>i (node\<^sub>i k (mts@(mt,sep)#rts) rt) = height (Node (mts@(mt,sep)#rts) rt)"
+ using node\<^sub>i_height by blast
+ also have "\<dots> = max (height rsub) (height sub)"
+ by (metis r_node height_up\<^sub>i.simps(2) height_list_split max.commute sub_node)
+ finally have height_max: "height_up\<^sub>i (node\<^sub>i k (mts @ (mt, sep) # rts) rt) = max (height rsub) (height sub)" by simp
+ then show ?thesis
+ proof (cases "node\<^sub>i k (mts@(mt,sep)#rts) rt")
+ case (T\<^sub>i u)
+ then have "height u = max (height rsub) (height sub)"
+ using height_max by simp
+ then show ?thesis
+ using T\<^sub>i False Cons r_node a_split sub_node t_node by auto
+ next
+ case (Up\<^sub>i l a r)
+ then have height_max: "max (height l) (height r) = max (height rsub) (height sub)"
+ using height_max by auto
+ then show ?thesis
+ using Cons a_split r_node Up\<^sub>i sub_node t_node by auto
+ qed
+ qed
+ qed (simp add: sub_node t_node)
+qed
+
+
+lemma rebalance_last_tree_height:
+ assumes "height t = height sub"
+ and "ts = list@[(sub,sep)]"
+ shows "height (rebalance_last_tree k ts t) = height (Node ts t)"
+ using rebalance_middle_tree_height assms by auto
+
+lemma split_max_height:
+ assumes "split_max k t = (sub,sep)"
+ and "nonempty_lasttreebal t"
+ and "t \<noteq> Leaf"
+ shows "height sub = height t"
+ using assms
+proof(induction t arbitrary: k sub sep)
+ case Node1: (Node tts tt)
+ then obtain ls tsub tsep where tts_split: "tts = ls@[(tsub,tsep)]" by auto
+ then show ?case
+ proof (cases tt)
+ case Leaf
+ then have "height (Node (ls@[(tsub,tsep)]) tt) = max (height (Node ls tsub)) (Suc (height tt))"
+ using height_btree_last height_btree_order by metis
+ moreover have "split_max k (Node tts tt) = (Node ls tsub, tsep)"
+ using Leaf Node1 tts_split by auto
+ ultimately show ?thesis
+ using Leaf Node1 height_Leaf max_def by auto
+ next
+ case Node2: (Node l a)
+ then obtain subsub subsep where sub_split: "split_max k tt = (subsub,subsep)" by (cases "split_max k tt")
+ then have "height subsub = height tt" using Node1 Node2 by auto
+ moreover have "split_max k (Node tts tt) = (rebalance_last_tree k tts subsub, subsep)"
+ using Node1 Node2 tts_split sub_split by auto
+ ultimately show ?thesis using rebalance_last_tree_height Node1 Node2 by auto
+ qed
+qed auto
+
+lemma order_bal_nonempty_lasttreebal: "\<lbrakk>k > 0; root_order k t; bal t\<rbrakk> \<Longrightarrow> nonempty_lasttreebal t"
+proof(induction k t rule: order.induct)
+ case (2 k ts t)
+ then have "length ts > 0" by auto
+ then obtain ls tsub tsep where ts_split: "ts = (ls@[(tsub,tsep)])"
+ by (metis eq_fst_iff length_greater_0_conv snoc_eq_iff_butlast)
+ moreover have "height tsub = height t"
+ using "2.prems"(3) ts_split by auto
+ moreover have "nonempty_lasttreebal t" using 2 order_impl_root_order by auto
+ ultimately show ?case by simp
+qed simp
+
+lemma bal_sub_height: "bal (Node (ls@a#rs) t) \<Longrightarrow> (case rs of [] \<Rightarrow> True | (sub,sep)#_ \<Rightarrow> height sub = height t)"
+ by (cases rs) (auto)
+
+lemma del_height: "\<lbrakk>k > 0; root_order k t; bal t\<rbrakk> \<Longrightarrow> height (del k x t) = height t"
+proof(induction k x t rule: del.induct)
+ case (2 k x ts t)
+ then obtain ls list where list_split: "split ts x = (ls, list)" by (cases "split ts x")
+ then show ?case
+ proof(cases list)
+ case Nil
+ then have "height (del k x t) = height t"
+ using 2 list_split order_bal_nonempty_lasttreebal
+ by (simp add: order_impl_root_order)
+ moreover obtain lls sub sep where "ls = lls@[(sub,sep)]"
+ using split_conc 2 list_split Nil
+ by (metis append_Nil2 nonempty_lasttreebal.simps(2) order_bal_nonempty_lasttreebal)
+ moreover have "Node ls t = Node ts t" using split_conc Nil list_split by auto
+ ultimately show ?thesis
+ using rebalance_last_tree_height 2 list_split Nil split_conc
+ by (auto simp add: max.assoc sup_nat_def max_def)
+ next
+ case (Cons a rs)
+ then have rs_height: "case rs of [] \<Rightarrow> True | (rsub,rsep)#_ \<Rightarrow> height rsub = height t" (* notice the difference if rsub and t are switched *)
+ using "2.prems"(3) bal_sub_height list_split split_conc by blast
+ from Cons obtain sub sep where a_split: "a = (sub,sep)" by (cases a)
+ consider (sep_n_x) "sep \<noteq> x" |
+ (sep_x_Leaf) "sep = x \<and> sub = Leaf" |
+ (sep_x_Node) "sep = x \<and> (\<exists>ts t. sub = Node ts t)"
+ using btree.exhaust by blast
+ then show ?thesis
+ proof cases
+ case sep_n_x
+ have height_t_sub: "height t = height sub"
+ using "2.prems"(3) a_split list_split local.Cons split.split_set(1) split_axioms by fastforce
+ have height_t_del: "height (del k x sub) = height t"
+ by (metis "2.IH"(2) "2.prems"(1) "2.prems"(2) "2.prems"(3) a_split bal.simps(2) list_split local.Cons order_impl_root_order root_order.simps(2) sep_n_x some_child_sub(1) split_set(1))
+ then have "height (rebalance_middle_tree k ls (del k x sub) sep rs t) = height (Node (ls@((del k x sub),sep)#rs) t)"
+ using rs_height rebalance_middle_tree_height by simp
+ also have "\<dots> = height (Node (ls@(sub,sep)#rs) t)"
+ using height_t_sub "2.prems" height_t_del
+ by auto
+ also have "\<dots> = height (Node ts t)"
+ using 2 a_split sep_n_x list_split Cons split_set(1) split_conc
+ by auto
+ finally show ?thesis
+ using sep_n_x Cons a_split list_split 2
+ by simp
+ next
+ case sep_x_Leaf
+ then have "height (Node ts t) = height (Node (ls@rs) t)"
+ using bal_split_last(2) "2.prems"(3) a_split list_split Cons split_conc
+ by metis
+ then show ?thesis
+ using a_split list_split Cons sep_x_Leaf 2 by auto
+ next
+ case sep_x_Node
+ then obtain sts st where sub_node: "sub = Node sts st" by blast
+ obtain sub_s max_s where sub_split: "split_max k sub = (sub_s, max_s)"
+ by (cases "split_max k sub")
+ then have "height sub_s = height t"
+ by (metis "2.prems"(1) "2.prems"(2) "2.prems"(3) a_split bal.simps(2) btree.distinct(1) list_split Cons order_bal_nonempty_lasttreebal order_impl_root_order root_order.simps(2) some_child_sub(1) split_set(1) split_max_height sub_node)
+ then have "height (rebalance_middle_tree k ls sub_s max_s rs t) = height (Node (ls@(sub_s,sep)#rs) t)"
+ using rs_height rebalance_middle_tree_height by simp
+ also have "\<dots> = height (Node ts t)"
+ using 2 a_split sep_x_Node list_split Cons split_set(1) \<open>height sub_s = height t\<close>
+ by (auto simp add: split_conc[of ts])
+ finally show ?thesis using sep_x_Node Cons a_split list_split 2 sub_node sub_split
+ by auto
+ qed
+ qed
+qed simp
+
+(* proof for inorders *)
+
+(* note: this works (as it should, since there is not even recursion involved)
+ automatically. *yay* *)
+lemma rebalance_middle_tree_inorder:
+ assumes "height t = height sub"
+ and "case rs of (rsub,rsep) # list \<Rightarrow> height rsub = height t | [] \<Rightarrow> True"
+ shows "inorder (rebalance_middle_tree k ls sub sep rs t) = inorder (Node (ls@(sub,sep)#rs) t)"
+ apply(cases sub; cases t)
+ using assms
+ apply (auto
+ split!: btree.splits up\<^sub>i.splits list.splits
+ simp del: node\<^sub>i.simps
+ simp add: node\<^sub>i_inorder_simps
+ )
+ done
+
+lemma rebalance_last_tree_inorder:
+ assumes "height t = height sub"
+ and "ts = list@[(sub,sep)]"
+ shows "inorder (rebalance_last_tree k ts t) = inorder (Node ts t)"
+ using rebalance_middle_tree_inorder assms by auto
+
+lemma butlast_inorder_app_id: "xs = xs' @ [(sub,sep)] \<Longrightarrow> inorder_list xs' @ inorder sub @ [sep] = inorder_list xs"
+ by simp
+
+lemma split_max_inorder:
+ assumes "nonempty_lasttreebal t"
+ and "t \<noteq> Leaf"
+ shows "inorder_pair (split_max k t) = inorder t"
+ using assms
+proof (induction k t rule: split_max.induct)
+ case (1 k ts t)
+ then show ?case
+ proof (cases t)
+ case Leaf
+ then have "ts = butlast ts @ [last ts]"
+ using "1.prems"(1) by auto
+ moreover obtain sub sep where "last ts = (sub,sep)"
+ by fastforce
+ ultimately show ?thesis
+ using Leaf
+ apply (auto split!: prod.splits btree.splits)
+ by (simp add: butlast_inorder_app_id)
+ next
+ case (Node tts tt)
+ then have IH: "inorder_pair (split_max k t) = inorder t"
+ using "1.IH" "1.prems"(1) by auto
+ obtain sub sep where split_sub_sep: "split_max k t = (sub,sep)"
+ by fastforce
+ then have height_sub: "height sub = height t"
+ by (metis "1.prems"(1) Node btree.distinct(1) nonempty_lasttreebal.simps(2) split_max_height)
+ have "inorder_pair (split_max k (Node ts t)) = inorder (rebalance_last_tree k ts sub) @ [sep]"
+ using Node 1 split_sub_sep by auto
+ also have "\<dots> = inorder_list ts @ inorder sub @ [sep]"
+ using rebalance_last_tree_inorder height_sub "1.prems"
+ by (auto simp del: rebalance_last_tree.simps)
+ also have "\<dots> = inorder (Node ts t)"
+ using IH split_sub_sep by simp
+ finally show ?thesis .
+ qed
+qed simp
+
+
+lemma height_bal_subtrees_merge: "\<lbrakk>height (Node as a) = height (Node bs b); bal (Node as a); bal (Node bs b)\<rbrakk>
+ \<Longrightarrow> \<forall>x \<in> set (subtrees as) \<union> {a}. height x = height b"
+ by (metis Suc_inject Un_iff bal.simps(2) height_bal_tree singletonD)
+
+lemma bal_list_merge:
+ assumes "bal_up\<^sub>i (Up\<^sub>i (Node as a) x (Node bs b))"
+ shows "bal (Node (as@(a,x)#bs) b)"
+proof -
+ have "\<forall>x\<in>set (subtrees (as @ (a, x) # bs)). bal x"
+ using subtrees_split assms by auto
+ moreover have "bal b"
+ using assms by auto
+ moreover have "\<forall>x\<in>set (subtrees as) \<union> {a} \<union> set (subtrees bs). height x = height b"
+ using assms height_bal_subtrees_merge
+ unfolding bal_up\<^sub>i.simps
+ by blast
+ ultimately show ?thesis
+ by auto
+qed
+
+lemma node\<^sub>i_bal_up\<^sub>i:
+ assumes "bal_up\<^sub>i (node\<^sub>i k ts t)"
+ shows "bal (Node ts t)"
+ using assms
+proof(cases "length ts \<le> 2*k")
+ case False
+ then obtain ls sub sep rs where split_list: "split_half ts = (ls, (sub,sep)#rs)"
+ using node\<^sub>i_cases by blast
+ then have "node\<^sub>i k ts t = Up\<^sub>i (Node ls sub) sep (Node rs t)"
+ using False by auto
+ moreover have "ts = ls@(sub,sep)#rs"
+ by (metis append_take_drop_id fst_conv local.split_list snd_conv split_half.elims)
+ ultimately show ?thesis
+ using bal_list_merge[of ls sub sep rs t] assms
+ by (simp del: bal.simps bal_up\<^sub>i.simps)
+qed simp
+
+lemma node\<^sub>i_bal_simp: "bal_up\<^sub>i (node\<^sub>i k ts t) = bal (Node ts t)"
+ using node\<^sub>i_bal node\<^sub>i_bal_up\<^sub>i by blast
+
+lemma rebalance_middle_tree_bal: "bal (Node (ls@(sub,sep)#rs) t) \<Longrightarrow> bal (rebalance_middle_tree k ls sub sep rs t)"
+proof (cases t)
+ case t_node: (Node tts tt)
+ assume assms: "bal (Node (ls @ (sub, sep) # rs) t)"
+ then obtain mts mt where sub_node: "sub = Node mts mt"
+ by (cases sub) (auto simp add: t_node)
+ have sub_heights: "height sub = height t" "bal sub" "bal t"
+ using assms by auto
+ show ?thesis
+ proof (cases "length mts \<ge> k \<and> length tts \<ge> k")
+ case True
+ then show ?thesis
+ using t_node sub_node assms
+ by (auto simp del: bal.simps)
+ next
+ case False
+ then show ?thesis
+ proof (cases rs)
+ case Nil
+ have "height_up\<^sub>i (node\<^sub>i k (mts@(mt,sep)#tts) tt) = height (Node (mts@(mt,sep)#tts) tt)"
+ using node\<^sub>i_height by blast
+ also have "\<dots> = Suc (height tt)"
+ by (metis height_bal_tree height_up\<^sub>i.simps(2) height_list_split max.idem sub_heights(1) sub_heights(3) sub_node t_node)
+ also have "\<dots> = height t"
+ using height_bal_tree sub_heights(3) t_node by fastforce
+ finally have "height_up\<^sub>i (node\<^sub>i k (mts@(mt,sep)#tts) tt) = height t" by simp
+ moreover have "bal_up\<^sub>i (node\<^sub>i k (mts@(mt,sep)#tts) tt)"
+ by (metis bal_list_merge bal_up\<^sub>i.simps(2) node\<^sub>i_bal sub_heights(1) sub_heights(2) sub_heights(3) sub_node t_node)
+ ultimately show ?thesis
+ apply (cases "node\<^sub>i k (mts@(mt,sep)#tts) tt")
+ using assms Nil sub_node t_node by auto
+ next
+ case (Cons r rs)
+ then obtain rsub rsep where r_split: "r = (rsub,rsep)" by (cases r)
+ then have rsub_height: "height rsub = height t" "bal rsub"
+ using assms Cons by auto
+ then obtain rts rt where r_node: "rsub = (Node rts rt)"
+ apply(cases rsub) using t_node by simp
+ have "height_up\<^sub>i (node\<^sub>i k (mts@(mt,sep)#rts) rt) = height (Node (mts@(mt,sep)#rts) rt)"
+ using node\<^sub>i_height by blast
+ also have "\<dots> = Suc (height rt)"
+ by (metis Un_iff \<open>height rsub = height t\<close> assms bal.simps(2) bal_split_last(1) height_bal_tree height_up\<^sub>i.simps(2) height_list_split list.set_intros(1) Cons max.idem r_node r_split set_append some_child_sub(1) sub_heights(1) sub_node)
+ also have "\<dots> = height rsub"
+ using height_bal_tree r_node rsub_height(2) by fastforce
+ finally have 1: "height_up\<^sub>i (node\<^sub>i k (mts@(mt,sep)#rts) rt) = height rsub" .
+ moreover have 2: "bal_up\<^sub>i (node\<^sub>i k (mts@(mt,sep)#rts) rt)"
+ by (metis bal_list_merge bal_up\<^sub>i.simps(2) node\<^sub>i_bal r_node rsub_height(1) rsub_height(2) sub_heights(1) sub_heights(2) sub_node)
+ ultimately show ?thesis
+ proof (cases "node\<^sub>i k (mts@(mt,sep)#rts) rt")
+ case (T\<^sub>i u)
+ then have "bal (Node (ls@(u,rsep)#rs) t)"
+ using 1 2 Cons assms t_node subtrees_split sub_heights r_split rsub_height
+ unfolding bal.simps by (auto simp del: height_btree.simps)
+ then show ?thesis
+ using Cons assms t_node sub_node r_split r_node False T\<^sub>i
+ by (auto simp del: node\<^sub>i.simps bal.simps)
+ next
+ case (Up\<^sub>i l a r)
+ then have "bal (Node (ls@(l,a)#(r,rsep)#rs) t)"
+ using 1 2 Cons assms t_node subtrees_split sub_heights r_split rsub_height
+ unfolding bal.simps by (auto simp del: height_btree.simps)
+ then show ?thesis
+ using Cons assms t_node sub_node r_split r_node False Up\<^sub>i
+ by (auto simp del: node\<^sub>i.simps bal.simps)
+ qed
+ qed
+ qed
+qed (simp add: height_Leaf)
+
+
+lemma rebalance_last_tree_bal: "\<lbrakk>bal (Node ts t); ts \<noteq> []\<rbrakk> \<Longrightarrow> bal (rebalance_last_tree k ts t)"
+ using rebalance_middle_tree_bal append_butlast_last_id[of ts]
+ apply(cases "last ts")
+ apply(auto simp del: bal.simps rebalance_middle_tree.simps)
+ done
+
+
+lemma split_max_bal:
+ assumes "bal t"
+ and "t \<noteq> Leaf"
+ and "nonempty_lasttreebal t"
+ shows "bal (fst (split_max k t))"
+ using assms
+proof(induction k t rule: split_max.induct)
+ case (1 k ts t)
+ then show ?case
+ proof (cases t)
+ case Leaf
+ then obtain sub sep where last_split: "last ts = (sub,sep)"
+ using 1 by auto
+ then have "height sub = height t" using 1 by auto
+ then have "bal (Node (butlast ts) sub)" using 1 last_split by auto
+ then show ?thesis using 1 Leaf last_split by auto
+ next
+ case (Node tts tt)
+ then obtain sub sep where t_split: "split_max k t = (sub,sep)" by (cases "split_max k t")
+ then have "height sub = height t" using 1 Node
+ by (metis btree.distinct(1) nonempty_lasttreebal.simps(2) split_max_height)
+ moreover have "bal sub"
+ using "1.IH" "1.prems"(1) "1.prems"(3) Node t_split by fastforce
+ ultimately have "bal (Node ts sub)"
+ using 1 t_split Node by auto
+ then show ?thesis
+ using rebalance_last_tree_bal t_split Node 1
+ by (auto simp del: bal.simps rebalance_middle_tree.simps)
+ qed
+qed simp
+
+lemma del_bal:
+ assumes "k > 0"
+ and "root_order k t"
+ and "bal t"
+ shows "bal (del k x t)"
+ using assms
+proof(induction k x t rule: del.induct)
+ case (2 k x ts t)
+ then obtain ls rs where list_split: "split ts x = (ls,rs)"
+ by (cases "split ts x")
+ then show ?case
+ proof (cases rs)
+ case Nil
+ then have "bal (del k x t)" using 2 list_split
+ by (simp add: order_impl_root_order)
+ moreover have "height (del k x t) = height t"
+ using 2 del_height by (simp add: order_impl_root_order)
+ moreover have "ts \<noteq> []" using 2 by auto
+ ultimately have "bal (rebalance_last_tree k ts (del k x t))"
+ using 2 Nil order_bal_nonempty_lasttreebal rebalance_last_tree_bal
+ by simp
+ then have "bal (rebalance_last_tree k ls (del k x t))"
+ using list_split split_conc Nil by fastforce
+ then show ?thesis
+ using 2 list_split Nil
+ by auto
+ next
+ case (Cons r rs)
+ then obtain sub sep where r_split: "r = (sub,sep)" by (cases r)
+ then have sub_height: "height sub = height t" "bal sub"
+ using 2 Cons list_split split_set(1) by fastforce+
+ consider (sep_n_x) "sep \<noteq> x" |
+ (sep_x_Leaf) "sep = x \<and> sub = Leaf" |
+ (sep_x_Node) "sep = x \<and> (\<exists>ts t. sub = Node ts t)"
+ using btree.exhaust by blast
+ then show ?thesis
+ proof cases
+ case sep_n_x
+ then have "bal (del k x sub)" "height (del k x sub) = height sub" using sub_height
+ apply (metis "2.IH"(2) "2.prems"(1) "2.prems"(2) list_split local.Cons order_impl_root_order r_split root_order.simps(2) some_child_sub(1) split_set(1))
+ by (metis "2.prems"(1) "2.prems"(2) list_split Cons order_impl_root_order r_split root_order.simps(2) some_child_sub(1) del_height split_set(1) sub_height(2))
+ moreover have "bal (Node (ls@(sub,sep)#rs) t)"
+ using "2.prems"(3) list_split Cons r_split split_conc by blast
+ ultimately have "bal (Node (ls@(del k x sub,sep)#rs) t)"
+ using bal_substitute_subtree[of ls sub sep rs t "del k x sub"] by metis
+ then have "bal (rebalance_middle_tree k ls (del k x sub) sep rs t)"
+ using rebalance_middle_tree_bal[of ls "del k x sub" sep rs t k] by metis
+ then show ?thesis
+ using 2 list_split Cons r_split sep_n_x by auto
+ next
+ case sep_x_Leaf
+ moreover have "bal (Node (ls@rs) t)"
+ using bal_split_last(1) list_split split_conc r_split
+ by (metis "2.prems"(3) Cons)
+ ultimately show ?thesis
+ using 2 list_split Cons r_split by auto
+ next
+ case sep_x_Node
+ then obtain sts st where sub_node: "sub = Node sts st" by auto
+ then obtain sub_s max_s where sub_split: "split_max k sub = (sub_s, max_s)"
+ by (cases "split_max k sub")
+ then have "height sub_s = height sub"
+ using split_max_height
+ by (metis "2.prems"(1) "2.prems"(2) btree.distinct(1) list_split Cons order_bal_nonempty_lasttreebal order_impl_root_order r_split root_order.simps(2) some_child_sub(1) split_set(1) sub_height(2) sub_node)
+ moreover have "bal sub_s"
+ using split_max_bal
+ by (metis "2.prems"(1) "2.prems"(2) btree.distinct(1) fst_conv list_split local.Cons order_bal_nonempty_lasttreebal order_impl_root_order r_split root_order.simps(2) some_child_sub(1) split_set(1) sub_height(2) sub_node sub_split)
+ moreover have "bal (Node (ls@(sub,sep)#rs) t)"
+ using "2.prems"(3) list_split Cons r_split split_conc by blast
+ ultimately have "bal (Node (ls@(sub_s,sep)#rs) t)"
+ using bal_substitute_subtree[of ls sub sep rs t "sub_s"] by metis
+ then have "bal (Node (ls@(sub_s,max_s)#rs) t)"
+ using bal_substitute_separator by metis
+ then have "bal (rebalance_middle_tree k ls sub_s max_s rs t)"
+ using rebalance_middle_tree_bal[of ls sub_s max_s rs t k] by metis
+ then show ?thesis
+ using 2 list_split Cons r_split sep_x_Node sub_node sub_split by auto
+ qed
+ qed
+qed simp
+
+
+lemma rebalance_middle_tree_order:
+ assumes "almost_order k sub"
+ and "\<forall>s \<in> set (subtrees (ls@rs)). order k s" "order k t"
+ and "case rs of (rsub,rsep) # list \<Rightarrow> height rsub = height t | [] \<Rightarrow> True"
+ and "length (ls@(sub,sep)#rs) \<le> 2*k"
+ and "height sub = height t"
+ shows "almost_order k (rebalance_middle_tree k ls sub sep rs t)"
+proof(cases t)
+ case Leaf
+ then have "sub = Leaf" using height_Leaf assms by auto
+ then show ?thesis using Leaf assms by auto
+next
+ case t_node: (Node tts tt)
+ then obtain mts mt where sub_node: "sub = Node mts mt"
+ using assms by (cases sub) (auto)
+ then show ?thesis
+ proof(cases "length mts \<ge> k \<and> length tts \<ge> k")
+ case True
+ then have "order k sub" using assms
+ by (simp add: sub_node)
+ then show ?thesis
+ using True t_node sub_node assms by auto
+ next
+ case False
+ then show ?thesis
+ proof (cases rs)
+ case Nil
+ have "order_up\<^sub>i k (node\<^sub>i k (mts@(mt,sep)#tts) tt)"
+ using node\<^sub>i_order[of k "mts@(mt,sep)#tts" tt] assms(1,3) t_node sub_node
+ by (auto simp del: order_up\<^sub>i.simps node\<^sub>i.simps)
+ then show ?thesis
+ apply(cases "node\<^sub>i k (mts@(mt,sep)#tts) tt")
+ using assms t_node sub_node False Nil apply (auto simp del: node\<^sub>i.simps)
+ done
+ next
+ case (Cons r rs)
+ then obtain rsub rsep where r_split: "r = (rsub,rsep)" by (cases r)
+ then have rsub_height: "height rsub = height t"
+ using assms Cons by auto
+ then obtain rts rt where r_node: "rsub = (Node rts rt)"
+ apply(cases rsub) using t_node by simp
+ have "order_up\<^sub>i k (node\<^sub>i k (mts@(mt,sep)#rts) rt)"
+ using node\<^sub>i_order[of k "mts@(mt,sep)#rts" rt] assms(1,2) t_node sub_node r_node r_split Cons
+ by (auto simp del: order_up\<^sub>i.simps node\<^sub>i.simps)
+ then show ?thesis
+ apply(cases "node\<^sub>i k (mts@(mt,sep)#rts) rt")
+ using assms t_node sub_node False Cons r_split r_node apply (auto simp del: node\<^sub>i.simps)
+ done
+ qed
+ qed
+qed
+
+(* we have to proof the order invariant once for an underflowing last tree *)
+lemma rebalance_middle_tree_last_order:
+ assumes "almost_order k t"
+ and "\<forall>s \<in> set (subtrees (ls@(sub,sep)#rs)). order k s"
+ and "rs = []"
+ and "length (ls@(sub,sep)#rs) \<le> 2*k"
+ and "height sub = height t"
+ shows "almost_order k (rebalance_middle_tree k ls sub sep rs t)"
+proof (cases t)
+ case Leaf
+ then have "sub = Leaf" using height_Leaf assms by auto
+ then show ?thesis using Leaf assms by auto
+next
+ case t_node: (Node tts tt)
+ then obtain mts mt where sub_node: "sub = Node mts mt"
+ using assms by (cases sub) (auto)
+ then show ?thesis
+ proof(cases "length mts \<ge> k \<and> length tts \<ge> k")
+ case True
+ then have "order k sub" using assms
+ by (simp add: sub_node)
+ then show ?thesis
+ using True t_node sub_node assms by auto
+ next
+ case False
+ have "order_up\<^sub>i k (node\<^sub>i k (mts@(mt,sep)#tts) tt)"
+ using node\<^sub>i_order[of k "mts@(mt,sep)#tts" tt] assms t_node sub_node
+ by (auto simp del: order_up\<^sub>i.simps node\<^sub>i.simps)
+ then show ?thesis
+ apply(cases "node\<^sub>i k (mts@(mt,sep)#tts) tt")
+ using assms t_node sub_node False Nil apply (auto simp del: node\<^sub>i.simps)
+ done
+ qed
+qed
+
+lemma rebalance_last_tree_order:
+ assumes "ts = ls@[(sub,sep)]"
+ and "\<forall>s \<in> set (subtrees (ts)). order k s" "almost_order k t"
+ and "length ts \<le> 2*k"
+ and "height sub = height t"
+ shows "almost_order k (rebalance_last_tree k ts t)"
+ using rebalance_middle_tree_last_order assms by auto
+
+lemma split_max_order:
+ assumes "order k t"
+ and "t \<noteq> Leaf"
+ and "nonempty_lasttreebal t"
+ shows "almost_order k (fst (split_max k t))"
+ using assms
+proof(induction k t rule: split_max.induct)
+ case (1 k ts t)
+ then obtain ls sub sep where ts_not_empty: "ts = ls@[(sub,sep)]"
+ by auto
+ then show ?case
+ proof (cases t)
+ case Leaf
+ then show ?thesis using ts_not_empty 1 by auto
+ next
+ case (Node)
+ then obtain s_sub s_max where sub_split: "split_max k t = (s_sub, s_max)"
+ by (cases "split_max k t")
+ moreover have "height sub = height s_sub"
+ by (metis "1.prems"(3) Node Pair_inject append1_eq_conv btree.distinct(1) nonempty_lasttreebal.simps(2) split_max_height sub_split ts_not_empty)
+ ultimately have "almost_order k (rebalance_last_tree k ts s_sub)"
+ using rebalance_last_tree_order[of ts ls sub sep k s_sub]
+ 1 ts_not_empty Node sub_split
+ by force
+ then show ?thesis
+ using Node 1 sub_split by auto
+ qed
+qed simp
+
+
+lemma del_order:
+ assumes "k > 0"
+ and "root_order k t"
+ and "bal t"
+ shows "almost_order k (del k x t)"
+ using assms
+proof (induction k x t rule: del.induct)
+ case (2 k x ts t)
+ then obtain ls list where list_split: "split ts x = (ls, list)" by (cases "split ts x")
+ then show ?case
+ proof (cases list)
+ case Nil
+ then have "almost_order k (del k x t)" using 2 list_split
+ by (simp add: order_impl_root_order)
+ moreover obtain lls lsub lsep where ls_split: "ls = lls@[(lsub,lsep)]"
+ using 2 Nil list_split
+ by (metis append_Nil2 nonempty_lasttreebal.simps(2) order_bal_nonempty_lasttreebal split_conc)
+ moreover have "height t = height (del k x t)" using del_height 2
+ by (simp add: order_impl_root_order)
+ moreover have "length ls = length ts"
+ using Nil list_split
+ by (auto dest: split_length)
+ ultimately have "almost_order k (rebalance_last_tree k ls (del k x t))"
+ using rebalance_last_tree_order[of ls lls lsub lsep k "del k x t"]
+ by (metis "2.prems"(2) "2.prems"(3) Un_iff append_Nil2 bal.simps(2) list_split Nil root_order.simps(2) singletonI split_conc subtrees_split)
+ then show ?thesis
+ using 2 list_split Nil by auto
+ next
+ case (Cons r rs)
+
+ from Cons obtain sub sep where r_split: "r = (sub,sep)" by (cases r)
+
+ have inductive_help:
+ "case rs of [] \<Rightarrow> True | (rsub,rsep)#_ \<Rightarrow> height rsub = height t"
+ "\<forall>s\<in>set (subtrees (ls @ rs)). order k s"
+ "Suc (length (ls @ rs)) \<le> 2 * k"
+ "order k t"
+ using Cons r_split "2.prems" list_split split_set
+ by (auto dest: split_conc split!: list.splits)
+
+ consider (sep_n_x) "sep \<noteq> x" |
+ (sep_x_Leaf) "sep = x \<and> sub = Leaf" |
+ (sep_x_Node) "sep = x \<and> (\<exists>ts t. sub = Node ts t)"
+ using btree.exhaust by blast
+ then show ?thesis
+ proof cases
+ case sep_n_x
+ then have "almost_order k (del k x sub)" using 2 list_split Cons r_split order_impl_root_order
+ by (metis bal.simps(2) root_order.simps(2) some_child_sub(1) split_set(1))
+ moreover have "height (del k x sub) = height t"
+ by (metis "2.prems"(1) "2.prems"(2) "2.prems"(3) bal.simps(2) list_split Cons order_impl_root_order r_split root_order.simps(2) some_child_sub(1) del_height split_set(1))
+ ultimately have "almost_order k (rebalance_middle_tree k ls (del k x sub) sep rs t)"
+ using rebalance_middle_tree_order[of k "del k x sub" ls rs t sep]
+ using inductive_help
+ using Cons r_split sep_n_x list_split by auto
+ then show ?thesis using 2 Cons r_split sep_n_x list_split by auto
+ next
+ case sep_x_Leaf
+ then have "almost_order k (Node (ls@rs) t)" using inductive_help by auto
+ then show ?thesis using 2 Cons r_split sep_x_Leaf list_split by auto
+ next
+ case sep_x_Node
+ then obtain sts st where sub_node: "sub = Node sts st" by auto
+ then obtain sub_s max_s where sub_split: "split_max k sub = (sub_s, max_s)"
+ by (cases "split_max k sub")
+ then have "height sub_s = height t" using split_max_height
+ by (metis "2.prems"(1) "2.prems"(2) "2.prems"(3) bal.simps(2) btree.distinct(1) list_split Cons order_bal_nonempty_lasttreebal order_impl_root_order r_split root_order.simps(2) some_child_sub(1) split_set(1) sub_node)
+ moreover have "almost_order k sub_s" using split_max_order
+ by (metis "2.prems"(1) "2.prems"(2) "2.prems"(3) bal.simps(2) btree.distinct(1) fst_conv list_split local.Cons order_bal_nonempty_lasttreebal order_impl_root_order r_split root_order.simps(2) some_child_sub(1) split_set(1) sub_node sub_split)
+ ultimately have "almost_order k (rebalance_middle_tree k ls sub_s max_s rs t)"
+ using rebalance_middle_tree_order[of k sub_s ls rs t max_s] inductive_help
+ by auto
+ then show ?thesis
+ using 2 Cons r_split list_split sep_x_Node sub_split by auto
+ qed
+ qed
+qed simp
+
+(* sortedness of delete by inorder *)
+(* generalize del_list_sorted since its cumbersome to express inorder_list ts as xs @ [a]
+note that the proof scheme is almost identical to ins_list_sorted
+ *)
+thm del_list_sorted
+
+lemma del_list_split:
+ assumes "split ts x = (ls, rs)"
+ and "sorted_less (inorder (Node ts t))"
+ shows "del_list x (inorder (Node ts t)) = inorder_list ls @ del_list x (inorder_list rs @ inorder t)"
+proof (cases ls)
+ case Nil
+ then show ?thesis
+ using assms by (auto dest!: split_conc)
+next
+ case Cons
+ then obtain ls' sub sep where ls_tail_split: "ls = ls' @ [(sub,sep)]"
+ by (metis list.distinct(1) rev_exhaust surj_pair)
+ moreover have "sep < x"
+ using split_req(2)[of ts x ls' sub sep rs]
+ using assms(1) assms(2) ls_tail_split sorted_inorder_separators
+ by blast
+ moreover have "sorted_less (inorder_list ls)"
+ using assms sorted_wrt_append split_conc by fastforce
+ ultimately show ?thesis using assms(2) split_conc[OF assms(1)]
+ using del_list_sorted[of "inorder_list ls' @ inorder sub" sep]
+ by auto
+qed
+
+(* del sorted requires sortedness of the full list so we need to change the right specialization a bit *)
+
+lemma del_list_split_right:
+ assumes "split ts x = (ls, (sub,sep)#rs)"
+ and "sorted_less (inorder (Node ts t))"
+ and "sep \<noteq> x"
+ shows "del_list x (inorder_list ((sub,sep)#rs) @ inorder t) = del_list x (inorder sub) @ sep # inorder_list rs @ inorder t"
+proof -
+ from assms have "x < sep"
+ proof -
+ from assms have "sorted_less (separators ts)"
+ using sorted_inorder_separators by blast
+ then show ?thesis
+ using split_req(3)
+ using assms
+ by fastforce
+ qed
+ moreover have "sorted_less (inorder sub @ sep # inorder_list rs @ inorder t)"
+ using assms sorted_wrt_append[where xs="inorder_list ls"]
+ by (auto dest!: split_conc)
+ ultimately show ?thesis
+ using del_list_sorted[of "inorder sub" "sep"]
+ by auto
+qed
+
+thm del_list_idem
+
+lemma del_inorder:
+ assumes "k > 0"
+ and "root_order k t"
+ and "bal t"
+ and "sorted_less (inorder t)"
+ shows "inorder (del k x t) = del_list x (inorder t)"
+ using assms
+proof (induction k x t rule: del.induct)
+ case (2 k x ts t)
+ then obtain ls rs where list_split: "split ts x = (ls, rs)"
+ by (meson surj_pair)
+ then have list_conc: "ts = ls @ rs"
+ using split.split_conc split_axioms by blast
+ show ?case
+ proof (cases rs)
+ case Nil
+ then have IH: "inorder (del k x t) = del_list x (inorder t)"
+ by (metis "2.IH"(1) "2.prems" bal.simps(2) list_split order_impl_root_order root_order.simps(2) sorted_inorder_induct_last)
+ have "inorder (del k x (Node ts t)) = inorder (rebalance_last_tree k ts (del k x t))"
+ using list_split Nil list_conc by auto
+ also have "\<dots> = inorder_list ts @ inorder (del k x t)"
+ proof -
+ obtain ts' sub sep where ts_split: "ts = ts' @ [(sub, sep)]"
+ by (meson "2.prems"(1) "2.prems"(2) "2.prems"(3) nonempty_lasttreebal.simps(2) order_bal_nonempty_lasttreebal)
+ then have "height sub = height t"
+ using "2.prems"(3) by auto
+ moreover have "height t = height (del k x t)"
+ by (metis "2.prems"(1) "2.prems"(2) "2.prems"(3) bal.simps(2) del_height order_impl_root_order root_order.simps(2))
+ ultimately show ?thesis
+ using rebalance_last_tree_inorder
+ using ts_split by auto
+ qed
+ also have "\<dots> = inorder_list ts @ del_list x (inorder t)"
+ using IH by blast
+ also have "\<dots> = del_list x (inorder (Node ts t))"
+ using "2.prems"(4) list_conc list_split Nil del_list_split
+ by auto
+ finally show ?thesis .
+ next
+ case (Cons h rs)
+ then obtain sub sep where h_split: "h = (sub,sep)"
+ by (cases h)
+ then have node_sorted_split:
+ "sorted_less (inorder (Node (ls@(sub,sep)#rs) t))"
+ "root_order k (Node (ls@(sub,sep)#rs) t)"
+ "bal (Node (ls@(sub,sep)#rs) t)"
+ using "2.prems" h_split list_conc Cons by blast+
+ consider (sep_n_x) "sep \<noteq> x" | (sep_x_Leaf) "sep = x \<and> sub = Leaf" | (sep_x_Node) "sep = x \<and> (\<exists>ts t. sub = Node ts t)"
+ using btree.exhaust by blast
+ then show ?thesis
+ proof cases
+ case sep_n_x
+ then have IH: "inorder (del k x sub) = del_list x (inorder sub)"
+ by (metis "2.IH"(2) "2.prems"(1) "2.prems"(2) bal.simps(2) bal_split_left(1) h_split list_split local.Cons node_sorted_split(1) node_sorted_split(3) order_impl_root_order root_order.simps(2) some_child_sub(1) sorted_inorder_induct_subtree split_set(1))
+ from sep_n_x have "inorder (del k x (Node ts t)) = inorder (rebalance_middle_tree k ls (del k x sub) sep rs t)"
+ using list_split Cons h_split by auto
+ also have "\<dots> = inorder (Node (ls@(del k x sub, sep)#rs) t)"
+ proof -
+ have "height t = height (del k x sub)"
+ using del_height
+ using order_impl_root_order "2.prems"
+ by (auto simp add: order_impl_root_order Cons list_conc h_split)
+ moreover have "case rs of [] \<Rightarrow> True | (rsub, rsep) # list \<Rightarrow> height rsub = height t"
+ using "2.prems"(3) bal_sub_height list_conc Cons by blast
+ ultimately show ?thesis
+ using rebalance_middle_tree_inorder
+ by simp
+ qed
+ also have "\<dots> = inorder_list ls @ del_list x (inorder sub) @ sep # inorder_list rs @ inorder t"
+ using IH by simp
+ also have "\<dots> = del_list x (inorder (Node ts t))"
+ using del_list_split[of ts x ls "(sub,sep)#rs" t]
+ using del_list_split_right[of ts x ls sub sep rs t]
+ using list_split list_conc h_split Cons "2.prems"(4) sep_n_x
+ by auto
+ finally show ?thesis .
+ next
+ case sep_x_Leaf
+ then have "del_list x (inorder (Node ts t)) = inorder (Node (ls@rs) t)"
+ using list_conc h_split Cons
+ using del_list_split[OF list_split "2.prems"(4)]
+ by simp
+ also have "\<dots> = inorder (del k x (Node ts t))"
+ using list_split sep_x_Leaf list_conc h_split Cons
+ by auto
+ finally show ?thesis by simp
+ next
+ case sep_x_Node
+ obtain ssub ssep where split_split: "split_max k sub = (ssub, ssep)"
+ by fastforce
+ from sep_x_Node have "x = sep"
+ by simp
+ then have "del_list x (inorder (Node ts t)) = inorder_list ls @ inorder sub @ inorder_list rs @ inorder t"
+ using list_split list_conc h_split Cons "2.prems"(4)
+ using del_list_split[OF list_split "2.prems"(4)]
+ using del_list_sorted1[of "inorder sub" sep "inorder_list rs @ inorder t" x]
+ sorted_wrt_append
+ by auto
+ also have "\<dots> = inorder_list ls @ inorder_pair (split_max k sub) @ inorder_list rs @ inorder t"
+ using sym[OF split_max_inorder[of sub k]]
+ using order_bal_nonempty_lasttreebal[of k sub] "2.prems"
+ list_conc h_split Cons sep_x_Node
+ by (auto simp del: split_max.simps simp add: order_impl_root_order)
+ also have "\<dots> = inorder_list ls @ inorder ssub @ ssep # inorder_list rs @ inorder t"
+ using split_split by auto
+ also have "\<dots> = inorder (rebalance_middle_tree k ls ssub ssep rs t)"
+ proof -
+ have "height t = height ssub"
+ using split_max_height
+ by (metis "2.prems"(1,2,3) bal.simps(2) btree.distinct(1) h_split list_split local.Cons order_bal_nonempty_lasttreebal order_impl_root_order root_order.simps(2) sep_x_Node some_child_sub(1) split_set(1) split_split)
+ moreover have "case rs of [] \<Rightarrow> True | (rsub, rsep) # list \<Rightarrow> height rsub = height t"
+ using "2.prems"(3) bal_sub_height list_conc local.Cons
+ by blast
+ ultimately show ?thesis
+ using rebalance_middle_tree_inorder
+ by auto
+ qed
+ also have "\<dots> = inorder (del k x (Node ts t))"
+ using list_split sep_x_Node list_conc h_split Cons split_split
+ by auto
+ finally show ?thesis by simp
+ qed
+ qed
+qed auto
+
+lemma reduce_root_order: "\<lbrakk>k > 0; almost_order k t\<rbrakk> \<Longrightarrow> root_order k (reduce_root t)"
+ apply(cases t)
+ apply(auto split!: list.splits simp add: order_impl_root_order)
+ done
+
+lemma reduce_root_bal: "bal (reduce_root t) = bal t"
+ apply(cases t)
+ apply(auto split!: list.splits)
+ done
+
+
+lemma reduce_root_inorder: "inorder (reduce_root t) = inorder t"
+ apply (cases t)
+ apply (auto split!: list.splits)
+ done
+
+
+lemma delete_order: "\<lbrakk>k > 0; bal t; root_order k t\<rbrakk> \<Longrightarrow> root_order k (delete k x t)"
+ using del_order
+ by (simp add: reduce_root_order)
+
+lemma delete_bal: "\<lbrakk>k > 0; bal t; root_order k t\<rbrakk> \<Longrightarrow> bal (delete k x t)"
+ using del_bal
+ by (simp add: reduce_root_bal)
+
+lemma delete_inorder: "\<lbrakk>k > 0; bal t; root_order k t; sorted_less (inorder t)\<rbrakk> \<Longrightarrow> inorder (delete k x t) = del_list x (inorder t)"
+ using del_inorder
+ by (simp add: reduce_root_inorder)
+
+(* TODO (opt) runtime wrt runtime of split *)
+
+(* we are interested in a) number of comparisons b) number of fetches c) number of writes *)
+(* a) is dependent on t_split, the remainder is not (we assume the number of fetches and writes
+for split fun is 0 *)
+
+
+(* TODO simpler induction schemes /less boilerplate isabelle/src/HOL/ex/Induction_Schema *)
+
+subsection "Set specification by inorder"
+
+
+interpretation S_ordered: Set_by_Ordered where
+ empty = empty_btree and
+ insert = "insert (Suc k)" and
+ delete = "delete (Suc k)" and
+ isin = "isin" and
+ inorder = "inorder" and
+ inv = "invar_inorder (Suc k)"
+proof (standard, goal_cases)
+ case (2 s x)
+ then show ?case
+ by (simp add: isin_set_inorder)
+next
+ case (3 s x)
+ then show ?case using insert_inorder
+ by simp
+next
+ case (4 s x)
+ then show ?case using delete_inorder
+ by auto
+next
+ case (6 s x)
+ then show ?case using insert_order insert_bal
+ by auto
+next
+ case (7 s x)
+ then show ?case using delete_order delete_bal
+ by auto
+qed (simp add: empty_btree_def)+
+
+
+(* if we remove this, it is not possible to remove the simp rules in subsequent contexts... *)
+declare node\<^sub>i.simps[simp del]
+
+end
+
+
+end
diff --git a/thys/BTree/BTree_Split.thy b/thys/BTree/BTree_Split.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/BTree_Split.thy
@@ -0,0 +1,167 @@
+theory BTree_Split
+ imports BTree_Set
+begin
+
+section "Abstract split functions"
+
+subsection "Linear split"
+
+text "Finally we show that the split axioms are feasible
+ by providing an example split function"
+
+(*TODO: at some point this better be replaced with something binary search like *)
+fun linear_split_help:: "(_\<times>'a::linorder) list \<Rightarrow> _ \<Rightarrow> (_\<times>_) list \<Rightarrow> ((_\<times>_) list \<times> (_\<times>_) list)" where
+ "linear_split_help [] x prev = (prev, [])" |
+ "linear_split_help ((sub, sep)#xs) x prev = (if sep < x then linear_split_help xs x (prev @ [(sub, sep)]) else (prev, (sub,sep)#xs))"
+
+fun linear_split:: "(_\<times>'a::linorder) list \<Rightarrow> _ \<Rightarrow> ((_\<times>_) list \<times> (_\<times>_) list)" where
+ "linear_split xs x = linear_split_help xs x []"
+
+text "Linear split is similar to well known functions, therefore a quick proof can be done."
+
+lemma linear_split_alt: "linear_split xs x = (takeWhile (\<lambda>(_,s). s<x) xs, dropWhile (\<lambda>(_,s). s<x) xs)"
+proof -
+
+ have "linear_split_help xs x prev = (prev @ takeWhile (\<lambda>(_, s). s < x) xs, dropWhile (\<lambda>(_, s). s < x) xs)"
+ for prev
+ apply (induction xs arbitrary: prev)
+ apply auto
+ done
+ thus ?thesis by auto
+qed
+
+global_interpretation btree_linear_search: split linear_split
+ (* the below definitions are required to be set here for evaluating example code... *)
+ defines btree_ls_isin = btree_linear_search.isin
+ and btree_ls_ins = btree_linear_search.ins
+ and btree_ls_insert = btree_linear_search.insert
+ and btree_ls_del = btree_linear_search.del
+ and btree_ls_delete = btree_linear_search.delete
+ apply unfold_locales
+ unfolding linear_split_alt
+ apply (auto split: list.splits)
+ subgoal
+ by (metis (no_types, lifting) case_prodD in_set_conv_decomp takeWhile_eq_all_conv takeWhile_idem)
+ subgoal
+ by (metis case_prod_conv hd_dropWhile le_less_linear list.sel(1) list.simps(3))
+ done
+
+
+text "Some examples follow to show that the implementation works
+ and the above lemmas make sense. The examples are visualized in the thesis."
+
+abbreviation "btree\<^sub>i \<equiv> btree_ls_insert"
+abbreviation "btree\<^sub>d \<equiv> btree_ls_delete"
+
+value "let k=2::nat; x::nat btree = (Node [(Node [(Leaf, 3),(Leaf, 5),(Leaf, 6)] Leaf, 10)] (Node [(Leaf, 14), (Leaf, 20)] Leaf)) in
+ root_order k x"
+value "let k=2::nat; x::nat btree = (Node [(Node [(Leaf, 3),(Leaf, 5),(Leaf, 6)] Leaf, 10)] (Node [(Leaf, 14), (Leaf, 20)] Leaf)) in
+ bal x"
+value "let k=2::nat; x::nat btree = (Node [(Node [(Leaf, 3),(Leaf, 5),(Leaf, 6)] Leaf, 10)] (Node [(Leaf, 14), (Leaf, 20)] Leaf)) in
+ sorted_less (inorder x)"
+value "let k=2::nat; x::nat btree = (Node [(Node [(Leaf, 3),(Leaf, 5),(Leaf, 6)] Leaf, 10)] (Node [(Leaf, 14), (Leaf, 20)] Leaf)) in
+ x"
+value "let k=2::nat; x::nat btree = (Node [(Node [(Leaf, 3),(Leaf, 5),(Leaf, 6)] Leaf, 10)] (Node [(Leaf, 14), (Leaf, 20)] Leaf)) in
+ btree\<^sub>i k 9 x"
+value "let k=2::nat; x::nat btree = (Node [(Node [(Leaf, 3),(Leaf, 5),(Leaf, 6)] Leaf, 10)] (Node [(Leaf, 14), (Leaf, 20)] Leaf)) in
+ btree\<^sub>i k 1 (btree\<^sub>i k 9 x)"
+value "let k=2::nat; x::nat btree = (Node [(Node [(Leaf, 3),(Leaf, 5),(Leaf, 6)] Leaf, 10)] (Node [(Leaf, 14), (Leaf, 20)] Leaf)) in
+ btree\<^sub>d k 10 (btree\<^sub>i k 1 (btree\<^sub>i k 9 x))"
+value "let k=2::nat; x::nat btree = (Node [(Node [(Leaf, 3),(Leaf, 5),(Leaf, 6)] Leaf, 10)] (Node [(Leaf, 14), (Leaf, 20)] Leaf)) in
+ btree\<^sub>d k 3 (btree\<^sub>d k 10 (btree\<^sub>i k 1 (btree\<^sub>i k 9 x)))"
+
+text "For completeness, we also proved an explicit proof of the locale
+requirements."
+
+lemma some_child_sm: "linear_split_help t y xs = (ls,(sub,sep)#rs) \<Longrightarrow> y \<le> sep"
+ apply(induction t y xs rule: linear_split_help.induct)
+ apply(simp_all)
+ by (metis Pair_inject le_less_linear list.inject)
+
+
+
+lemma linear_split_append: "linear_split_help xs p ys = (ls,rs) \<Longrightarrow> ls@rs = ys@xs"
+ apply(induction xs p ys rule: linear_split_help.induct)
+ apply(simp_all)
+ by (metis Pair_inject)
+
+lemma linear_split_sm: "\<lbrakk>linear_split_help xs p ys = (ls,rs); sorted_less (separators (ys@xs)); \<forall>sep \<in> set (separators ys). p > sep\<rbrakk> \<Longrightarrow> \<forall>sep \<in> set (separators ls). p > sep"
+ apply(induction xs p ys rule: linear_split_help.induct)
+ apply(simp_all)
+ by (metis prod.inject)+
+
+value "linear_split [((Leaf::nat btree), 2)] (1::nat)"
+
+(* TODO still has format for older proof *)
+lemma linear_split_gr:
+ "\<lbrakk>linear_split_help xs p ys = (ls,rs); sorted_less (separators (ys@xs)); \<forall>(sub,sep) \<in> set ys. p > sep\<rbrakk> \<Longrightarrow>
+(case rs of [] \<Rightarrow> True | (_,sep)#_ \<Rightarrow> p \<le> sep)"
+ apply(cases rs)
+ by (auto simp add: some_child_sm)
+
+
+lemma linear_split_req:
+ assumes "linear_split xs p = (ls,(sub,sep)#rs)"
+ and "sorted_less (separators xs)"
+ shows "p \<le> sep"
+ using assms linear_split_gr by fastforce
+
+lemma linear_split_req2:
+ assumes "linear_split xs p = (ls@[(sub,sep)],rs)"
+ and "sorted_less (separators xs)"
+ shows "sep < p"
+ using linear_split_sm[of xs p "[]" "ls@[(sub,sep)]" rs]
+ using assms(1) assms(2)
+ by (metis Nil_is_map_conv Un_iff append_self_conv2 empty_iff empty_set linear_split.elims prod_set_simps(2) separators_split snd_eqD snds.intros)
+
+
+interpretation split linear_split
+ by (simp add: linear_split_req linear_split_req2 linear_split_append split_def)
+
+
+subsection "Binary split"
+
+text "It is possible to define a binary split predicate.
+ However, even proving that it terminates is uncomfortable."
+
+function (sequential) binary_split_help:: "(_\<times>'a::linorder) list \<Rightarrow> (_\<times>'a) list \<Rightarrow> (_\<times>'a) list \<Rightarrow> 'a \<Rightarrow> ((_\<times>_) list \<times> (_\<times>_) list)" where
+ "binary_split_help ls [] rs x = (ls,rs)" |
+ "binary_split_help ls as rs x = (let (mls, mrs) = split_half as in (
+ case mrs of (sub,sep)#mrrs \<Rightarrow> (
+ if x < sep then binary_split_help ls mls (mrs@rs) x
+ else if x > sep then binary_split_help (ls@mls@[(sub,sep)]) mrrs rs x
+ else (ls@mls, mrs@rs)
+ )
+ )
+)"
+ by pat_completeness auto
+termination
+ apply(relation "measure (\<lambda>(ls,xs,rs,x). length xs)")
+ apply (auto)
+ by (metis append_take_drop_id length_Cons length_append lessI trans_less_add2)
+
+
+fun binary_split where
+ "binary_split as x = binary_split_help [] as [] x"
+
+text "We can show that it will return sublists that concatenate to
+ the original list again but will not show that it fulfils sortedness properties."
+
+lemma "binary_split_help as bs cs x = (ls,rs) \<Longrightarrow> (as@bs@cs) = (ls@rs)"
+ apply(induction as bs cs x arbitrary: ls rs rule: binary_split_help.induct)
+ apply (auto simp add: drop_not_empty split!: list.splits )
+ subgoal for ls a b va rs x lsa rsa aa ba x22
+ apply(cases "cmp x ba")
+ apply auto
+ apply (metis Cons_eq_appendI append_eq_appendI append_take_drop_id)
+ apply (metis append_take_drop_id)
+ by (metis Cons_eq_appendI append_eq_appendI append_take_drop_id)
+ done
+
+lemma "\<lbrakk>sorted_less (separators (as@bs@cs)); binary_split_help as bs cs x = (ls,rs); \<forall>y \<in> set (separators as). y < x\<rbrakk>
+\<Longrightarrow> \<forall>y \<in> set (separators ls). y < x"
+ oops
+
+
+
+end
diff --git a/thys/BTree/Basic_Assn.thy b/thys/BTree/Basic_Assn.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/Basic_Assn.thy
@@ -0,0 +1,50 @@
+theory Basic_Assn
+ imports
+ "Refine_Imperative_HOL.Sepref_HOL_Bindings"
+ "Refine_Imperative_HOL.Sepref_Basic"
+begin
+
+section "Auxilary imperative assumptions"
+
+text "The following auxiliary assertion types and lemmas were provided by Peter Lammich"
+
+subsection \<open>List-Assn\<close>
+
+
+
+lemma list_assn_cong[fundef_cong]:
+ "\<lbrakk> xs=xs'; ys=ys'; \<And>x y. \<lbrakk> x\<in>set xs; y\<in>set ys \<rbrakk> \<Longrightarrow> A x y = A' x y \<rbrakk> \<Longrightarrow> list_assn A xs ys = list_assn A' xs' ys'"
+ by (induction xs ys arbitrary: xs' ys' rule: list_assn.induct) auto
+
+
+lemma list_assn_app_one: "list_assn P (l1@[x]) (l1'@[y]) = list_assn P l1 l1' * P x y"
+ by simp
+
+(* ------------------ ADDED by NM in course of btree_imp -------- *)
+
+
+lemma list_assn_len: "h \<Turnstile> list_assn A xs ys \<Longrightarrow> length xs = length ys"
+ using list_assn_aux_ineq_len by fastforce
+
+
+lemma list_assn_append_Cons_left: "list_assn A (xs@x#ys) zs = (\<exists>\<^sub>A zs1 z zs2. list_assn A xs zs1 * A x z * list_assn A ys zs2 * \<up>(zs1@z#zs2 = zs))"
+ by (sep_auto simp add: list_assn_aux_cons_conv list_assn_aux_append_conv1 intro!: ent_iffI)
+
+
+lemma list_assn_aux_append_Cons:
+ shows "length xs = length zsl \<Longrightarrow> list_assn A (xs@x#ys) (zsl@z#zsr) = (list_assn A xs zsl * A x z * list_assn A ys zsr) "
+ by (sep_auto simp add: mult.assoc)
+
+
+(* -------------------------------------------- *)
+
+subsection \<open>Prod-Assn\<close>
+
+
+lemma prod_assn_cong[fundef_cong]:
+ "\<lbrakk> p=p'; pi=pi'; A (fst p) (fst pi) = A' (fst p) (fst pi); B (snd p) (snd pi) = B' (snd p) (snd pi) \<rbrakk>
+ \<Longrightarrow> (A\<times>\<^sub>aB) p pi = (A'\<times>\<^sub>aB') p' pi'"
+ apply (cases p; cases pi)
+ by auto
+
+end
\ No newline at end of file
diff --git a/thys/BTree/Imperative_Loops.thy b/thys/BTree/Imperative_Loops.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/Imperative_Loops.thy
@@ -0,0 +1,129 @@
+theory Imperative_Loops
+ imports
+ "Refine_Imperative_HOL.Sepref_HOL_Bindings"
+ "Refine_Imperative_HOL.Pf_Mono_Prover"
+ "Refine_Imperative_HOL.Pf_Add"
+
+
+begin
+
+section \<open>Imperative Loops\<close>
+
+text "An auxiliary while rule provided by Peter Lammich."
+
+lemma heap_WHILET_rule:
+ assumes
+ "wf R"
+ "P \<Longrightarrow>\<^sub>A I s"
+ "\<And>s. <I s * true> bi s <\<lambda>r. I s * \<up>(r \<longleftrightarrow> b s)>\<^sub>t"
+ "\<And>s. b s \<Longrightarrow> <I s * true> f s <\<lambda>s'. I s' * \<up>((s', s) \<in> R)>\<^sub>t"
+ "\<And>s. \<not> b s \<Longrightarrow> I s \<Longrightarrow>\<^sub>A Q s"
+ shows "<P * true> heap_WHILET bi f s <Q>\<^sub>t"
+proof -
+ have "<I s * true> heap_WHILET bi f s <\<lambda>s'. I s' * \<up>(\<not> b s')>\<^sub>t"
+ using assms(1)
+ proof (induction arbitrary:)
+ case (less s)
+ show ?case
+ proof (cases "b s")
+ case True
+ then show ?thesis
+ by (subst heap_WHILET_unfold) (sep_auto heap: assms(3,4) less)
+ next
+ case False
+ then show ?thesis
+ by (subst heap_WHILET_unfold) (sep_auto heap: assms(3))
+ qed
+ qed
+ then show ?thesis
+ apply (rule cons_rule[rotated 2])
+ apply (intro ent_star_mono assms(2) ent_refl)
+ apply clarsimp
+ apply (intro ent_star_mono assms(5) ent_refl)
+ .
+qed
+
+
+lemma heap_WHILET_rule':
+ assumes
+ "wf R"
+ "P \<Longrightarrow>\<^sub>A I s si * F"
+ "\<And>si s. <I s si * F> bi si <\<lambda>r. I s si * F * \<up>(r \<longleftrightarrow> b s)>\<^sub>t"
+ "\<And>si s. b s \<Longrightarrow> <I s si * F> f si <\<lambda>si'. \<exists>\<^sub>As'. I s' si' * F * \<up>((s', s) \<in> R)>\<^sub>t"
+ "\<And>si s. \<not> b s \<Longrightarrow> I s si * F \<Longrightarrow>\<^sub>A Q s si"
+ shows "<P> heap_WHILET bi f si <\<lambda>si. \<exists>\<^sub>As. Q s si>\<^sub>t"
+proof -
+ have "<I s si * F> heap_WHILET bi f si <\<lambda>si'. \<exists>\<^sub>As'. I s' si' * F * \<up>(\<not> b s')>\<^sub>t"
+ using assms(1)
+ proof (induction arbitrary: si)
+ case (less s)
+ show ?case
+ proof (cases "b s")
+ case True
+ then show ?thesis
+ apply (subst heap_WHILET_unfold)
+ apply (sep_auto heap: assms(3,4) less)
+ done
+ next
+ case False
+ then show ?thesis
+ by (subst heap_WHILET_unfold) (sep_auto heap: assms(3))
+ qed
+ qed
+ then show ?thesis
+ apply (rule cons_rule[rotated 2])
+ apply (intro ent_star_mono assms(2) ent_refl)
+ apply clarsimp
+ apply (sep_auto )
+ apply (erule ent_frame_fwd[OF assms(5)])
+ apply frame_inference
+ by sep_auto
+
+qed
+
+(* Added by NM, just a technicality since this rule fits our use case better *)
+
+text "I derived my own version,
+simply because it was a better fit to my use case."
+
+corollary heap_WHILET_rule'':
+ assumes
+ "wf R"
+ "P \<Longrightarrow>\<^sub>A I s"
+ "\<And>s. <I s * true> bi s <\<lambda>r. I s * \<up>(r \<longleftrightarrow> b s)>\<^sub>t"
+ "\<And>s. b s \<Longrightarrow> <I s * true> f s <\<lambda>s'. I s' * \<up>((s', s) \<in> R)>\<^sub>t"
+ "\<And>s. \<not> b s \<Longrightarrow> I s \<Longrightarrow>\<^sub>A Q s"
+ shows "<P> heap_WHILET bi f s <Q>\<^sub>t"
+ supply R = heap_WHILET_rule'[of R P "\<lambda>s si. \<up>(s = si) * I s" s _ true bi b f "\<lambda>s si.\<up>(s = si) * Q s * true"]
+ thm R
+ using assms ent_true_drop apply(sep_auto heap: R assms)
+ done
+ (*
+explicit proof:
+
+proof -
+ have "<I s * true> heap_WHILET bi f s <\<lambda>s'. I s' * \<up>(\<not> b s')>\<^sub>t"
+ using assms(1)
+ proof (induction arbitrary:)
+ case (less s)
+ show ?case
+ proof (cases "b s")
+ case True
+ then show ?thesis
+ by (subst heap_WHILET_unfold) (sep_auto heap: assms(3,4) less)
+ next
+ case False
+ then show ?thesis
+ by (subst heap_WHILET_unfold) (sep_auto heap: assms(3))
+ qed
+ qed
+ then show ?thesis
+ apply (rule cons_rule[rotated 2])
+ apply (intro ent_true_drop assms(2) ent_refl)
+ apply clarsimp
+ apply(intro ent_star_mono assms(5) ent_refl)
+ .
+qed
+*)
+
+end
diff --git a/thys/BTree/Partially_Filled_Array.thy b/thys/BTree/Partially_Filled_Array.thy
new file mode 100644
--- /dev/null
+++ b/thys/BTree/Partially_Filled_Array.thy
@@ -0,0 +1,427 @@
+theory Partially_Filled_Array
+ imports
+ "Refine_Imperative_HOL.IICF_Array_List"
+ Array_SBlit
+begin
+
+section "Partially Filled Arrays"
+
+text \<open>An array that is only partially filled.
+The number of actual elements contained is kept in a second element.
+This represents a weakened version of the array\_list from IICF.\<close>
+
+type_synonym 'a pfarray = "'a array_list"
+
+
+subsection "Operations on Partly Filled Arrays"
+
+
+definition is_pfa where
+ "is_pfa c l \<equiv> \<lambda>(a,n). \<exists>\<^sub>A l'. a \<mapsto>\<^sub>a l' * \<up>(c = length l' \<and> n \<le> c \<and> l = (take n l'))"
+
+
+lemma is_pfa_prec[safe_constraint_rules]: "precise (is_pfa c)"
+ unfolding is_pfa_def[abs_def]
+ apply(rule preciseI)
+ apply(simp split: prod.splits)
+ using preciseD snga_prec by fastforce
+
+definition pfa_init where
+ "pfa_init cap v n \<equiv> do {
+ a \<leftarrow> Array.new cap v;
+ return (a,n)
+}"
+
+lemma pfa_init_rule[sep_heap_rules]: "n \<le> N \<Longrightarrow> < emp > pfa_init N x n <is_pfa N (replicate n x)>"
+ by (sep_auto simp: pfa_init_def is_pfa_def)
+
+definition pfa_empty where
+ "pfa_empty cap \<equiv> pfa_init cap default 0"
+
+
+
+lemma pfa_empty_rule[sep_heap_rules]: "< emp > pfa_empty N <is_pfa N []>"
+ by (sep_auto simp: pfa_empty_def is_pfa_def)
+
+
+definition "pfa_length \<equiv> arl_length"
+
+lemma pfa_length_rule[sep_heap_rules]: "
+ <is_pfa c l a>
+ pfa_length a
+ <\<lambda>r. is_pfa c l a * \<up>(r=length l)>"
+ by (sep_auto simp: pfa_length_def arl_length_def is_pfa_def)
+
+
+definition "pfa_capacity \<equiv> \<lambda>(a,n). Array.len a
+"
+
+
+lemma pfa_capacity_rule[sep_heap_rules]: "
+ <is_pfa c l a>
+ pfa_capacity a
+ <\<lambda>r. is_pfa c l a * \<up>(c=r)>"
+ by (sep_auto simp: pfa_capacity_def arl_length_def is_pfa_def)
+
+
+
+definition "pfa_is_empty \<equiv> arl_is_empty"
+
+lemma pfa_is_empty_rule[sep_heap_rules]: "
+ <is_pfa c l a>
+ pfa_is_empty a
+ <\<lambda>r. is_pfa c l a * \<up>(r\<longleftrightarrow>(l=[]))>"
+ by (sep_auto simp: pfa_is_empty_def arl_is_empty_def is_pfa_def)
+
+
+
+definition "pfa_append \<equiv> \<lambda>(a,n) x. do {
+ Array.upd n x a;
+ return (a,n+1)
+}"
+
+lemma pfa_append_rule[sep_heap_rules]: "
+ n < c \<Longrightarrow>
+ < is_pfa c l (a,n) >
+ pfa_append (a,n) x
+ <\<lambda>(a',n'). is_pfa c (l@[x]) (a',n') * \<up>(a' = a \<and> n' = n+1) >"
+ by (sep_auto
+ simp: pfa_append_def arl_append_def is_pfa_def take_update_last neq_Nil_conv
+ split: prod.splits nat.split)
+
+
+definition "pfa_last \<equiv> arl_last"
+
+
+lemma pfa_last_rule[sep_heap_rules]: "
+ l\<noteq>[] \<Longrightarrow>
+ <is_pfa c l a>
+ pfa_last a
+ <\<lambda>r. is_pfa c l a * \<up>(r=last l)>"
+ by (sep_auto simp: pfa_last_def arl_last_def is_pfa_def last_take_nth_conv)
+
+
+definition pfa_butlast :: "'a::heap pfarray \<Rightarrow> 'a pfarray Heap" where
+ "pfa_butlast \<equiv> \<lambda>(a,n).
+ return (a,n-1)
+ "
+
+
+lemma pfa_butlast_rule[sep_heap_rules]: "
+ <is_pfa c l (a,n)>
+ pfa_butlast (a,n)
+ <\<lambda>(a',n'). is_pfa c (butlast l) (a',n') * \<up>(a' = a)>"
+ by (sep_auto
+ split: prod.splits
+ simp: pfa_butlast_def is_pfa_def butlast_take)
+
+
+definition "pfa_get \<equiv> arl_get"
+
+lemma pfa_get_rule[sep_heap_rules]: "
+ i < length l \<Longrightarrow>
+ < is_pfa c l a>
+ pfa_get a i
+ <\<lambda>r. is_pfa c l a * \<up>((l!i) = r)>"
+ by (sep_auto simp: is_pfa_def pfa_get_def arl_get_def split: prod.split)
+
+
+definition "pfa_set \<equiv> arl_set"
+
+lemma pfa_set_rule[sep_heap_rules]: "
+ i<length l \<Longrightarrow>
+ <is_pfa c l a>
+ pfa_set a i x
+ <\<lambda>a'. is_pfa c (l[i:=x]) a' * \<up>(a' = a)>"
+ by (sep_auto simp: pfa_set_def arl_set_def is_pfa_def split: prod.split)
+
+
+
+
+
+definition pfa_shrink :: "nat \<Rightarrow> 'a::heap pfarray \<Rightarrow> 'a pfarray Heap" where
+ "pfa_shrink k \<equiv> \<lambda>(a,n).
+ return (a,k)
+"
+
+
+lemma pfa_shrink_rule[sep_heap_rules]: "
+ k \<le> length l \<Longrightarrow>
+ < is_pfa c l (a,n) >
+ pfa_shrink k (a,n)
+ <\<lambda>(a',n'). is_pfa c (take k l) (a',n') * \<up>(n' = k \<and> a'=a) >"
+ by (sep_auto
+ simp: pfa_shrink_def is_pfa_def min.absorb1
+ split: prod.splits nat.split)
+
+
+definition pfa_shrink_cap :: "nat \<Rightarrow> 'a::heap pfarray \<Rightarrow> 'a pfarray Heap" where
+ "pfa_shrink_cap k \<equiv> \<lambda>(a,n). do {
+ a' \<leftarrow> array_shrink a k;
+ return (a',min k n)
+}
+"
+
+lemma pfa_shrink_cap_rule_preserve[sep_heap_rules]: "
+ \<lbrakk>n \<le> k; k \<le> c\<rbrakk> \<Longrightarrow>
+ < is_pfa c l (a,n) >
+ pfa_shrink_cap k (a,n)
+ <\<lambda>a'. is_pfa k l a' >\<^sub>t"
+ by (sep_auto
+ simp: pfa_shrink_cap_def is_pfa_def min.absorb1 min.absorb2
+ split: prod.splits nat.split)
+
+
+
+lemma pfa_shrink_cap_rule: "
+ \<lbrakk>k \<le> c\<rbrakk> \<Longrightarrow>
+ < is_pfa c l a >
+ pfa_shrink_cap k a
+ <\<lambda>a'. is_pfa k (take k l) a' >\<^sub>t"
+ by (sep_auto
+ simp: pfa_shrink_cap_def is_pfa_def min.absorb1 min.absorb2
+ split: prod.splits nat.split dest: mod_starD)
+
+
+definition "array_ensure a s x \<equiv> do {
+ l\<leftarrow>Array.len a;
+ if l\<ge>s then
+ return a
+ else do {
+ a'\<leftarrow>Array.new s x;
+ blit a 0 a' 0 l;
+ return a'
+ }
+ }"
+
+lemma array_ensure_rule[sep_heap_rules]:
+ shows "
+ < a\<mapsto>\<^sub>ala >
+ array_ensure a s x
+ <\<lambda>a'. a'\<mapsto>\<^sub>a (la @ replicate (s-length la) x)>\<^sub>t"
+ unfolding array_ensure_def
+ by sep_auto
+
+(* Ensure a certain capacity *)
+definition pfa_ensure :: "'a::{heap,default} pfarray \<Rightarrow> nat \<Rightarrow> 'a pfarray Heap" where
+ "pfa_ensure \<equiv> \<lambda>(a,n) k. do {
+ a' \<leftarrow> array_ensure a k default;
+ return (a',n)
+}
+"
+
+lemma pfa_ensure_rule[sep_heap_rules]: "
+ < is_pfa c l (a,n) >
+ pfa_ensure (a,n) k
+ <\<lambda>(a',n'). is_pfa (max c k) l (a',n') * \<up>(n' = n \<and> c \<ge> n)>\<^sub>t"
+ by (sep_auto
+ simp: pfa_ensure_def is_pfa_def)
+
+
+definition "pfa_copy \<equiv> arl_copy"
+
+
+lemma pfa_copy_rule[sep_heap_rules]:
+ "< is_pfa c l a >
+ pfa_copy a
+ <\<lambda>r. is_pfa c l a * is_pfa c l r>\<^sub>t"
+ by (sep_auto simp: pfa_copy_def arl_copy_def is_pfa_def)
+
+definition pfa_blit :: "'a::heap pfarray \<Rightarrow> nat \<Rightarrow> 'a::heap pfarray \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow> unit Heap" where
+ "pfa_blit \<equiv> \<lambda>(src,sn) si (dst,dn) di l. blit src si dst di l"
+
+
+lemma min_nat: "min a (a+b) = (a::nat)"
+ by auto
+
+
+lemma pfa_blit_rule[sep_heap_rules]:
+ assumes LEN: "si+len \<le> sn" "di \<le> dn" "di+len \<le> dc"
+ shows
+ "< is_pfa sc src (srci,sn)
+ * is_pfa dc dst (dsti,dn) >
+ pfa_blit (srci,sn) si (dsti,dn) di len
+ <\<lambda>_. is_pfa sc src (srci,sn)
+ * is_pfa dc (take di dst @ take len (drop si src) @ drop (di+len) dst) (dsti,max (di+len) dn)
+ >"
+ using LEN apply(sep_auto simp add: min_nat is_pfa_def pfa_blit_def min.commute min.absorb1 heap: blit_rule)
+ apply (simp add: min.absorb1 take_drop)
+ apply (simp add: drop_take max_def)
+ done
+
+definition pfa_drop :: "('a::heap) pfarray \<Rightarrow> nat \<Rightarrow> 'a pfarray \<Rightarrow> 'a pfarray Heap" where
+ "pfa_drop \<equiv> \<lambda>(src,sn) si (dst,dn). do {
+ blit src si dst 0 (sn-si);
+ return (dst,(sn-si))
+}
+"
+
+
+lemma pfa_drop_rule[sep_heap_rules]:
+ assumes LEN: "k \<le> sn" "(sn-k) \<le> dc"
+ shows
+ "< is_pfa sc src (srci,sn)
+ * is_pfa dc dst (dsti,dn) >
+ pfa_drop (srci,sn) k (dsti,dn)
+ <\<lambda>(dsti',dn'). is_pfa sc src (srci,sn)
+ * is_pfa dc (drop k src) (dsti',dn')
+ * \<up>(dsti' = dsti)
+ >"
+ using LEN apply (sep_auto simp add: drop_take is_pfa_def pfa_drop_def dest!: mod_starD heap: pfa_blit_rule)
+ done
+
+
+definition "pfa_append_grow \<equiv> \<lambda>(a,n) x. do {
+ l \<leftarrow> pfa_capacity (a,n);
+ a' \<leftarrow> if l = n
+ then array_grow a (l+1) x
+ else Array.upd n x a;
+ return (a',n+1)
+}"
+
+
+
+lemma pfa_append_grow_full_rule[sep_heap_rules]: "n = c \<Longrightarrow>
+ <is_pfa c l (a,n)>
+ array_grow a (c+1) x
+ <\<lambda>a'. is_pfa (c+1) (l@[x]) (a',n+1)>\<^sub>t"
+ apply(sep_auto simp add: is_pfa_def
+ heap del: array_grow_rule)
+ apply(vcg heap del: array_grow_rule heap add: array_grow_rule[of l "(Suc (length l))" a x])
+ apply simp
+ apply(rule ent_ex_postI[where ?x="l@[x]"])
+ apply sep_auto
+ done
+
+
+lemma pfa_append_grow_less_rule: "n < c \<Longrightarrow>
+ <is_pfa c l (a,n)>
+ Array.upd n x a
+<\<lambda>a'. is_pfa c (l@[x]) (a',n+1)>\<^sub>t"
+ apply(sep_auto simp add: is_pfa_def take_update_last)
+ done
+
+lemma pfa_append_grow_rule[sep_heap_rules]: "
+ <is_pfa c l (a,n)>
+ pfa_append_grow (a,n) x
+ <\<lambda>(a',n'). is_pfa (if c = n then c+1 else c) (l@[x]) (a',n') * \<up>(n'=n+1 \<and> c \<ge> n)>\<^sub>t"
+ apply(subst pfa_append_grow_def)
+ apply(rule hoare_triple_preI)
+ apply (sep_auto
+ heap add: pfa_append_grow_full_rule pfa_append_grow_less_rule)
+ apply(sep_auto simp add: is_pfa_def)
+ apply(sep_auto simp add: is_pfa_def)
+ done
+
+(* This definition has only one access to the array length *)
+definition "pfa_append_grow' \<equiv> \<lambda>(a,n) x. do {
+ a' \<leftarrow> pfa_ensure (a,n) (n+1);
+ a'' \<leftarrow> pfa_append a' x;
+ return a''
+}"
+
+lemma pfa_append_grow'_rule[sep_heap_rules]: "
+ <is_pfa c l (a,n)>
+ pfa_append_grow' (a,n) x
+ <\<lambda>(a',n'). is_pfa (max (n+1) c) (l@[x]) (a',n') * \<up>(n'=n+1 \<and> c \<ge> n)>\<^sub>t"
+ unfolding pfa_append_grow'_def
+ by (sep_auto simp add: max_def)
+
+
+definition "pfa_insert \<equiv> \<lambda>(a,n) i x. do {
+ a' \<leftarrow> array_shr a i 1;
+ a'' \<leftarrow> Array.upd i x a;
+ return (a'',n+1)
+}"
+
+
+lemma list_update_last: "length ls = Suc i \<Longrightarrow> ls[i:=x] = (take i ls)@[x]"
+ by (metis append_eq_conv_conj length_Suc_rev_conv list_update_length)
+
+lemma pfa_insert_rule[sep_heap_rules]:
+ "\<lbrakk>i \<le> n; n < c\<rbrakk> \<Longrightarrow>
+ <is_pfa c l (a,n)>
+ pfa_insert (a,n) i x
+ <\<lambda>(a',n'). is_pfa c (take i l@x#drop i l) (a',n') * \<up>(n' = n+1 \<and> a=a')>"
+ unfolding pfa_insert_def is_pfa_def
+ by (sep_auto simp add: list_update_append1 list_update_last
+ Suc_diff_le drop_take min_def)
+
+definition pfa_insert_grow :: "'a::{heap,default} pfarray \<Rightarrow> nat \<Rightarrow> 'a \<Rightarrow> 'a pfarray Heap"
+ where "pfa_insert_grow \<equiv> \<lambda>(a,n) i x. do {
+ a' \<leftarrow> pfa_ensure (a,n) (n+1);
+ a'' \<leftarrow> pfa_insert a' i x;
+ return a''
+}"
+
+lemma pfa_insert_grow_rule:
+ "i \<le> n \<Longrightarrow>
+ <is_pfa c l (a,n)>
+ pfa_insert_grow (a,n) i x
+ <\<lambda>(a',n'). is_pfa (max c (n+1)) (take i l@x#drop i l) (a',n') * \<up>(n'=n+1 \<and> c \<ge> n)>\<^sub>t"
+ unfolding pfa_insert_grow_def
+ by (sep_auto heap add: pfa_insert_rule[of i n "max c (Suc n)"])
+
+
+definition pfa_extend where
+ "pfa_extend \<equiv> \<lambda> (a,n) (b,m). do{
+ blit b 0 a n m;
+ return (a,n+m)
+}"
+
+lemma pfa_extend_rule:
+ "n+m \<le> c \<Longrightarrow>
+ <is_pfa c l1 (a,n) * is_pfa d l2 (b,m)>
+ pfa_extend (a,n) (b,m)
+ <\<lambda>(a',n'). is_pfa c (l1@l2) (a',n') * \<up>(a' = a \<and> n'=n+m) * is_pfa d l2 (b,m)>\<^sub>t"
+ unfolding pfa_extend_def
+ by (sep_auto simp add: is_pfa_def min.absorb1 min.absorb2 heap add: blit_rule)
+
+
+definition pfa_extend_grow where
+ "pfa_extend_grow \<equiv> \<lambda> (a,n) (b,m). do{
+ a' \<leftarrow> array_ensure a (n+m) default;
+ blit b 0 a' n m;
+ return (a',n+m)
+}"
+
+lemma pfa_extend_grow_rule:
+ "<is_pfa c l1 (a,n) * is_pfa d l2 (b,m)>
+ pfa_extend_grow (a,n) (b,m)
+ <\<lambda>(a',n'). is_pfa (max c (n+m)) (l1@l2) (a',n') * \<up>(n'=n+m \<and> c \<ge> n) * is_pfa d l2 (b,m)>\<^sub>t"
+ unfolding pfa_extend_grow_def
+ by (sep_auto simp add: is_pfa_def min.absorb1 min.absorb2 heap add: blit_rule)
+
+definition pfa_append_extend_grow where
+ "pfa_append_extend_grow \<equiv> \<lambda> (a,n) x (b,m). do{
+ a' \<leftarrow> array_ensure a (n+m+1) default;
+ a'' \<leftarrow> Array.upd n x a';
+ blit b 0 a'' (n+1) m;
+ return (a'',n+m+1)
+}"
+
+lemma pfa_append_extend_grow_rule:
+ "<is_pfa c l1 (a,n) * is_pfa d l2 (b,m)>
+ pfa_append_extend_grow (a,n) x (b,m)
+ <\<lambda>(a',n'). is_pfa (max c (n+m+1)) (l1@x#l2) (a',n') * \<up>(n'=n+m+1 \<and> c \<ge> n) * is_pfa d l2 (b,m)>\<^sub>t"
+ unfolding pfa_append_extend_grow_def
+ by (sep_auto simp add: list_update_last is_pfa_def min.absorb1 min.absorb2 heap add: blit_rule)
+
+
+definition "pfa_delete \<equiv> \<lambda>(a,n) i. do {
+ array_shl a (i+1) 1;
+ return (a,n-1)
+}"
+
+lemma pfa_delete_rule[sep_heap_rules]:
+ "i < n \<Longrightarrow>
+ <is_pfa c l (a,n)>
+ pfa_delete (a,n) i
+ <\<lambda>(a',n'). is_pfa c (take i l@drop (i+1) l) (a',n') * \<up>(n' = n-1 \<and> a=a')>"
+ unfolding pfa_delete_def is_pfa_def
+ apply (sep_auto simp add: drop_take min_def)
+ by (metis Suc_diff_Suc diff_zero dual_order.strict_trans2 le_less_Suc_eq zero_le)
+
+
+
+end
\ No newline at end of file
diff --git a/thys/BTree/README.md b/thys/BTree/README.md
new file mode 100644
--- /dev/null
+++ b/thys/BTree/README.md
@@ -0,0 +1,37 @@
+# A Verified Imperative Implementation of B-Trees
+
+This repository contains all definitions, lemmas and proofs
+related to the Bachelors Thesis "A Verified Imperative Implementation of B-Trees"
+by Niels Mündler.
+
+For a detailed description of the project, [see the thesis](https://github.com/nielstron/btrees-thesis).
+
+## Overview
+
+A functional specification of B-trees, B-tree operations and a
+height analysis may be found in
+the files `BTree*.thy` that do not contain `Imp`.
+
+An imperative specification of B-trees may be found in `BTree_Imp*.thy`.
+This imperative specification makes use of the auxiliary definition
+of "Partially Filled Arrays" as list refinements, which may be found in `Partially_Filled_Array.thy`.
+Further an extension of the standard array blit operation in Isabelle,
+such that it allows error-free array-internal copy operations,
+may be found in `Array_SBlit.thy`.
+
+The remaining files contain auxiliary lemmas and definitions that are due to
+Dr. Peter Lammich or me.
+
+All above mentioned files contain definitions as well as proofs of functional correctness.
+
+
+## Usage
+
+These theories have been tested with [Isabelle2020](https://isabelle.in.tum.de/website-Isabelle2020/index.html), although it should be compatible to newer versions of the tool.
+
+The files `BTree*.thy` that do not contain `Imp` only need a regular Isabelle2020 setup.
+
+The rest of the theories build upon [Refine_Imperative_HOL](https://www.isa-afp.org/entries/Refine_Imperative_HOL.html), you will need to succesfully set up that project first as described in the [rArchive of Formal Proofs](https://www.isa-afp.org/using.html).
+The script `start_isabelle.sh` uses and if not available compiles a session
+containing the content of the Refinement Framework which significantly enhances
+working with the files provided in this project.
diff --git a/thys/BTree/ROOT b/thys/BTree/ROOT
new file mode 100644
--- /dev/null
+++ b/thys/BTree/ROOT
@@ -0,0 +1,19 @@
+chapter AFP
+
+session "BTree" (AFP) = Refine_Imperative_HOL +
+ options [timeout = 600]
+ sessions
+ "HOL-Data_Structures"
+ theories
+ BTree
+ BTree_Height
+ BTree_Set
+ BTree_Split
+ Array_SBlit
+ Partially_Filled_Array
+ BTree_Imp
+ BTree_ImpSet
+ BTree_ImpSplit
+ document_files
+ "root.tex"
+ "root.bib"
diff --git a/thys/BTree/document/root.bib b/thys/BTree/document/root.bib
new file mode 100644
--- /dev/null
+++ b/thys/BTree/document/root.bib
@@ -0,0 +1,34 @@
+@article{Refine_Imperative_HOL-AFP,
+ author = {Peter Lammich},
+ title = {The Imperative Refinement Framework},
+ journal = {Archive of Formal Proofs},
+ month = aug,
+ year = 2016,
+ note = {\url{https://isa-afp.org/entries/Refine_Imperative_HOL.html},
+ Formal proof development},
+ ISSN = {2150-914x},
+}
+@article{DBLP:journals/acta/BayerM72,
+ author = {Rudolf Bayer and
+ Edward M. McCreight},
+ title = {Organization and Maintenance of Large Ordered Indices},
+ journal = {Acta Informatica},
+ volume = {1},
+ pages = {173--189},
+ year = {1972},
+ url = {https://doi.org/10.1007/BF00288683},
+ doi = {10.1007/BF00288683},
+ timestamp = {Sun, 21 Jun 2020 17:37:55 +0200},
+ biburl = {https://dblp.org/rec/journals/acta/BayerM72.bib},
+ bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+@mastersthesis{BTNielsMuendler,
+ author = {Niels Mündler},
+ title = {A Verified Imperative Implementation of B-Trees},
+ type = {Bachelor's Thesis},
+ school = "Technische Universität München",
+ address = "München",
+ year = {2021},
+ biburl = {https://mediatum.ub.tum.de/export/1596550/bibtex},
+ url = {https://mediatum.ub.tum.de/1596550},
+}
\ No newline at end of file
diff --git a/thys/BTree/document/root.tex b/thys/BTree/document/root.tex
new file mode 100644
--- /dev/null
+++ b/thys/BTree/document/root.tex
@@ -0,0 +1,63 @@
+\documentclass[11pt,a4paper]{article}
+\usepackage{isabelle,isabellesym}
+\usepackage{mathtools}
+\usepackage{amssymb}
+\usepackage{stmaryrd}
+\usepackage[numbers]{natbib}
+
+% this should be the last package used
+\usepackage{pdfsetup}
+\usepackage{doi}
+
+% urls in roman style, theory text in math-similar italics
+\urlstyle{rm}
+\isabellestyle{it}
+
+\DeclarePairedDelimiter{\norm}{\lVert}{\rVert}
+
+\begin{document}
+
+\title{A Verified Imperative Implementation of B-Trees}
+\author{Niels Mündler}
+\date{}
+\maketitle
+
+\begin{abstract}
+In this work, we use the interactive theorem prover Isabelle/HOL
+to verify an imperative implementation of the classical B-tree data structure \cite{DBLP:journals/acta/BayerM72}.
+The implementation supports set membership and insertion queries
+with efficient binary search for intra-node navigation.
+This is accomplished by first specifying the structure abstractly
+in the functional modeling language HOL and proving functional correctness.
+Using manual refinement, we derive an imperative implementation
+in Imperative/HOL.
+We show the validity of this refinement using
+the separation logic utilities from the
+Isabelle Refinement Framework \cite{Refine_Imperative_HOL-AFP}.
+The code can be exported to the programming languages SML and Scala.
+We examine the runtime of all operations indirectly by reproducing results
+of the logarithmic relationship between height and the number of nodes.
+The results are discussed in greater detail in the related Bachelor's Thesis
+\cite{BTNielsMuendler}.
+\end{abstract}
+
+\tableofcontents
+
+% sane default for proof documents
+\parindent 0pt\parskip 0.5ex
+
+% generated text of all theories
+\input{session}
+
+% optional bibliography
+{\raggedright
+\bibliographystyle{plainnat}
+\bibliography{root}
+}
+
+\end{document}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: t
+%%% End:
diff --git a/thys/Formal_Puiseux_Series/FPS_Hensel.thy b/thys/Formal_Puiseux_Series/FPS_Hensel.thy
new file mode 100644
--- /dev/null
+++ b/thys/Formal_Puiseux_Series/FPS_Hensel.thy
@@ -0,0 +1,442 @@
+(*
+ File: FPS_Hensel.thy
+ Author: Manuel Eberl, TU München
+*)
+section \<open>Hensel's lemma for formal power series\<close>
+theory FPS_Hensel
+ imports "HOL-Computational_Algebra.Computational_Algebra" Puiseux_Polynomial_Library
+begin
+
+text \<open>
+ The following proof of Hensel's lemma for formal power series follows the book
+ ``Algebraic Geometry for Scientists and Engineers'' by Abhyankar~\cite[p.~90--92]{abhyankar1990}.
+\<close>
+
+definition fps_poly_swap1 :: "'a :: zero fps poly \<Rightarrow> 'a poly fps" where
+ "fps_poly_swap1 p = Abs_fps (\<lambda>m. Abs_poly (\<lambda>n. fps_nth (coeff p n) m))"
+
+lemma coeff_fps_nth_fps_poly_swap1 [simp]:
+ "coeff (fps_nth (fps_poly_swap1 p) m) n = fps_nth (coeff p n) m"
+proof -
+ have "\<forall>\<^sub>\<infinity>n. poly.coeff p n = 0"
+ using MOST_coeff_eq_0 by blast
+ hence "\<forall>\<^sub>\<infinity>n. poly.coeff p n $ m = 0"
+ by eventually_elim auto
+ thus ?thesis
+ by (simp add: fps_poly_swap1_def poly.Abs_poly_inverse)
+qed
+
+definition fps_poly_swap2 :: "'a :: zero poly fps \<Rightarrow> 'a fps poly" where
+ "fps_poly_swap2 p = Abs_poly (\<lambda>m. Abs_fps (\<lambda>n. coeff (fps_nth p n) m))"
+
+lemma fps_nth_coeff_fps_poly_swap2:
+ assumes "\<And>n. degree (fps_nth p n) \<le> d"
+ shows "fps_nth (coeff (fps_poly_swap2 p) m) n = coeff (fps_nth p n) m"
+proof -
+ have "\<forall>\<^sub>\<infinity>n. n > d"
+ using MOST_nat by blast
+ hence "\<forall>\<^sub>\<infinity>n. (\<lambda>m. poly.coeff (p $ m) n) = (\<lambda>_. 0)"
+ by eventually_elim (auto simp: fun_eq_iff intro!: coeff_eq_0 le_less_trans[OF assms(1)])
+ hence ev: "\<forall>\<^sub>\<infinity>n. Abs_fps (\<lambda>m. poly.coeff (p $ m) n) = 0"
+ by eventually_elim (simp add: fps_zero_def)
+
+ have "fps_nth (coeff (fps_poly_swap2 p) m) n =
+ poly.coeff (Abs_poly (\<lambda>m. Abs_fps (\<lambda>n. poly.coeff (p $ n) m))) m $ n"
+ by (simp add: fps_poly_swap2_def)
+ also have "\<dots> = Abs_fps (\<lambda>n. poly.coeff (p $ n) m) $ n"
+ using ev by (subst poly.Abs_poly_inverse) auto
+ finally show "fps_nth (coeff (fps_poly_swap2 p) m) n = coeff (fps_nth p n) m"
+ by simp
+qed
+
+lemma degree_fps_poly_swap2_le:
+ assumes "\<And>n. degree (fps_nth p n) \<le> d"
+ shows "degree (fps_poly_swap2 p) \<le> d"
+proof (safe intro!: degree_le)
+ fix n assume "n > d"
+ show "poly.coeff (fps_poly_swap2 p) n = 0"
+ proof (rule fps_ext)
+ fix m
+ have "poly.coeff (fps_poly_swap2 p) n $ m = poly.coeff (p $ m) n"
+ by (subst fps_nth_coeff_fps_poly_swap2[OF assms]) auto
+ also have "\<dots> = 0"
+ by (intro coeff_eq_0 le_less_trans[OF assms \<open>n > d\<close>])
+ finally show "poly.coeff (fps_poly_swap2 p) n $ m = 0 $ m"
+ by simp
+ qed
+qed
+
+lemma degree_fps_poly_swap2_eq:
+ assumes "\<And>n. degree (fps_nth p n) \<le> d"
+ assumes "d > 0 \<or> fps_nth p n \<noteq> 0"
+ assumes "degree (fps_nth p n) = d"
+ shows "degree (fps_poly_swap2 p) = d"
+proof (rule antisym)
+ have "fps_nth (coeff (fps_poly_swap2 p) d) n = poly.coeff (fps_nth p n) d"
+ by (subst fps_nth_coeff_fps_poly_swap2[OF assms(1)]) auto
+ also have "\<dots> \<noteq> 0"
+ using assms(2,3) by force
+ finally have "coeff (fps_poly_swap2 p) d \<noteq> 0"
+ by force
+ thus "degree (fps_poly_swap2 p) \<ge> d"
+ using le_degree by blast
+next
+ show "degree (fps_poly_swap2 p) \<le> d"
+ by (intro degree_fps_poly_swap2_le) fact
+qed
+
+definition reduce_fps_poly :: "'a :: zero fps poly \<Rightarrow> 'a poly" where
+ "reduce_fps_poly F = fps_nth (fps_poly_swap1 F) 0"
+
+lemma
+ fixes F :: "'a :: field fps poly"
+ assumes "lead_coeff F = 1"
+ shows degree_reduce_fps_poly_monic: "degree (reduce_fps_poly F) = degree F"
+ and reduce_fps_poly_monic: "lead_coeff (reduce_fps_poly F) = 1"
+proof -
+ have eq1: "coeff (reduce_fps_poly F) (degree F) = 1"
+ unfolding reduce_fps_poly_def by (simp add: assms)
+ have eq2: "coeff (reduce_fps_poly F) n = 0" if "n > degree F" for n
+ unfolding reduce_fps_poly_def using that by (simp add: coeff_eq_0)
+
+ have "degree (reduce_fps_poly F) \<le> degree F"
+ by (rule degree_le) (auto simp: eq2)
+ moreover have "degree (reduce_fps_poly F) \<ge> degree F"
+ by (rule le_degree) (simp add: eq1)
+ from eq1 eq2 show "degree (reduce_fps_poly F) = degree F"
+ by (intro antisym le_degree degree_le) auto
+ with eq1 show "lead_coeff (reduce_fps_poly F) = 1"
+ by simp
+qed
+
+locale fps_hensel_aux =
+ fixes F :: "'a :: field_gcd poly fps"
+ fixes g h :: "'a poly"
+ assumes coprime: "coprime g h" and deg_g: "degree g > 0" and deg_h: "degree h > 0"
+begin
+
+context
+ fixes g' h' :: "'a poly"
+ defines "h' \<equiv> fst (bezout_coefficients g h)" and "g' \<equiv> snd (bezout_coefficients g h)"
+begin
+
+fun hensel_fpxs_aux :: "nat \<Rightarrow> 'a poly \<times> 'a poly" where
+ "hensel_fpxs_aux n = (if n = 0 then (g, h) else
+ (let
+ U = fps_nth F n -
+ (\<Sum>(i,j) | i < n \<and> j < n \<and> i + j = n. fst (hensel_fpxs_aux i) * snd (hensel_fpxs_aux j))
+ in (U * g' + g * ((U * h') div h), (U * h') mod h)))"
+
+lemmas [simp del] = hensel_fpxs_aux.simps
+
+lemma hensel_fpxs_aux_0 [simp]: "hensel_fpxs_aux 0 = (g, h)"
+ by (subst hensel_fpxs_aux.simps) auto
+
+definition hensel_fpxs1 :: "'a poly fps"
+ where "hensel_fpxs1 = Abs_fps (fst \<circ> hensel_fpxs_aux)"
+
+definition hensel_fpxs2 :: "'a poly fps"
+ where "hensel_fpxs2 = Abs_fps (snd \<circ> hensel_fpxs_aux)"
+
+lemma hensel_fpxs1_0 [simp]: "hensel_fpxs1 $ 0 = g"
+ by (simp add: hensel_fpxs1_def)
+
+lemma hensel_fpxs2_0 [simp]: "hensel_fpxs2 $ 0 = h"
+ by (simp add: hensel_fpxs2_def)
+
+theorem fps_hensel_aux:
+ defines "f \<equiv> fps_nth F 0"
+ assumes "f = g * h"
+ assumes "\<forall>n>0. degree (fps_nth F n) < degree f"
+ defines "G \<equiv> hensel_fpxs1" and "H \<equiv> hensel_fpxs2"
+ shows "F = G * H" "fps_nth G 0 = g" "fps_nth H 0 = h"
+ "\<forall>n>0. degree (fps_nth G n) < degree g"
+ "\<forall>n>0. degree (fps_nth H n) < degree h"
+proof -
+ show "fps_nth G 0 = g" "fps_nth H 0 = h"
+ by (simp_all add: G_def H_def hensel_fpxs1_def hensel_fpxs2_def)
+
+ have deg_f: "degree f = degree g + degree h"
+ unfolding \<open>f = g * h\<close> using assms by (intro degree_mult_eq) auto
+
+ have deg_H: "degree (fps_nth H n) < degree h" if \<open>n > 0\<close> for n
+ proof (cases "snd (hensel_fpxs_aux n) = 0")
+ case False
+ thus ?thesis
+ using deg_h \<open>n > 0\<close>
+ by (auto simp: hensel_fpxs_aux.simps[of n] hensel_fpxs2_def H_def intro: degree_mod_less')
+ qed (use assms deg_h in \<open>auto simp: hensel_fpxs2_def\<close>)
+ thus "\<forall>n>0. degree (fps_nth H n) < degree h"
+ by blast
+
+ have *: "fps_nth F n = fps_nth (G * H) n \<and> (n > 0 \<longrightarrow> degree (fps_nth G n) < degree g)" for n
+ proof (induction n rule: less_induct)
+ case (less n)
+ have fin: "finite {p. fst p < n \<and> snd p < n \<and> fst p + snd p = n}"
+ by (rule finite_subset[of _ "{..n} \<times> {..n}"]) auto
+ show ?case
+ proof (cases "n = 0")
+ case True
+ thus ?thesis using assms
+ by (auto simp: hensel_fpxs1_def hensel_fpxs2_def)
+ next
+ case False
+ define U where "U = fps_nth F n -
+ (\<Sum>(i,j) | i < n \<and> j < n \<and> i + j = n. fst (hensel_fpxs_aux i) * snd (hensel_fpxs_aux j))"
+ define g'' h'' where "g'' = U * g'" and "h'' = U * h'"
+
+ have "fps_nth (G * H) n =
+ (\<Sum>i=0..n. fst (hensel_fpxs_aux i) * snd (hensel_fpxs_aux (n - i)))"
+ using assms by (auto simp: hensel_fpxs1_def hensel_fpxs2_def fps_mult_nth)
+ also have "\<dots> = (\<Sum>(i,j) | i + j = n. fst (hensel_fpxs_aux i) * snd (hensel_fpxs_aux j))"
+ by (rule sum.reindex_bij_witness[of _ fst "\<lambda>i. (i, n - i)"]) auto
+ also have "{(i,j). i + j = n} = {(i,j). i < n \<and> j < n \<and> i + j = n} \<union> {(n,0), (0,n)}"
+ by auto
+ also have "(\<Sum>(i,j)\<in>\<dots>. fst (hensel_fpxs_aux i) * snd (hensel_fpxs_aux j)) =
+ fps_nth F n - U + (fst (hensel_fpxs_aux n) * h + g * snd (hensel_fpxs_aux n))"
+ using False fin by (subst sum.union_disjoint) (auto simp: case_prod_unfold U_def)
+ also have eq: "fst (hensel_fpxs_aux n) * h + g * snd (hensel_fpxs_aux n) = U"
+ proof -
+ have "fst (hensel_fpxs_aux n) * h + g * snd (hensel_fpxs_aux n) =
+ (g'' + g * (h'' div h)) * h + g * (h'' mod h)"
+ using False by (simp add: hensel_fpxs_aux.simps[of n] U_def g''_def h''_def)
+ also have "h'' mod h = h'' - (h'' div h) * h"
+ by (simp add: minus_div_mult_eq_mod)
+ also have "(g'' + g * (h'' div h)) * h + g * (h'' - h'' div h * h) = g * h'' + g'' * h"
+ by (simp add: algebra_simps)
+ also have "\<dots> = U * (h' * g + g' * h)"
+ by (simp add: algebra_simps g''_def h''_def)
+ also have "h' * g + g' * h = gcd g h"
+ unfolding g'_def h'_def by (rule bezout_coefficients_fst_snd)
+ also have "gcd g h = 1"
+ using coprime by simp
+ finally show ?thesis by simp
+ qed
+ finally have "fps_nth F n = fps_nth (G * H) n" by simp
+
+ have "degree (G $ n) < degree g"
+ proof (cases "G $ n = 0")
+ case False
+ have "degree (G $ n) + degree h = degree (G $ n * h)"
+ using False assms by (intro degree_mult_eq [symmetric]) auto
+ also from eq have "fps_nth G n * h = U - g * snd (hensel_fpxs_aux n)"
+ by (simp add: algebra_simps G_def hensel_fpxs1_def)
+ hence "degree (fps_nth G n * h) = degree (U - g * snd (hensel_fpxs_aux n))"
+ by (simp only: )
+ also have "\<dots> < degree f"
+ proof (intro degree_diff_less)
+ have "degree (g * snd (local.hensel_fpxs_aux n)) \<le>
+ degree g + degree (snd (local.hensel_fpxs_aux n))"
+ by (intro degree_mult_le)
+ also have "degree (snd (local.hensel_fpxs_aux n)) < degree h"
+ using deg_H[of n] \<open>n \<noteq> 0\<close> by (auto simp: H_def hensel_fpxs2_def)
+ also have "degree g + degree h = degree f"
+ by (subst deg_f) auto
+ finally show "degree (g * snd (local.hensel_fpxs_aux n)) < degree f"
+ by simp
+ next
+ show "degree U < degree f"
+ unfolding U_def
+ proof (intro degree_diff_less degree_sum_less)
+ show "degree (F $ n) < degree f"
+ using \<open>n \<noteq> 0\<close> assms by auto
+ next
+ show "degree f > 0"
+ unfolding deg_f using deg_g by simp
+ next
+ fix z assume z: "z \<in> {(i, j). i < n \<and> j < n \<and> i + j = n}"
+ have "degree (case z of (i, j) \<Rightarrow> fst (hensel_fpxs_aux i) * snd (hensel_fpxs_aux j)) =
+ degree (fps_nth G (fst z) * fps_nth H (snd z))" (is "?lhs = _")
+ by (simp add: case_prod_unfold G_def H_def hensel_fpxs1_def hensel_fpxs2_def)
+ also have "\<dots> \<le> degree (fps_nth G (fst z)) + degree (fps_nth H (snd z))"
+ by (intro degree_mult_le)
+ also have "\<dots> < degree g + degree h"
+ using z less.IH[of "fst z"]
+ by (intro add_strict_mono deg_H) (simp_all add: case_prod_unfold)
+ finally show "?lhs < degree f"
+ by (simp add: deg_f)
+ qed
+ qed
+ finally show ?thesis
+ by (simp add: deg_f)
+ qed (use deg_g in auto)
+
+ with \<open>fps_nth F n = fps_nth (G * H) n\<close> show ?thesis
+ by blast
+ qed
+ qed
+
+ from * show "F = G * H" and "\<forall>n>0. degree (fps_nth G n) < degree g"
+ by (auto simp: fps_eq_iff)
+qed
+
+end
+
+end
+
+
+locale fps_hensel =
+ fixes F :: "'a :: field_gcd fps poly" and f g h :: "'a poly"
+ assumes monic: "lead_coeff F = 1"
+ defines "f \<equiv> reduce_fps_poly F"
+ assumes f_splits: "f = g * h"
+ assumes coprime: "coprime g h" and deg_g: "degree g > 0" and deg_h: "degree h > 0"
+begin
+
+definition F' where "F' = fps_poly_swap1 F"
+
+sublocale fps_hensel_aux F' g h
+ by unfold_locales (fact deg_g deg_h coprime)+
+
+
+definition G where
+ "G = fps_poly_swap2 hensel_fpxs1"
+
+definition H where
+ "H = fps_poly_swap2 hensel_fpxs2"
+
+lemma deg_f: "degree f = degree F"
+proof (intro antisym)
+ have "coeff f (degree F) \<noteq> 0"
+ using monic by (simp add: f_def reduce_fps_poly_def)
+ thus "degree f \<ge> (degree F)"
+ by (rule le_degree)
+next
+ have "coeff f n = 0" if "n > degree F" for n
+ using that by (simp add: f_def reduce_fps_poly_def coeff_eq_0)
+ thus "degree f \<le> degree F"
+ using degree_le by blast
+qed
+
+lemma
+ F_splits: "F = G * H" and
+ reduce_G: "reduce_fps_poly G = g" and
+ reduce_H: "reduce_fps_poly H = h" and
+ deg_G: "degree G = degree g" and
+ deg_H: "degree H = degree h" and
+ lead_coeff_G: "lead_coeff G = fps_const (lead_coeff g)" and
+ lead_coeff_H: "lead_coeff H = fps_const (lead_coeff h)"
+proof -
+ from deg_g deg_h have [simp]: "g \<noteq> 0" "h \<noteq> 0"
+ by auto
+ define N where "N = degree F"
+
+ have deg_f: "degree f = N"
+ proof (intro antisym)
+ have "coeff f N \<noteq> 0"
+ using monic by (simp add: f_def reduce_fps_poly_def N_def)
+ thus "degree f \<ge> N"
+ by (rule le_degree)
+ next
+ have "coeff f n = 0" if "n > N" for n
+ using that by (simp add: f_def reduce_fps_poly_def N_def coeff_eq_0)
+ thus "degree f \<le> N"
+ using degree_le by blast
+ qed
+
+ have "F' $ 0 = f"
+ unfolding F'_def f_def reduce_fps_poly_def ..
+ have F'0: "F' $ 0 = g * h"
+ using f_splits by (simp add: F'_def f_def reduce_fps_poly_def)
+
+ have "\<forall>n>0. degree (F' $ n) < N"
+ proof (subst F'_def, intro allI impI degree_lessI)
+ fix n :: nat
+ assume n: "n > 0"
+ show "fps_poly_swap1 F $ n \<noteq> 0 \<or> 0 < N"
+ using n deg_g deg_h f_splits deg_f by (auto simp: F'0 degree_mult_eq)
+ fix k
+ assume k: "k \<ge> N"
+ have "coeff (F' $ n) k = coeff F k $ n"
+ unfolding F'_def by simp
+ also have "\<dots>= 0"
+ using monic \<open>n > 0\<close> k by (cases "k > N") (auto simp: N_def coeff_eq_0)
+ finally show "coeff (fps_poly_swap1 F $ n) k = 0"
+ by (simp add: F'_def)
+ qed
+ hence degs_less: "\<forall>n>0. degree (F' $ n) < degree (F' $ 0)"
+ by (simp add: \<open>F' $ 0 = f\<close> deg_f)
+ note hensel = fps_hensel_aux[OF F'0 degs_less]
+
+ have deg_less1: "degree (hensel_fpxs1 $ n) < degree g" if "n > 0" for n
+ using hensel(4) that by (simp add: F'_def)
+ have deg_le1: "degree (hensel_fpxs1 $ n) \<le> degree g" for n
+ proof (cases "n = 0")
+ case True
+ hence "hensel_fpxs1 $ n = g"
+ by (simp add: hensel_fpxs1_def)
+ thus ?thesis by simp
+ qed (auto intro: less_imp_le deg_less1 simp: f_def)
+
+ have deg_less2: "degree (hensel_fpxs2 $ n) < degree h" if "n > 0" for n
+ using hensel(5) that by (simp add: F'_def)
+ have deg_le2: "degree (hensel_fpxs2 $ n) \<le> degree h" for n
+ proof (cases "n = 0")
+ case True
+ hence "hensel_fpxs2 $ n = h"
+ by (simp add: hensel_fpxs2_def)
+ thus ?thesis by simp
+ qed (auto intro: less_imp_le deg_less2 simp: f_def)
+
+ show "F = G * H"
+ unfolding poly_eq_iff fps_eq_iff
+ proof safe
+ fix n k
+ have "poly.coeff F n $ k = poly.coeff (F' $ k) n"
+ unfolding F'_def by simp
+ also have "F' = hensel_fpxs1 * hensel_fpxs2"
+ by (rule hensel)
+ also have "\<dots> $ k = (\<Sum>i=0..k. hensel_fpxs1 $ i * hensel_fpxs2 $ (k - i))"
+ unfolding fps_mult_nth ..
+ also have "poly.coeff \<dots> n =
+ (\<Sum>i=0..k. \<Sum>j\<le>n. coeff (hensel_fpxs1 $ i) j * coeff (hensel_fpxs2 $ (k - i)) (n - j))"
+ by (simp add: coeff_sum coeff_mult)
+ also have "(\<lambda>i j. coeff (hensel_fpxs1 $ i) j) = (\<lambda>i j. coeff G j $ i)"
+ unfolding G_def
+ by (subst fps_nth_coeff_fps_poly_swap2[OF deg_le1]) (auto simp: F'_def)
+ also have "(\<lambda>i j. coeff (hensel_fpxs2 $ i) j) = (\<lambda>i j. coeff H j $ i)"
+ unfolding H_def
+ by (subst fps_nth_coeff_fps_poly_swap2[OF deg_le2]) (auto simp: F'_def)
+ also have "(\<Sum>i=0..k. \<Sum>j\<le>n. poly.coeff G j $ i * poly.coeff H (n - j) $ (k - i)) =
+ (\<Sum>j\<le>n. \<Sum>i=0..k. poly.coeff G j $ i * poly.coeff H (n - j) $ (k - i))"
+ by (rule sum.swap)
+ also have "\<dots> = poly.coeff (G * H) n $ k"
+ by (simp add: coeff_mult fps_mult_nth fps_sum_nth)
+ finally show "poly.coeff F n $ k = poly.coeff (G * H) n $ k" .
+ qed
+
+ show "reduce_fps_poly G = g" unfolding G_def reduce_fps_poly_def poly_eq_iff
+ by (auto simp: fps_nth_coeff_fps_poly_swap2[OF deg_le1])
+ show "reduce_fps_poly H = h" unfolding H_def reduce_fps_poly_def poly_eq_iff
+ by (auto simp: fps_nth_coeff_fps_poly_swap2[OF deg_le2])
+ show "degree G = degree g" unfolding G_def
+ by (rule degree_fps_poly_swap2_eq[where n = 0] deg_le1 disjI1 deg_g deg_le2)+ simp_all
+ show "degree H = degree h" unfolding H_def
+ by (rule degree_fps_poly_swap2_eq[where n = 0] deg_le1 disjI1 deg_h deg_le2)+ simp_all
+
+ show "lead_coeff G = fps_const (lead_coeff g)"
+ proof (rule fps_ext)
+ fix n ::nat
+ have "lead_coeff G $ n = coeff (hensel_fpxs1 $ n) (degree G)"
+ by (subst G_def, subst fps_nth_coeff_fps_poly_swap2[OF deg_le1]) auto
+ also have "\<dots> = (if n = 0 then lead_coeff g else 0)"
+ by (auto simp: \<open>degree G = degree g\<close> intro: coeff_eq_0 deg_less1)
+ finally show "lead_coeff G $ n = fps_const (lead_coeff g) $ n"
+ by simp
+ qed
+
+ show "lead_coeff H = fps_const (lead_coeff h)"
+ proof (rule fps_ext)
+ fix n ::nat
+ have "lead_coeff H $ n = coeff (hensel_fpxs2 $ n) (degree H)"
+ by (subst H_def, subst fps_nth_coeff_fps_poly_swap2[OF deg_le2]) auto
+ also have "\<dots> = (if n = 0 then lead_coeff h else 0)"
+ by (auto simp: \<open>degree H = degree h\<close> intro: coeff_eq_0 deg_less2)
+ finally show "lead_coeff H $ n = fps_const (lead_coeff h) $ n"
+ by simp
+ qed
+qed
+
+end
+
+end
\ No newline at end of file
diff --git a/thys/Formal_Puiseux_Series/Formal_Puiseux_Series.thy b/thys/Formal_Puiseux_Series/Formal_Puiseux_Series.thy
new file mode 100644
--- /dev/null
+++ b/thys/Formal_Puiseux_Series/Formal_Puiseux_Series.thy
@@ -0,0 +1,1824 @@
+(*
+ File: Formal_Puiseux_Series.thy
+ Author: Manuel Eberl, TU München
+*)
+section \<open>Formal Puiseux Series\<close>
+theory Formal_Puiseux_Series
+ imports Puiseux_Laurent_Library FPS_Hensel
+begin
+
+subsection \<open>Auxiliary facts and definitions\<close>
+
+lemma div_dvd_self:
+ fixes a b :: "'a :: {semidom_divide}"
+ shows "b dvd a \<Longrightarrow> a div b dvd a"
+ by (elim dvdE; cases "b = 0") simp_all
+
+lemma quotient_of_int [simp]: "quotient_of (of_int n) = (n, 1)"
+ using Rat.of_int_def quotient_of_int by auto
+
+lemma of_int_div_of_int_in_Ints_iff:
+ "(of_int n / of_int m :: 'a :: field_char_0) \<in> \<int> \<longleftrightarrow> m = 0 \<or> m dvd n"
+proof
+ assume *: "(of_int n / of_int m :: 'a) \<in> \<int>"
+ {
+ assume "m \<noteq> 0"
+ from * obtain k where k: "(of_int n / of_int m :: 'a) = of_int k"
+ by (auto elim!: Ints_cases)
+ hence "of_int n = (of_int k * of_int m :: 'a)"
+ using \<open>m \<noteq> 0\<close> by (simp add: field_simps)
+ also have "\<dots> = of_int (k * m)"
+ by simp
+ finally have "n = k * m"
+ by (subst (asm) of_int_eq_iff)
+ hence "m dvd n" by auto
+ }
+ thus "m = 0 \<or> m dvd n" by blast
+qed auto
+
+lemma rat_eq_quotientD:
+ assumes "r = rat_of_int a / rat_of_int b" "b \<noteq> 0"
+ shows "fst (quotient_of r) dvd a" "snd (quotient_of r) dvd b"
+proof -
+ define a' b' where "a' = fst (quotient_of r)" and "b' = snd (quotient_of r)"
+ define d where "d = gcd a b"
+ have "b' > 0"
+ by (auto simp: b'_def quotient_of_denom_pos')
+
+ have "coprime a' b'"
+ by (rule quotient_of_coprime[of r]) (simp add: a'_def b'_def)
+ have r: "r = rat_of_int a' / rat_of_int b'"
+ by (simp add: a'_def b'_def quotient_of_div)
+ from assms \<open>b' > 0\<close> have "rat_of_int (a' * b) = rat_of_int (a * b')"
+ unfolding of_int_mult by (simp add: field_simps r)
+ hence eq: "a' * b = a * b'"
+ by (subst (asm) of_int_eq_iff)
+
+ have "a' dvd a * b'"
+ by (simp flip: eq)
+ hence "a' dvd a"
+ by (subst (asm) coprime_dvd_mult_left_iff) fact
+ moreover have "b' dvd a' * b"
+ by (simp add: eq)
+ hence "b' dvd b"
+ by (subst (asm) coprime_dvd_mult_right_iff) (use \<open>coprime a' b'\<close> in \<open>simp add: coprime_commute\<close>)
+ ultimately show "fst (quotient_of r) dvd a" "snd (quotient_of r) dvd b"
+ unfolding a'_def b'_def by blast+
+qed
+
+lemma quotient_of_denom_add_dvd:
+ "snd (quotient_of (x + y)) dvd snd (quotient_of x) * snd (quotient_of y)"
+proof -
+ define a b where "a = fst (quotient_of x)" and "b = snd (quotient_of x)"
+ define c d where "c = fst (quotient_of y)" and "d = snd (quotient_of y)"
+ have "b > 0" "d > 0"
+ by (auto simp: b_def d_def quotient_of_denom_pos')
+ have xy: "x = rat_of_int a / rat_of_int b" "y = rat_of_int c / rat_of_int d"
+ unfolding a_def b_def c_def d_def by (simp_all add: quotient_of_div)
+
+ show "snd (quotient_of (x + y)) dvd b * d"
+ proof (rule rat_eq_quotientD)
+ show "x + y = rat_of_int (a * d + c * b) / rat_of_int (b * d)"
+ using \<open>b > 0\<close> \<open>d > 0\<close> by (simp add: field_simps xy)
+ qed (use \<open>b > 0\<close> \<open>d > 0\<close> in auto)
+qed
+
+lemma quotient_of_denom_diff_dvd:
+ "snd (quotient_of (x - y)) dvd snd (quotient_of x) * snd (quotient_of y)"
+ using quotient_of_denom_add_dvd[of x "-y"]
+ by (simp add: rat_uminus_code Let_def case_prod_unfold)
+
+
+definition supp :: "('a \<Rightarrow> ('b :: zero)) \<Rightarrow> 'a set" where
+ "supp f = f -` (-{0})"
+
+lemma supp_0 [simp]: "supp (\<lambda>_. 0) = {}"
+ and supp_const: "supp (\<lambda>_. c) = (if c = 0 then {} else UNIV)"
+ and supp_singleton [simp]: "c \<noteq> 0 \<Longrightarrow> supp (\<lambda>x. if x = d then c else 0) = {d}"
+ by (auto simp: supp_def)
+
+lemma supp_uminus [simp]: "supp (\<lambda>x. -f x :: 'a :: group_add) = supp f"
+ by (auto simp: supp_def)
+
+
+subsection \<open>Definition\<close>
+
+text \<open>
+ Similarly to formal power series $R[[X]]$ and formal Laurent series $R((X))$, we define the ring
+ of formal Puiseux series $R\{\{X\}\}$ as functions from the rationals into a ring such that
+
+ \<^enum> the support is bounded from below, and
+
+ \<^enum> the denominators of the numbers in the support have a common multiple other than 0
+
+ One can also think of a formal Puiseux series in the paramter $X$ as a formal Laurent series
+ in the parameter $X^{1/d}$ for some positive integer $d$. This is often written in the
+ following suggestive notation:
+ \[ R\{\{X\}\} = \bigcup_{d\geq 1} R((X^{1/d})) \]
+
+ Many operations will be defined in terms of this correspondence between Puiseux and Laurent
+ series, and many of the simple properties proven that way.
+\<close>
+
+definition is_fpxs :: "(rat \<Rightarrow> 'a :: zero) \<Rightarrow> bool" where
+ "is_fpxs f \<longleftrightarrow> bdd_below (supp f) \<and> (LCM r\<in>supp f. snd (quotient_of r)) \<noteq> 0"
+
+typedef (overloaded) 'a fpxs = "{f::rat \<Rightarrow> 'a :: zero. is_fpxs f}"
+ morphisms fpxs_nth Abs_fpxs
+ by (rule exI[of _ "\<lambda>_. 0"]) (auto simp: is_fpxs_def supp_def)
+
+setup_lifting type_definition_fpxs
+
+lemma fpxs_ext: "(\<And>r. fpxs_nth f r = fpxs_nth g r) \<Longrightarrow> f = g"
+ by transfer auto
+
+lemma fpxs_eq_iff: "f = g \<longleftrightarrow> (\<forall>r. fpxs_nth f r = fpxs_nth g r)"
+ by transfer auto
+
+lift_definition fpxs_supp :: "'a :: zero fpxs \<Rightarrow> rat set" is supp .
+
+lemma fpxs_supp_altdef: "fpxs_supp f = {x. fpxs_nth f x \<noteq> 0}"
+ by transfer (auto simp: supp_def)
+
+
+text \<open>
+ The following gives us the ``root order'' of \<open>f\<close>i, i.e. the smallest positive integer \<open>d\<close>
+ such that \<open>f\<close> is in $R((X^{1/p}))$.
+\<close>
+lift_definition fpxs_root_order :: "'a :: zero fpxs \<Rightarrow> nat" is
+ "\<lambda>f. nat (LCM r\<in>supp f. snd (quotient_of r))" .
+
+lemma fpxs_root_order_pos [simp]: "fpxs_root_order f > 0"
+proof transfer
+ fix f :: "rat \<Rightarrow> 'a" assume f: "is_fpxs f"
+ hence "(LCM r\<in>supp f. snd (quotient_of r)) \<noteq> 0"
+ by (auto simp: is_fpxs_def)
+ moreover have "(LCM r\<in>supp f. snd (quotient_of r)) \<ge> 0"
+ by simp
+ ultimately show "nat (LCM r\<in>supp f. snd (quotient_of r)) > 0"
+ by linarith
+qed
+
+lemma fpxs_root_order_nonzero [simp]: "fpxs_root_order f \<noteq> 0"
+ using fpxs_root_order_pos[of f] by linarith
+
+
+text \<open>
+ Let \<open>d\<close> denote the root order of a Puiseux series \<open>f\<close>, i.e. the smallest number \<open>d\<close> such that
+ all monomials with non-zero coefficients can be written in the form $X^{n/d}$ for some \<open>n\<close>.
+ Then \<open>f\<close> can be written as a Laurent series in \<open>X^{1/d}\<close>. The following operation gives us
+ this Laurent series.
+\<close>
+lift_definition fls_of_fpxs :: "'a :: zero fpxs \<Rightarrow> 'a fls" is
+ "\<lambda>f n. f (of_int n / of_int (LCM r\<in>supp f. snd (quotient_of r)))"
+proof -
+ fix f :: "rat \<Rightarrow> 'a"
+ assume f: "is_fpxs f"
+ hence "bdd_below (supp f)"
+ by (auto simp: is_fpxs_def)
+ then obtain r0 where "\<forall>x\<in>supp f. r0 \<le> x"
+ by (auto simp: bdd_below_def)
+ hence r0: "f x = 0" if "x < r0" for x
+ using that by (auto simp: supp_def vimage_def)
+ define d :: int where "d = (LCM r\<in>supp f. snd (quotient_of r))"
+ have "d \<ge> 0" by (simp add: d_def)
+ moreover have "d \<noteq> 0"
+ using f by (auto simp: d_def is_fpxs_def)
+ ultimately have "d > 0" by linarith
+
+ have *: "f (of_int n / of_int d) = 0" if "n < \<lfloor>r0 * of_int d\<rfloor>" for n
+ proof -
+ have "rat_of_int n < r0 * rat_of_int d"
+ using that by linarith
+ thus ?thesis
+ using \<open>d > 0\<close> by (intro r0) (auto simp: field_simps)
+ qed
+ have "eventually (\<lambda>n. n > -\<lfloor>r0 * of_int d\<rfloor>) at_top"
+ by (rule eventually_gt_at_top)
+ hence "eventually (\<lambda>n. f (of_int (-n) / of_int d) = 0) at_top"
+ by (eventually_elim) (rule *, auto)
+ hence "eventually (\<lambda>n. f (of_int (-int n) / of_int d) = 0) at_top"
+ by (rule eventually_compose_filterlim) (rule filterlim_int_sequentially)
+ thus "eventually (\<lambda>n. f (of_int (-int n) / of_int d) = 0) cofinite"
+ by (simp add: cofinite_eq_sequentially)
+qed
+
+lemma fls_nth_of_fpxs:
+ "fls_nth (fls_of_fpxs f) n = fpxs_nth f (of_int n / of_nat (fpxs_root_order f))"
+ by transfer simp
+
+
+subsection \<open>Basic algebraic typeclass instances\<close>
+
+instantiation fpxs :: (zero) zero
+begin
+
+lift_definition zero_fpxs :: "'a fpxs" is "\<lambda>r::rat. 0 :: 'a"
+ by (auto simp: is_fpxs_def supp_def)
+
+instance ..
+
+end
+
+instantiation fpxs :: ("{one, zero}") one
+begin
+
+lift_definition one_fpxs :: "'a fpxs" is "\<lambda>r::rat. if r = 0 then 1 else 0 :: 'a"
+ by (cases "(1 :: 'a) = 0") (auto simp: is_fpxs_def cong: if_cong)
+
+instance ..
+
+end
+
+lemma fls_of_fpxs_0 [simp]: "fls_of_fpxs 0 = 0"
+ by transfer auto
+
+lemma fpxs_nth_0 [simp]: "fpxs_nth 0 r = 0"
+ by transfer auto
+
+lemma fpxs_nth_1: "fpxs_nth 1 r = (if r = 0 then 1 else 0)"
+ by transfer auto
+
+lemma fpxs_nth_1': "fpxs_nth 1 0 = 1" "r \<noteq> 0 \<Longrightarrow> fpxs_nth 1 r = 0"
+ by (auto simp: fpxs_nth_1)
+
+instantiation fpxs :: (monoid_add) monoid_add
+begin
+
+lift_definition plus_fpxs :: "'a fpxs \<Rightarrow> 'a fpxs \<Rightarrow> 'a fpxs" is
+ "\<lambda>f g x. f x + g x"
+proof -
+ fix f g :: "rat \<Rightarrow> 'a"
+ assume fg: "is_fpxs f" "is_fpxs g"
+ show "is_fpxs (\<lambda>x. f x + g x)"
+ unfolding is_fpxs_def
+ proof
+ have supp: "supp (\<lambda>x. f x + g x) \<subseteq> supp f \<union> supp g"
+ by (auto simp: supp_def)
+ show "bdd_below (supp (\<lambda>x. f x + g x))"
+ by (rule bdd_below_mono[OF _ supp]) (use fg in \<open>auto simp: is_fpxs_def\<close>)
+ have "(LCM r\<in>supp (\<lambda>x. f x + g x). snd (quotient_of r)) dvd
+ (LCM r\<in>supp f \<union> supp g. snd (quotient_of r))"
+ by (intro Lcm_subset image_mono supp)
+ also have "\<dots> = lcm (LCM r\<in>supp f. snd (quotient_of r)) (LCM r\<in>supp g. snd (quotient_of r))"
+ unfolding image_Un Lcm_Un ..
+ finally have "(LCM r\<in>supp (\<lambda>x. f x + g x). snd (quotient_of r)) dvd
+ lcm (LCM r\<in>supp f. snd (quotient_of r)) (LCM r\<in>supp g. snd (quotient_of r))" .
+ moreover have "lcm (LCM r\<in>supp f. snd (quotient_of r)) (LCM r\<in>supp g. snd (quotient_of r)) \<noteq> 0"
+ using fg by (auto simp: is_fpxs_def)
+ ultimately show "(LCM r\<in>supp (\<lambda>x. f x + g x). snd (quotient_of r)) \<noteq> 0"
+ by auto
+ qed
+qed
+
+instance
+ by standard (transfer; simp add: algebra_simps fun_eq_iff)+
+
+end
+
+instance fpxs :: (comm_monoid_add) comm_monoid_add
+proof
+ fix f g :: "'a fpxs"
+ show "f + g = g + f"
+ by transfer (auto simp: add_ac)
+qed simp_all
+
+lemma fpxs_nth_add [simp]: "fpxs_nth (f + g) r = fpxs_nth f r + fpxs_nth g r"
+ by transfer auto
+
+lift_definition fpxs_of_fls :: "'a :: zero fls \<Rightarrow> 'a fpxs" is
+ "\<lambda>f r. if r \<in> \<int> then f \<lfloor>r\<rfloor> else 0"
+proof -
+ fix f :: "int \<Rightarrow> 'a"
+ assume "eventually (\<lambda>n. f (-int n) = 0) cofinite"
+ hence "eventually (\<lambda>n. f (-int n) = 0) at_top"
+ by (simp add: cofinite_eq_sequentially)
+ then obtain N where N: "f (-int n) = 0" if "n \<ge> N" for n
+ by (auto simp: eventually_at_top_linorder)
+
+ show "is_fpxs (\<lambda>r. if r \<in> \<int> then f \<lfloor>r\<rfloor> else 0)"
+ unfolding is_fpxs_def
+ proof
+ have "bdd_below {-(of_nat N::rat)..}"
+ by simp
+ moreover have "supp (\<lambda>r::rat. if r \<in> \<int> then f \<lfloor>r\<rfloor> else 0) \<subseteq> {-of_nat N..}"
+ proof
+ fix r :: rat assume "r \<in> supp (\<lambda>r. if r \<in> \<int> then f \<lfloor>r\<rfloor> else 0)"
+ then obtain m where [simp]: "r = of_int m" "f m \<noteq> 0"
+ by (auto simp: supp_def elim!: Ints_cases split: if_splits)
+ have "m \<ge> -int N"
+ using N[of "nat (-m)"] by (cases "m \<ge> 0"; cases "-int N \<le> m") (auto simp: le_nat_iff)
+ thus "r \<in> {-of_nat N..}" by simp
+ qed
+ ultimately show "bdd_below (supp (\<lambda>r::rat. if r \<in> \<int> then f \<lfloor>r\<rfloor> else 0))"
+ by (rule bdd_below_mono)
+ next
+ have "(LCM r\<in>supp (\<lambda>r. if r \<in> \<int> then f \<lfloor>r\<rfloor> else 0). snd (quotient_of r)) dvd 1"
+ by (intro Lcm_least) (auto simp: supp_def elim!: Ints_cases split: if_splits)
+ thus "(LCM r\<in>supp (\<lambda>r. if r \<in> \<int> then f \<lfloor>r\<rfloor> else 0). snd (quotient_of r)) \<noteq> 0"
+ by (intro notI) simp
+ qed
+qed
+
+instantiation fpxs :: (group_add) group_add
+begin
+
+lift_definition uminus_fpxs :: "'a fpxs \<Rightarrow> 'a fpxs" is "\<lambda>f x. -f x"
+ by (auto simp: is_fpxs_def)
+
+definition minus_fpxs :: "'a fpxs \<Rightarrow> 'a fpxs \<Rightarrow> 'a fpxs" where
+ "minus_fpxs f g = f + (-g)"
+
+instance proof
+ fix f :: "'a fpxs"
+ show "-f + f = 0"
+ by transfer auto
+qed (auto simp: minus_fpxs_def)
+
+end
+
+lemma fpxs_nth_uminus [simp]: "fpxs_nth (-f) r = -fpxs_nth f r"
+ by transfer auto
+
+lemma fpxs_nth_minus [simp]: "fpxs_nth (f - g) r = fpxs_nth f r - fpxs_nth g r"
+ unfolding minus_fpxs_def fpxs_nth_add fpxs_nth_uminus by simp
+
+lemma fpxs_of_fls_eq_iff [simp]: "fpxs_of_fls f = fpxs_of_fls g \<longleftrightarrow> f = g"
+ by transfer (force simp: fun_eq_iff Ints_def)
+
+lemma fpxs_of_fls_0 [simp]: "fpxs_of_fls 0 = 0"
+ by transfer auto
+
+lemma fpxs_of_fls_1 [simp]: "fpxs_of_fls 1 = 1"
+ by transfer (auto simp: fun_eq_iff elim!: Ints_cases)
+
+lemma fpxs_of_fls_add [simp]: "fpxs_of_fls (f + g) = fpxs_of_fls f + fpxs_of_fls g"
+ by transfer (auto simp: fun_eq_iff elim!: Ints_cases)
+
+lemma fps_to_fls_sum [simp]: "fps_to_fls (sum f A) = (\<Sum>x\<in>A. fps_to_fls (f x))"
+ by (induction A rule: infinite_finite_induct) auto
+
+lemma fpxs_of_fls_sum [simp]: "fpxs_of_fls (sum f A) = (\<Sum>x\<in>A. fpxs_of_fls (f x))"
+ by (induction A rule: infinite_finite_induct) auto
+
+lemma fpxs_nth_of_fls:
+ "fpxs_nth (fpxs_of_fls f) r = (if r \<in> \<int> then fls_nth f \<lfloor>r\<rfloor> else 0)"
+ by transfer auto
+
+lemma fpxs_of_fls_eq_0_iff [simp]: "fpxs_of_fls f = 0 \<longleftrightarrow> f = 0"
+ using fpxs_of_fls_eq_iff[of f 0] by (simp del: fpxs_of_fls_eq_iff)
+
+lemma fpxs_of_fls_eq_1_iff [simp]: "fpxs_of_fls f = 1 \<longleftrightarrow> f = 1"
+ using fpxs_of_fls_eq_iff[of f 1] by (simp del: fpxs_of_fls_eq_iff)
+
+lemma fpxs_root_order_of_fls [simp]: "fpxs_root_order (fpxs_of_fls f) = 1"
+proof (transfer, goal_cases)
+ case (1 f)
+ have "supp (\<lambda>r. if r \<in> \<int> then f \<lfloor>r\<rfloor> else 0) = rat_of_int ` {n. f n \<noteq> 0}"
+ by (force simp: supp_def Ints_def)
+ also have "(LCM r\<in>\<dots>. snd (quotient_of r)) = nat (LCM x\<in>{n. f n \<noteq> 0}. 1)"
+ by (simp add: image_image)
+ also have "\<dots> = 1"
+ by simp
+ also have "nat 1 = 1"
+ by simp
+ finally show ?case .
+qed
+
+
+
+subsection \<open>The substitution $X \mapsto X^r$\<close>
+
+text \<open>
+ This operation turns a formal Puiseux series $f(X)$ into $f(X^r)$, where
+ $r$ can be any positive rational number:
+\<close>
+lift_definition fpxs_compose_power :: "'a :: zero fpxs \<Rightarrow> rat \<Rightarrow> 'a fpxs" is
+ "\<lambda>f r x. if r > 0 then f (x / r) else 0"
+proof -
+ fix f :: "rat \<Rightarrow> 'a" and r :: rat
+ assume f: "is_fpxs f"
+ have "is_fpxs (\<lambda>x. f (x / r))" if "r > 0"
+ unfolding is_fpxs_def
+ proof
+ define r' where "r' = inverse r"
+ have "r' > 0"
+ using \<open>r > 0\<close> by (auto simp: r'_def)
+ have "(\<lambda>x. x / r') ` supp f = supp (\<lambda>x. f (x * r'))"
+ using \<open>r' > 0\<close> by (auto simp: supp_def image_iff vimage_def field_simps)
+ hence eq: "(\<lambda>x. x * r) ` supp f = supp (\<lambda>x. f (x / r))"
+ using \<open>r > 0\<close> by (simp add: r'_def field_simps)
+
+ from f have "bdd_below (supp f)"
+ by (auto simp: is_fpxs_def)
+ hence "bdd_below ((\<lambda>x. x * r) ` supp f)"
+ using \<open>r > 0\<close> by (intro bdd_below_image_mono) (auto simp: mono_def divide_right_mono)
+ also note eq
+ finally show "bdd_below (supp (\<lambda>x. f (x / r)))" .
+
+ define a b where "a = fst (quotient_of r)" and "b = snd (quotient_of r)"
+ have "b > 0" by (simp add: b_def quotient_of_denom_pos')
+ have [simp]: "quotient_of r = (a, b)"
+ by (simp add: a_def b_def)
+ have "r = of_int a / of_int b"
+ by (simp add: quotient_of_div)
+ with \<open>r > 0\<close> and \<open>b > 0\<close> have \<open>a > 0\<close>
+ by (simp add: field_simps)
+
+ have "(LCM r\<in>supp (\<lambda>x. f (x / r)). snd (quotient_of r)) =
+ (LCM x\<in>supp f. snd (quotient_of (x * r)))"
+ by (simp add: eq [symmetric] image_image)
+ also have "\<dots> dvd (LCM x\<in>supp f. snd (quotient_of x) * b)"
+ using \<open>a > 0\<close> \<open>b > 0\<close>
+ by (intro Lcm_mono)
+ (simp add: rat_times_code case_prod_unfold Let_def Rat.normalize_def
+ quotient_of_denom_pos' div_dvd_self)
+ also have "\<dots> dvd normalize (b * (LCM x\<in>supp f. snd (quotient_of x)))"
+ proof (cases "supp f = {}")
+ case False
+ thus ?thesis using Lcm_mult[of "(\<lambda>x. snd (quotient_of x)) ` supp f" b]
+ by (simp add: mult_ac image_image)
+ qed auto
+ hence "(LCM x\<in>supp f. snd (quotient_of x) * b) dvd
+ b * (LCM x\<in>supp f. snd (quotient_of x))" by simp
+ finally show "(LCM r\<in>supp (\<lambda>x. f (x / r)). snd (quotient_of r)) \<noteq> 0"
+ using \<open>b > 0\<close> f by (auto simp: is_fpxs_def)
+ qed
+ thus "is_fpxs (\<lambda>x. if r > 0 then f (x / r) else 0)"
+ by (cases "r > 0") (auto simp: is_fpxs_def supp_def)
+qed
+
+lemma fpxs_as_fls:
+ "fpxs_compose_power (fpxs_of_fls (fls_of_fpxs f)) (1 / of_nat (fpxs_root_order f)) = f"
+proof (transfer, goal_cases)
+ case (1 f)
+ define d where "d = (LCM r\<in>supp f. snd (quotient_of r))"
+ have "d \<ge> 0" by (simp add: d_def)
+ moreover have "d \<noteq> 0" using 1 by (simp add: is_fpxs_def d_def)
+ ultimately have "d > 0" by linarith
+
+ have "(if rat_of_int d * x \<in> \<int> then f (rat_of_int \<lfloor>rat_of_int d * x\<rfloor> / rat_of_int d) else 0) = f x" for x
+ proof (cases "rat_of_int d * x \<in> \<int>")
+ case True
+ then obtain n where n: "rat_of_int d * x = of_int n"
+ by (auto elim!: Ints_cases)
+ have "f (rat_of_int \<lfloor>rat_of_int d * x\<rfloor> / rat_of_int d) = f (rat_of_int n / rat_of_int d)"
+ by (simp add: n)
+ also have "rat_of_int n / rat_of_int d = x"
+ using n \<open>d > 0\<close> by (simp add: field_simps)
+ finally show ?thesis
+ using True by simp
+ next
+ case False
+ have "x \<notin> supp f"
+ proof
+ assume "x \<in> supp f"
+ hence "snd (quotient_of x) dvd d"
+ by (simp add: d_def)
+ hence "rat_of_int (fst (quotient_of x) * d) / rat_of_int (snd (quotient_of x)) \<in> \<int>"
+ by (intro of_int_divide_in_Ints) auto
+ also have "rat_of_int (fst (quotient_of x) * d) / rat_of_int (snd (quotient_of x)) =
+ rat_of_int d * (rat_of_int (fst (quotient_of x)) / rat_of_int (snd (quotient_of x)))"
+ by (simp only: of_int_mult mult_ac times_divide_eq_right)
+ also have "\<dots> = rat_of_int d * x"
+ by (metis Fract_of_int_quotient Rat_cases normalize_stable prod.sel(1) prod.sel(2) quotient_of_Fract)
+ finally have "rat_of_int d * x \<in> \<int>" .
+ with False show False by contradiction
+ qed
+ thus ?thesis using False by (simp add: supp_def)
+ qed
+ thus ?case
+ using \<open>d > 0\<close> by (simp add: is_fpxs_def d_def mult_ac fun_eq_iff cong: if_cong)
+qed
+
+lemma fpxs_compose_power_0 [simp]: "fpxs_compose_power 0 r = 0"
+ by transfer simp
+
+lemma fpxs_compose_power_1 [simp]: "r > 0 \<Longrightarrow> fpxs_compose_power 1 r = 1"
+ by transfer (auto simp: fun_eq_iff)
+
+lemma fls_of_fpxs_eq_0_iff [simp]: "fls_of_fpxs x = 0 \<longleftrightarrow> x = 0"
+ by (metis fls_of_fpxs_0 fpxs_as_fls fpxs_compose_power_0 fpxs_of_fls_0)
+
+lemma fpxs_of_fls_compose_power [simp]:
+ "fpxs_of_fls (fls_compose_power f d) = fpxs_compose_power (fpxs_of_fls f) (of_nat d)"
+proof (transfer, goal_cases)
+ case (1 f d)
+ show ?case
+ proof (cases "d = 0")
+ case False
+ show ?thesis
+ proof (intro ext, goal_cases)
+ case (1 r)
+ show ?case
+ proof (cases "r \<in> \<int>")
+ case True
+ then obtain n where [simp]: "r = of_int n"
+ by (cases r rule: Ints_cases)
+ show ?thesis
+ proof (cases "d dvd n")
+ case True
+ thus ?thesis by (auto elim!: Ints_cases)
+ next
+ case False
+ hence "rat_of_int n / rat_of_int (int d) \<notin> \<int>"
+ using \<open>d \<noteq> 0\<close> by (subst of_int_div_of_int_in_Ints_iff) auto
+ thus ?thesis using False by auto
+ qed
+ next
+ case False
+ hence "r / rat_of_nat d \<notin> \<int>"
+ using \<open>d \<noteq> 0\<close> by (auto elim!: Ints_cases simp: field_simps)
+ thus ?thesis using False by auto
+ qed
+ qed
+ qed auto
+qed
+
+lemma fpxs_compose_power_add [simp]:
+ "fpxs_compose_power (f + g) r = fpxs_compose_power f r + fpxs_compose_power g r"
+ by transfer (auto simp: fun_eq_iff)
+
+lemma fpxs_compose_power_distrib:
+ "r1 > 0 \<or> r2 > 0 \<Longrightarrow>
+ fpxs_compose_power (fpxs_compose_power f r1) r2 = fpxs_compose_power f (r1 * r2)"
+ by transfer (auto simp: fun_eq_iff algebra_simps zero_less_mult_iff)
+
+lemma fpxs_compose_power_divide_right:
+ "r1 > 0 \<Longrightarrow> r2 > 0 \<Longrightarrow>
+ fpxs_compose_power f (r1 / r2) = fpxs_compose_power (fpxs_compose_power f r1) (inverse r2)"
+ by (simp add: fpxs_compose_power_distrib field_simps)
+
+lemma fpxs_compose_power_1_right [simp]: "fpxs_compose_power f 1 = f"
+ by transfer auto
+
+lemma fpxs_compose_power_eq_iff [simp]:
+ assumes "r > 0"
+ shows "fpxs_compose_power f r = fpxs_compose_power g r \<longleftrightarrow> f = g"
+ using assms
+proof (transfer, goal_cases)
+ case (1 r f g)
+ have "f x = g x" if "\<And>x. f (x / r) = g (x / r)" for x
+ using that[of "x * r"] \<open>r > 0\<close> by auto
+ thus ?case using \<open>r > 0\<close> by (auto simp: fun_eq_iff)
+qed
+
+lemma fpxs_compose_power_eq_1_iff [simp]:
+ assumes "l > 0"
+ shows "fpxs_compose_power p l = 1 \<longleftrightarrow> p = 1"
+proof -
+ have "fpxs_compose_power p l = 1 \<longleftrightarrow> fpxs_compose_power p l = fpxs_compose_power 1 l"
+ by (subst fpxs_compose_power_1) (use assms in auto)
+ also have "\<dots> \<longleftrightarrow> p = 1"
+ using assms by (subst fpxs_compose_power_eq_iff) auto
+ finally show ?thesis .
+qed
+
+lemma fpxs_compose_power_eq_0_iff [simp]:
+ assumes "r > 0"
+ shows "fpxs_compose_power f r = 0 \<longleftrightarrow> f = 0"
+ using fpxs_compose_power_eq_iff[of r f 0] assms by (simp del: fpxs_compose_power_eq_iff)
+
+lemma fls_of_fpxs_of_fls [simp]: "fls_of_fpxs (fpxs_of_fls f) = f"
+ using fpxs_as_fls[of "fpxs_of_fls f"] by simp
+
+lemma fpxs_as_fls':
+ assumes "fpxs_root_order f dvd d" "d > 0"
+ obtains f' where "f = fpxs_compose_power (fpxs_of_fls f') (1 / of_nat d)"
+proof -
+ define D where "D = fpxs_root_order f"
+ have "D > 0"
+ by (auto simp: D_def)
+ define f' where "f' = fls_of_fpxs f"
+ from assms obtain d' where d': "d = D * d'"
+ by (auto simp: D_def)
+ have "d' > 0"
+ using assms by (auto intro!: Nat.gr0I simp: d')
+ define f'' where "f'' = fls_compose_power f' d'"
+ have "fpxs_compose_power (fpxs_of_fls f'') (1 / of_nat d) = f"
+ using \<open>D > 0\<close> \<open>d' > 0\<close>
+ by (simp add: d' D_def f''_def f'_def fpxs_as_fls fpxs_compose_power_distrib)
+ thus ?thesis using that[of f''] by blast
+qed
+
+
+subsection \<open>Mutiplication and ring properties\<close>
+
+instantiation fpxs :: (comm_semiring_1) comm_semiring_1
+begin
+
+lift_definition times_fpxs :: "'a fpxs \<Rightarrow> 'a fpxs \<Rightarrow> 'a fpxs" is
+ "\<lambda>f g x. (\<Sum>(y,z) | y \<in> supp f \<and> z \<in> supp g \<and> x = y + z. f y * g z)"
+proof -
+ fix f g :: "rat \<Rightarrow> 'a"
+ assume fg: "is_fpxs f" "is_fpxs g"
+ show "is_fpxs (\<lambda>x. \<Sum>(y,z) | y \<in> supp f \<and> z \<in> supp g \<and> x = y + z. f y * g z)"
+ (is "is_fpxs ?h") unfolding is_fpxs_def
+ proof
+ from fg obtain bnd1 bnd2 where bnds: "\<forall>x\<in>supp f. x \<ge> bnd1" "\<forall>x\<in>supp g. x \<ge> bnd2"
+ by (auto simp: is_fpxs_def bdd_below_def)
+ have "supp ?h \<subseteq> (\<lambda>(x,y). x + y) ` (supp f \<times> supp g)"
+ proof
+ fix x :: rat
+ assume "x \<in> supp ?h"
+ have "{(y,z). y \<in> supp f \<and> z \<in> supp g \<and> x = y + z} \<noteq> {}"
+ proof
+ assume eq: "{(y,z). y \<in> supp f \<and> z \<in> supp g \<and> x = y + z} = {}"
+ hence "?h x = 0"
+ by (simp only:) auto
+ with \<open>x \<in> supp ?h\<close> show False by (auto simp: supp_def)
+ qed
+ thus "x \<in> (\<lambda>(x,y). x + y) ` (supp f \<times> supp g)"
+ by auto
+ qed
+ also have "\<dots> \<subseteq> {bnd1 + bnd2..}"
+ using bnds by (auto intro: add_mono)
+ finally show "bdd_below (supp ?h)"
+ by auto
+ next
+ define d1 where "d1 = (LCM r\<in>supp f. snd (quotient_of r))"
+ define d2 where "d2 = (LCM r\<in>supp g. snd (quotient_of r))"
+ have "(LCM r\<in>supp ?h. snd (quotient_of r)) dvd (d1 * d2)"
+ proof (intro Lcm_least, safe)
+ fix r :: rat
+ assume "r \<in> supp ?h"
+ hence "(\<Sum>(y, z) | y \<in> supp f \<and> z \<in> supp g \<and> r = y + z. f y * g z) \<noteq> 0"
+ by (auto simp: supp_def)
+ hence "{(y, z). y \<in> supp f \<and> z \<in> supp g \<and> r = y + z} \<noteq> {}"
+ by (intro notI) simp_all
+ then obtain y z where yz: "y \<in> supp f" "z \<in> supp g" "r = y + z"
+ by auto
+ have "snd (quotient_of r) = snd (quotient_of y) * snd (quotient_of z) div
+ gcd (fst (quotient_of y) * snd (quotient_of z) +
+ fst (quotient_of z) * snd (quotient_of y))
+ (snd (quotient_of y) * snd (quotient_of z))"
+ by (simp add: \<open>r = _\<close> rat_plus_code case_prod_unfold Let_def
+ Rat.normalize_def quotient_of_denom_pos')
+ also have "\<dots> dvd snd (quotient_of y) * snd (quotient_of z)"
+ by (metis dvd_def dvd_div_mult_self gcd_dvd2)
+ also have "\<dots> dvd d1 * d2"
+ using yz by (auto simp: d1_def d2_def intro!: mult_dvd_mono)
+ finally show "snd (quotient_of r) dvd d1 * d2"
+ by (simp add: d1_def d2_def)
+ qed
+ moreover have "d1 * d2 \<noteq> 0"
+ using fg by (auto simp: d1_def d2_def is_fpxs_def)
+ ultimately show "(LCM r\<in>supp ?h. snd (quotient_of r)) \<noteq> 0"
+ by auto
+ qed
+qed
+
+lemma fpxs_nth_mult:
+ "fpxs_nth (f * g) r =
+ (\<Sum>(y,z) | y \<in> fpxs_supp f \<and> z \<in> fpxs_supp g \<and> r = y + z. fpxs_nth f y * fpxs_nth g z)"
+ by transfer simp
+
+lemma fpxs_compose_power_mult [simp]:
+ "fpxs_compose_power (f * g) r = fpxs_compose_power f r * fpxs_compose_power g r"
+proof (transfer, rule ext, goal_cases)
+ case (1 f g r x)
+ show ?case
+ proof (cases "r > 0")
+ case True
+ have "(\<Sum>x\<in>{(y, z). y \<in> supp f \<and> z \<in> supp g \<and> x / r = y + z}.
+ case x of (y, z) \<Rightarrow> f y * g z) =
+ (\<Sum>x\<in>{(y, z). y \<in> supp (\<lambda>x. f (x / r)) \<and> z \<in> supp (\<lambda>x. g (x / r)) \<and> x = y + z}.
+ case x of (y, z) \<Rightarrow> f (y / r) * g (z / r))"
+ by (rule sum.reindex_bij_witness[of _ "\<lambda>(x,y). (x/r,y/r)" "\<lambda>(x,y). (x*r,y*r)"])
+ (use \<open>r > 0\<close> in \<open>auto simp: supp_def field_simps\<close>)
+ thus ?thesis
+ by (auto simp: fun_eq_iff)
+ qed auto
+qed
+
+lemma fpxs_supp_of_fls: "fpxs_supp (fpxs_of_fls f) = of_int ` supp (fls_nth f)"
+ by (force simp: fpxs_supp_def fpxs_nth_of_fls supp_def elim!: Ints_cases)
+
+lemma fpxs_of_fls_mult [simp]: "fpxs_of_fls (f * g) = fpxs_of_fls f * fpxs_of_fls g"
+proof (rule fpxs_ext)
+ fix r :: rat
+ show "fpxs_nth (fpxs_of_fls (f * g)) r = fpxs_nth (fpxs_of_fls f * fpxs_of_fls g) r"
+ proof (cases "r \<in> \<int>")
+ case True
+ define h1 where "h1 = (\<lambda>(x, y). (\<lfloor>x::rat\<rfloor>, \<lfloor>y::rat\<rfloor>))"
+ define h2 where "h2 = (\<lambda>(x, y). (of_int x :: rat, of_int y :: rat))"
+ define df dg where [simp]: "df = fls_subdegree f" "dg = fls_subdegree g"
+ from True obtain n where [simp]: "r = of_int n"
+ by (cases rule: Ints_cases)
+ have "fpxs_nth (fpxs_of_fls f * fpxs_of_fls g) r =
+ (\<Sum>(y,z) | y \<in> fpxs_supp (fpxs_of_fls f) \<and> z \<in> fpxs_supp (fpxs_of_fls g) \<and> rat_of_int n = y + z.
+ (if y \<in> \<int> then fls_nth f \<lfloor>y\<rfloor> else 0) * (if z \<in> \<int> then fls_nth g \<lfloor>z\<rfloor> else 0))"
+ by (auto simp: fpxs_nth_mult fpxs_nth_of_fls)
+ also have "\<dots> = (\<Sum>(y,z) | y \<in> supp (fls_nth f) \<and> z \<in> supp (fls_nth g) \<and> n = y + z.
+ fls_nth f y * fls_nth g z)"
+ by (rule sum.reindex_bij_witness[of _ h2 h1]) (auto simp: h1_def h2_def fpxs_supp_of_fls)
+ also have "\<dots> = (\<Sum>y | y - fls_subdegree g \<in> supp (fls_nth f) \<and> fls_subdegree g + n - y \<in> supp (fls_nth g).
+ fls_nth f (y - fls_subdegree g) * fls_nth g (fls_subdegree g + n - y))"
+ by (rule sum.reindex_bij_witness[of _ "\<lambda>y. (y - fls_subdegree g, fls_subdegree g + n - y)" "\<lambda>z. fst z + fls_subdegree g"])
+ auto
+ also have "\<dots> = (\<Sum>i = fls_subdegree f + fls_subdegree g..n.
+ fls_nth f (i - fls_subdegree g) * fls_nth g (fls_subdegree g + n - i))"
+ using fls_subdegree_leI[of f] fls_subdegree_leI [of g]
+ by (intro sum.mono_neutral_left; force simp: supp_def)
+ also have "\<dots> = fpxs_nth (fpxs_of_fls (f * g)) r"
+ by (auto simp: fls_times_nth fpxs_nth_of_fls)
+ finally show ?thesis ..
+ next
+ case False
+ have "fpxs_nth (fpxs_of_fls f * fpxs_of_fls g) r =
+ (\<Sum>(y,z) | y \<in> fpxs_supp (fpxs_of_fls f) \<and> z \<in> fpxs_supp (fpxs_of_fls g) \<and> r = y + z.
+ (if y \<in> \<int> then fls_nth f \<lfloor>y\<rfloor> else 0) * (if z \<in> \<int> then fls_nth g \<lfloor>z\<rfloor> else 0))"
+ by (simp add: fpxs_nth_mult fpxs_nth_of_fls)
+ also have "\<dots> = 0"
+ using False by (intro sum.neutral ballI) auto
+ also have "0 = fpxs_nth (fpxs_of_fls (f * g)) r"
+ using False by (simp add: fpxs_nth_of_fls)
+ finally show ?thesis ..
+ qed
+qed
+
+instance proof
+ show "0 \<noteq> (1 :: 'a fpxs)"
+ by transfer (auto simp: fun_eq_iff)
+next
+ fix f :: "'a fpxs"
+ show "1 * f = f"
+ proof (transfer, goal_cases)
+ case (1 f)
+ have "{(y, z). y \<in> supp (\<lambda>r. if r = 0 then (1::'a) else 0) \<and> z \<in> supp f \<and> x = y + z} =
+ (if x \<in> supp f then {(0, x)} else {})" for x
+ by (auto simp: supp_def split: if_splits)
+ thus ?case
+ by (auto simp: fun_eq_iff supp_def)
+ qed
+next
+ fix f :: "'a fpxs"
+ show "0 * f = 0"
+ by transfer (auto simp: fun_eq_iff supp_def)
+ show "f * 0 = 0"
+ by transfer (auto simp: fun_eq_iff supp_def)
+next
+ fix f g :: "'a fpxs"
+ show "f * g = g * f"
+ proof (transfer, rule ext, goal_cases)
+ case (1 f g x)
+ show "(\<Sum>(y, z)\<in>{(y, z). y \<in> supp f \<and> z \<in> supp g \<and> x = y + z}. f y * g z) =
+ (\<Sum>(y, z)\<in>{(y, z). y \<in> supp g \<and> z \<in> supp f \<and> x = y + z}. g y * f z)"
+ by (rule sum.reindex_bij_witness[of _ "\<lambda>(x,y). (y,x)" "\<lambda>(x,y). (y,x)"])
+ (auto simp: mult_ac)
+ qed
+next
+ fix f g h :: "'a fpxs"
+ define d where "d = (LCM F\<in>{f,g,h}. fpxs_root_order F)"
+ have "d > 0"
+ by (auto simp: d_def intro!: Nat.gr0I)
+ obtain f' where f: "f = fpxs_compose_power (fpxs_of_fls f') (1 / of_nat d)"
+ using fpxs_as_fls'[of f d] \<open>d > 0\<close> by (auto simp: d_def)
+ obtain g' where g: "g = fpxs_compose_power (fpxs_of_fls g') (1 / of_nat d)"
+ using fpxs_as_fls'[of g d] \<open>d > 0\<close> by (auto simp: d_def)
+ obtain h' where h: "h = fpxs_compose_power (fpxs_of_fls h') (1 / of_nat d)"
+ using fpxs_as_fls'[of h d] \<open>d > 0\<close> by (auto simp: d_def)
+ show "(f * g) * h = f * (g * h)"
+ by (simp add: f g h mult_ac
+ flip: fpxs_compose_power_mult fpxs_compose_power_add fpxs_of_fls_mult)
+ show "(f + g) * h = f * h + g * h"
+ by (simp add: f g h ring_distribs
+ flip: fpxs_compose_power_mult fpxs_compose_power_add fpxs_of_fls_mult fpxs_of_fls_add)
+qed
+
+end
+
+instance fpxs :: (comm_ring_1) comm_ring_1
+ by intro_classes auto
+
+instance fpxs :: ("{comm_semiring_1,semiring_no_zero_divisors}") semiring_no_zero_divisors
+proof
+ fix f g :: "'a fpxs"
+ assume fg: "f \<noteq> 0" "g \<noteq> 0"
+ define d where "d = lcm (fpxs_root_order f) (fpxs_root_order g)"
+ have "d > 0"
+ by (auto simp: d_def intro!: lcm_pos_nat)
+ obtain f' where f: "f = fpxs_compose_power (fpxs_of_fls f') (1 / of_nat d)"
+ using fpxs_as_fls'[of f d] \<open>d > 0\<close> by (auto simp: d_def)
+ obtain g' where g: "g = fpxs_compose_power (fpxs_of_fls g') (1 / of_nat d)"
+ using fpxs_as_fls'[of g d] \<open>d > 0\<close> by (auto simp: d_def)
+ show "f * g \<noteq> 0"
+ using \<open>d > 0\<close> fg
+ by (simp add: f g flip: fpxs_compose_power_mult fpxs_of_fls_mult)
+qed
+
+lemma fpxs_of_fls_power [simp]: "fpxs_of_fls (f ^ n) = fpxs_of_fls f ^ n"
+ by (induction n) auto
+
+lemma fpxs_compose_power_power [simp]:
+ "r > 0 \<Longrightarrow> fpxs_compose_power (f ^ n) r = fpxs_compose_power f r ^ n"
+ by (induction n) simp_all
+
+
+subsection \<open>Constant Puiseux series and the series \<open>X\<close>\<close>
+
+lift_definition fpxs_const :: "'a :: zero \<Rightarrow> 'a fpxs" is
+ "\<lambda>c n. if n = 0 then c else 0"
+proof -
+ fix c :: 'a
+ have "supp (\<lambda>n::rat. if n = 0 then c else 0) = (if c = 0 then {} else {0})"
+ by auto
+ thus "is_fpxs (\<lambda>n::rat. if n = 0 then c else 0)"
+ unfolding is_fpxs_def by auto
+qed
+
+lemma fpxs_const_0 [simp]: "fpxs_const 0 = 0"
+ by transfer auto
+
+lemma fpxs_const_1 [simp]: "fpxs_const 1 = 1"
+ by transfer auto
+
+lemma fpxs_of_fls_const [simp]: "fpxs_of_fls (fls_const c) = fpxs_const c"
+ by transfer (auto simp: fun_eq_iff Ints_def)
+
+lemma fls_of_fpxs_const [simp]: "fls_of_fpxs (fpxs_const c) = fls_const c"
+ by (metis fls_of_fpxs_of_fls fpxs_of_fls_const)
+
+lemma fls_of_fpxs_1 [simp]: "fls_of_fpxs 1 = 1"
+ using fls_of_fpxs_const[of 1] by (simp del: fls_of_fpxs_const)
+
+lift_definition fpxs_X :: "'a :: {one, zero} fpxs" is
+ "\<lambda>x. if x = 1 then (1::'a) else 0"
+ by (cases "1 = (0 :: 'a)") (auto simp: is_fpxs_def cong: if_cong)
+
+lemma fpxs_const_altdef: "fpxs_const x = fpxs_of_fls (fls_const x)"
+ by transfer auto
+
+lemma fpxs_const_add [simp]: "fpxs_const (x + y) = fpxs_const x + fpxs_const y"
+ by transfer auto
+
+lemma fpxs_const_mult [simp]:
+ fixes x y :: "'a::{comm_semiring_1}"
+ shows "fpxs_const (x * y) = fpxs_const x * fpxs_const y"
+ unfolding fpxs_const_altdef fls_const_mult_const[symmetric] fpxs_of_fls_mult ..
+
+lemma fpxs_const_eq_iff [simp]:
+ "fpxs_const x = fpxs_const y \<longleftrightarrow> x = y"
+ by transfer (auto simp: fun_eq_iff)
+
+lemma of_nat_fpxs_eq: "of_nat n = fpxs_const (of_nat n)"
+ by (induction n) auto
+
+lemma fpxs_const_uminus [simp]: "fpxs_const (-x) = -fpxs_const x"
+ by transfer auto
+
+lemma fpxs_const_diff [simp]: "fpxs_const (x - y) = fpxs_const x - fpxs_const y"
+ unfolding minus_fpxs_def by transfer auto
+
+lemma of_int_fpxs_eq: "of_int n = fpxs_const (of_int n)"
+ by (induction n) (auto simp: of_nat_fpxs_eq)
+
+
+subsection \<open>More algebraic typeclass instances\<close>
+
+instance fpxs :: ("{comm_semiring_1,semiring_char_0}") semiring_char_0
+proof
+ show "inj (of_nat :: nat \<Rightarrow> 'a fpxs)"
+ by (intro injI) (auto simp: of_nat_fpxs_eq)
+qed
+
+instance fpxs :: ("{comm_ring_1,ring_char_0}") ring_char_0 ..
+
+instance fpxs :: (idom) idom ..
+
+instantiation fpxs :: (field) field
+begin
+
+definition inverse_fpxs :: "'a fpxs \<Rightarrow> 'a fpxs" where
+ "inverse_fpxs f =
+ fpxs_compose_power (fpxs_of_fls (inverse (fls_of_fpxs f))) (1 / of_nat (fpxs_root_order f))"
+
+definition divide_fpxs :: "'a fpxs \<Rightarrow> 'a fpxs \<Rightarrow> 'a fpxs" where
+ "divide_fpxs f g = f * inverse g"
+
+instance proof
+ fix f :: "'a fpxs"
+ assume "f \<noteq> 0"
+ define f' where "f' = fls_of_fpxs f"
+ define d where "d = fpxs_root_order f"
+ have "d > 0" by (auto simp: d_def)
+ have f: "f = fpxs_compose_power (fpxs_of_fls f') (1 / of_nat d)"
+ by (simp add: f'_def d_def fpxs_as_fls)
+
+ have "inverse f * f = fpxs_compose_power (fpxs_of_fls (inverse f')) (1 / of_nat d) * f"
+ by (simp add: inverse_fpxs_def f'_def d_def)
+ also have "fpxs_compose_power (fpxs_of_fls (inverse f')) (1 / of_nat d) * f =
+ fpxs_compose_power (fpxs_of_fls (inverse f' * f')) (1 / of_nat d)"
+ by (simp add: f)
+ also have "inverse f' * f' = 1"
+ using \<open>f \<noteq> 0\<close> \<open>d > 0\<close> by (simp add: f field_simps)
+ finally show "inverse f * f = 1"
+ using \<open>d > 0\<close> by simp
+qed (auto simp: divide_fpxs_def inverse_fpxs_def)
+
+end
+
+instance fpxs :: (field_char_0) field_char_0 ..
+
+
+subsection \<open>Valuation\<close>
+
+definition fpxs_val :: "'a :: zero fpxs \<Rightarrow> rat" where
+ "fpxs_val f =
+ of_int (fls_subdegree (fls_of_fpxs f)) / rat_of_nat (fpxs_root_order f)"
+
+lemma fpxs_val_of_fls [simp]: "fpxs_val (fpxs_of_fls f) = of_int (fls_subdegree f)"
+ by (simp add: fpxs_val_def)
+
+lemma fpxs_nth_compose_power [simp]:
+ assumes "r > 0"
+ shows "fpxs_nth (fpxs_compose_power f r) n = fpxs_nth f (n / r)"
+ using assms by transfer auto
+
+lemma fls_of_fpxs_uminus [simp]: "fls_of_fpxs (-f) = -fls_of_fpxs f"
+ by transfer auto
+
+lemma fpxs_root_order_uminus [simp]: "fpxs_root_order (-f) = fpxs_root_order f"
+ by transfer auto
+
+lemma fpxs_val_uminus [simp]: "fpxs_val (-f) = fpxs_val f"
+ unfolding fpxs_val_def by simp
+
+lemma fpxs_val_minus_commute: "fpxs_val (f - g) = fpxs_val (g - f)"
+ by (subst fpxs_val_uminus [symmetric]) (simp del: fpxs_val_uminus)
+
+lemma fpxs_val_const [simp]: "fpxs_val (fpxs_const c) = 0"
+ by (simp add: fpxs_val_def)
+
+lemma fpxs_val_1 [simp]: "fpxs_val 1 = 0"
+ by (simp add: fpxs_val_def)
+
+lemma of_int_fls_subdegree_of_fpxs:
+ "rat_of_int (fls_subdegree (fls_of_fpxs f)) = fpxs_val f * of_nat (fpxs_root_order f)"
+ by (simp add: fpxs_val_def)
+
+lemma fpxs_nth_val_nonzero:
+ assumes "f \<noteq> 0"
+ shows "fpxs_nth f (fpxs_val f) \<noteq> 0"
+proof -
+ define N where "N = fpxs_root_order f"
+ define f' where "f' = fls_of_fpxs f"
+ define M where "M = fls_subdegree f'"
+ have val: "fpxs_val f = of_int M / of_nat N"
+ by (simp add: M_def fpxs_val_def N_def f'_def)
+ have *: "f = fpxs_compose_power (fpxs_of_fls f') (1 / rat_of_nat N)"
+ by (simp add: fpxs_as_fls N_def f'_def)
+ also have "fpxs_nth \<dots> (fpxs_val f) =
+ fpxs_nth (fpxs_of_fls f') (fpxs_val f * rat_of_nat (fpxs_root_order f))"
+ by (subst fpxs_nth_compose_power) (auto simp: N_def)
+ also have "\<dots> = fls_nth f' M"
+ by (subst fpxs_nth_of_fls) (auto simp: val N_def)
+ also have "f' \<noteq> 0"
+ using * assms by auto
+ hence "fls_nth f' M \<noteq> 0"
+ unfolding M_def by simp
+ finally show "fpxs_nth f (fpxs_val f) \<noteq> 0" .
+qed
+
+lemma fpxs_nth_below_val:
+ assumes n: "n < fpxs_val f"
+ shows "fpxs_nth f n = 0"
+proof (cases "f = 0")
+ case False
+ define N where "N = fpxs_root_order f"
+ define f' where "f' = fls_of_fpxs f"
+ define M where "M = fls_subdegree f'"
+ have val: "fpxs_val f = of_int M / of_nat N"
+ by (simp add: M_def fpxs_val_def N_def f'_def)
+ have *: "f = fpxs_compose_power (fpxs_of_fls f') (1 / rat_of_nat N)"
+ by (simp add: fpxs_as_fls N_def f'_def)
+ have "fpxs_nth f n = fpxs_nth (fpxs_of_fls f') (n * rat_of_nat N)"
+ by (subst *, subst fpxs_nth_compose_power) (auto simp: N_def)
+ also have "\<dots> = 0"
+ proof (cases "rat_of_nat N * n \<in> \<int>")
+ case True
+ then obtain n' where n': "of_int n' = rat_of_nat N * n"
+ by (elim Ints_cases) auto
+ have "of_int n' < rat_of_nat N * fpxs_val f"
+ unfolding n' using n by (intro mult_strict_left_mono) (auto simp: N_def)
+ also have "\<dots> = of_int M"
+ by (simp add: val N_def)
+ finally have "n' < M" by linarith
+
+ have "fpxs_nth (fpxs_of_fls f') (rat_of_nat N * n) = fls_nth f' n'"
+ unfolding n'[symmetric] by (subst fpxs_nth_of_fls) (auto simp: N_def)
+ also from \<open>n' < M\<close> have "\<dots> = 0"
+ unfolding M_def by simp
+ finally show ?thesis by (simp add: mult_ac)
+ qed (auto simp: fpxs_nth_of_fls mult_ac)
+ finally show "fpxs_nth f n = 0" .
+qed auto
+
+lemma fpxs_val_leI: "fpxs_nth f r \<noteq> 0 \<Longrightarrow> fpxs_val f \<le> r"
+ using fpxs_nth_below_val[of r f]
+ by (cases "f = 0"; cases "fpxs_val f" r rule: linorder_cases) auto
+
+lemma fpxs_val_0 [simp]: "fpxs_val 0 = 0"
+ by (simp add: fpxs_val_def)
+
+lemma fpxs_val_geI:
+ assumes "f \<noteq> 0" "\<And>r. r < r' \<Longrightarrow> fpxs_nth f r = 0"
+ shows "fpxs_val f \<ge> r'"
+ using fpxs_nth_val_nonzero[of f] assms by force
+
+lemma fpxs_val_compose_power [simp]:
+ assumes "r > 0"
+ shows "fpxs_val (fpxs_compose_power f r) = fpxs_val f * r"
+proof (cases "f = 0")
+ case [simp]: False
+ show ?thesis
+ proof (intro antisym)
+ show "fpxs_val (fpxs_compose_power f r) \<le> fpxs_val f * r"
+ using assms by (intro fpxs_val_leI) (simp add: fpxs_nth_val_nonzero)
+ next
+ show "fpxs_val f * r \<le> fpxs_val (fpxs_compose_power f r)"
+ proof (intro fpxs_val_geI)
+ show "fpxs_nth (fpxs_compose_power f r) r' = 0" if "r' < fpxs_val f * r" for r'
+ unfolding fpxs_nth_compose_power[OF assms]
+ by (rule fpxs_nth_below_val) (use that assms in \<open>auto simp: field_simps\<close>)
+ qed (use assms in auto)
+ qed
+qed auto
+
+lemma fpxs_val_add_ge:
+ assumes "f + g \<noteq> 0"
+ shows "fpxs_val (f + g) \<ge> min (fpxs_val f) (fpxs_val g)"
+proof (rule ccontr)
+ assume "\<not>(fpxs_val (f + g) \<ge> min (fpxs_val f) (fpxs_val g))" (is "\<not>(?n \<ge> _)")
+ hence "?n < fpxs_val f" "?n < fpxs_val g"
+ by auto
+ hence "fpxs_nth f ?n = 0" "fpxs_nth g ?n = 0"
+ by (intro fpxs_nth_below_val; simp; fail)+
+ hence "fpxs_nth (f + g) ?n = 0"
+ by simp
+ moreover have "fpxs_nth (f + g) ?n \<noteq> 0"
+ by (intro fpxs_nth_val_nonzero assms)
+ ultimately show False by contradiction
+qed
+
+lemma fpxs_val_diff_ge:
+ assumes "f \<noteq> g"
+ shows "fpxs_val (f - g) \<ge> min (fpxs_val f) (fpxs_val g)"
+ using fpxs_val_add_ge[of f "-g"] assms by simp
+
+lemma fpxs_nth_mult_val:
+ "fpxs_nth (f * g) (fpxs_val f + fpxs_val g) = fpxs_nth f (fpxs_val f) * fpxs_nth g (fpxs_val g)"
+proof (cases "f = 0 \<or> g = 0")
+ case False
+ have "{(y, z). y \<in> fpxs_supp f \<and> z \<in> fpxs_supp g \<and> fpxs_val f + fpxs_val g = y + z} \<subseteq>
+ {(fpxs_val f, fpxs_val g)}"
+ using False fpxs_val_leI[of f] fpxs_val_leI[of g] by (force simp: fpxs_supp_def supp_def)
+ hence "fpxs_nth (f * g) (fpxs_val f + fpxs_val g) =
+ (\<Sum>(y, z)\<in>{(fpxs_val f, fpxs_val g)}. fpxs_nth f y * fpxs_nth g z)"
+ unfolding fpxs_nth_mult
+ by (intro sum.mono_neutral_left) (auto simp: fpxs_supp_def supp_def)
+ thus ?thesis by simp
+qed auto
+
+lemma fpxs_val_mult [simp]:
+ fixes f g :: "'a :: {comm_semiring_1, semiring_no_zero_divisors} fpxs"
+ assumes "f \<noteq> 0" "g \<noteq> 0"
+ shows "fpxs_val (f * g) = fpxs_val f + fpxs_val g"
+proof (intro antisym fpxs_val_leI fpxs_val_geI)
+ fix r :: rat
+ assume r: "r < fpxs_val f + fpxs_val g"
+ show "fpxs_nth (f * g) r = 0"
+ unfolding fpxs_nth_mult using assms fpxs_val_leI[of f] fpxs_val_leI[of g] r
+ by (intro sum.neutral; force)
+qed (use assms in \<open>auto simp: fpxs_nth_mult_val fpxs_nth_val_nonzero\<close>)
+
+lemma fpxs_val_power [simp]:
+ fixes f :: "'a :: {comm_semiring_1, semiring_no_zero_divisors} fpxs"
+ assumes "f \<noteq> 0 \<or> n > 0"
+ shows "fpxs_val (f ^ n) = of_nat n * fpxs_val f"
+proof (cases "f = 0")
+ case False
+ have [simp]: "f ^ n \<noteq> 0" for n
+ using False by (induction n) auto
+ thus ?thesis using False
+ by (induction n) (auto simp: algebra_simps)
+qed (use assms in \<open>auto simp: power_0_left\<close>)
+
+lemma fpxs_nth_power_val [simp]:
+ fixes f :: "'a :: {comm_semiring_1, semiring_no_zero_divisors} fpxs"
+ shows "fpxs_nth (f ^ r) (rat_of_nat r * fpxs_val f) = fpxs_nth f (fpxs_val f) ^ r"
+proof (cases "f \<noteq> 0")
+ case True
+ show ?thesis
+ proof (induction r)
+ case (Suc r)
+ have "fpxs_nth (f ^ Suc r) (rat_of_nat (Suc r) * fpxs_val f) =
+ fpxs_nth (f * f ^ r) (fpxs_val f + fpxs_val (f ^ r))"
+ using True by (simp add: fpxs_nth_mult_val ring_distribs)
+ also have "\<dots> = fpxs_nth f (fpxs_val f) ^ Suc r"
+ using Suc True by (subst fpxs_nth_mult_val) auto
+ finally show ?case .
+ qed (auto simp: fpxs_nth_1')
+next
+ case False
+ thus ?thesis
+ by (cases r) (auto simp: fpxs_nth_1')
+qed
+
+
+subsection \<open>Powers of \<open>X\<close> and shifting\<close>
+
+lift_definition fpxs_X_power :: "rat \<Rightarrow> 'a :: {zero, one} fpxs" is
+ "\<lambda>r n :: rat. if n = r then 1 else (0 :: 'a)"
+proof -
+ fix r :: rat
+ have "supp (\<lambda>n. if n = r then 1 else (0 :: 'a)) = (if (1 :: 'a) = 0 then {} else {r})"
+ by (auto simp: supp_def)
+ thus "is_fpxs (\<lambda>n. if n = r then 1 else (0 :: 'a))"
+ using quotient_of_denom_pos'[of r] by (auto simp: is_fpxs_def)
+qed
+
+lemma fpxs_X_power_0 [simp]: "fpxs_X_power 0 = 1"
+ by transfer auto
+
+lemma fpxs_X_power_add: "fpxs_X_power (a + b) = fpxs_X_power a * fpxs_X_power b"
+proof (transfer, goal_cases)
+ case (1 a b)
+ have *: "{(y,z). y \<in> supp (\<lambda>n. if n=a then (1::'a) else 0) \<and>
+ z \<in> supp (\<lambda>n. if n=b then (1::'a) else 0) \<and> x=y+z} =
+ (if x = a + b then {(a, b)} else {})" for x
+ by (auto simp: supp_def fun_eq_iff)
+ show ?case
+ unfolding * by (auto simp: fun_eq_iff case_prod_unfold)
+qed
+
+lemma fpxs_X_power_mult: "fpxs_X_power (rat_of_nat n * m) = fpxs_X_power m ^ n"
+ by (induction n) (auto simp: ring_distribs fpxs_X_power_add)
+
+lemma fpxs_of_fls_X_power [simp]: "fpxs_of_fls (fls_shift n 1) = fpxs_X_power (-rat_of_int n)"
+ by transfer (auto simp: fun_eq_iff Ints_def simp flip: of_int_minus)
+
+lemma fpxs_X_power_neq_0 [simp]: "fpxs_X_power r \<noteq> (0 :: 'a :: zero_neq_one fpxs)"
+ by transfer (auto simp: fun_eq_iff)
+
+lemma fpxs_X_power_eq_1_iff [simp]: "fpxs_X_power r = (1 :: 'a :: zero_neq_one fpxs) \<longleftrightarrow> r = 0"
+ by transfer (auto simp: fun_eq_iff)
+
+
+lift_definition fpxs_shift :: "rat \<Rightarrow> 'a :: zero fpxs \<Rightarrow> 'a fpxs" is
+ "\<lambda>r f n. f (n + r)"
+proof -
+ fix r :: rat and f :: "rat \<Rightarrow> 'a"
+ assume f: "is_fpxs f"
+ have subset: "supp (\<lambda>n. f (n + r)) \<subseteq> (\<lambda>n. n + r) -` supp f"
+ by (auto simp: supp_def)
+ have eq: "(\<lambda>n. n + r) -` supp f = (\<lambda>n. n - r) ` supp f"
+ by (auto simp: image_iff algebra_simps)
+
+ show "is_fpxs (\<lambda>n. f (n + r))"
+ unfolding is_fpxs_def
+ proof
+ have "bdd_below ((\<lambda>n. n + r) -` supp f)"
+ unfolding eq by (rule bdd_below_image_mono) (use f in \<open>auto simp: is_fpxs_def mono_def\<close>)
+ thus "bdd_below (supp (\<lambda>n. f (n + r)))"
+ by (rule bdd_below_mono[OF _ subset])
+ next
+ have "(LCM r\<in>supp (\<lambda>n. f (n + r)). snd (quotient_of r)) dvd
+ (LCM r\<in>(\<lambda>n. n + r) -` supp f. snd (quotient_of r))"
+ by (intro Lcm_subset image_mono subset)
+ also have "\<dots> = (LCM x\<in>supp f. snd (quotient_of (x - r)))"
+ by (simp only: eq image_image o_def)
+ also have "\<dots> dvd (LCM x\<in>supp f. snd (quotient_of r) * snd (quotient_of x))"
+ by (subst mult.commute, intro Lcm_mono quotient_of_denom_diff_dvd)
+ also have "\<dots> = Lcm ((\<lambda>x. snd (quotient_of r) * x) ` (\<lambda>x. snd (quotient_of x)) ` supp f)"
+ by (simp add: image_image o_def)
+ also have "\<dots> dvd normalize (snd (quotient_of r) * (LCM x\<in>supp f. snd (quotient_of x)))"
+ proof (cases "supp f = {}")
+ case False
+ thus ?thesis by (subst Lcm_mult) auto
+ qed auto
+ finally show "(LCM r\<in>supp (\<lambda>n. f (n + r)). snd (quotient_of r)) \<noteq> 0"
+ using quotient_of_denom_pos'[of r] f by (auto simp: is_fpxs_def)
+ qed
+qed
+
+lemma fpxs_nth_shift [simp]: "fpxs_nth (fpxs_shift r f) n = fpxs_nth f (n + r)"
+ by transfer simp_all
+
+lemma fpxs_shift_0_left [simp]: "fpxs_shift 0 f = f"
+ by transfer auto
+
+lemma fpxs_shift_add_left: "fpxs_shift (m + n) f = fpxs_shift m (fpxs_shift n f)"
+ by transfer (simp_all add: add_ac)
+
+lemma fpxs_shift_diff_left: "fpxs_shift (m - n) f = fpxs_shift m (fpxs_shift (-n) f)"
+ by (subst fpxs_shift_add_left [symmetric]) auto
+
+lemma fpxs_shift_0 [simp]: "fpxs_shift r 0 = 0"
+ by transfer simp_all
+
+lemma fpxs_shift_add [simp]: "fpxs_shift r (f + g) = fpxs_shift r f + fpxs_shift r g"
+ by transfer auto
+
+lemma fpxs_shift_uminus [simp]: "fpxs_shift r (-f) = -fpxs_shift r f"
+ by transfer auto
+
+lemma fpxs_shift_shift_uminus [simp]: "fpxs_shift r (fpxs_shift (-r) f) = f"
+ by (simp flip: fpxs_shift_add_left)
+
+lemma fpxs_shift_shift_uminus' [simp]: "fpxs_shift (-r) (fpxs_shift r f) = f"
+ by (simp flip: fpxs_shift_add_left)
+
+lemma fpxs_shift_diff [simp]: "fpxs_shift r (f - g) = fpxs_shift r f - fpxs_shift r g"
+ unfolding minus_fpxs_def by (subst fpxs_shift_add) auto
+
+lemma fpxs_shift_compose_power [simp]:
+ "fpxs_shift r (fpxs_compose_power f s) = fpxs_compose_power (fpxs_shift (r / s) f) s"
+ by transfer (simp_all add: add_divide_distrib add_ac cong: if_cong)
+
+lemma rat_of_int_div_dvd: "d dvd n \<Longrightarrow> rat_of_int (n div d) = rat_of_int n / rat_of_int d"
+ by auto
+
+lemma fpxs_of_fls_shift [simp]:
+ "fpxs_of_fls (fls_shift n f) = fpxs_shift (of_int n) (fpxs_of_fls f)"
+proof (transfer, goal_cases)
+ case (1 n f)
+ show ?case
+ proof
+ fix r :: rat
+ have eq: "r + rat_of_int n \<in> \<int> \<longleftrightarrow> r \<in> \<int>"
+ by (metis Ints_add Ints_diff Ints_of_int add_diff_cancel_right')
+ show "(if r \<in> \<int> then f (\<lfloor>r\<rfloor> + n) else 0) =
+ (if r + rat_of_int n \<in> \<int> then f \<lfloor>r + rat_of_int n\<rfloor> else 0)"
+ unfolding eq by auto
+ qed
+qed
+
+lemma fpxs_shift_mult: "f * fpxs_shift r g = fpxs_shift r (f * g)"
+ "fpxs_shift r f * g = fpxs_shift r (f * g)"
+proof -
+ obtain a b where ab: "r = of_int a / of_nat b" and "b > 0"
+ by (metis Fract_of_int_quotient of_int_of_nat_eq quotient_of_unique zero_less_imp_eq_int)
+
+ define s where "s = lcm b (lcm (fpxs_root_order f) (fpxs_root_order g))"
+ have "s > 0" using \<open>b > 0\<close>
+ by (auto simp: s_def intro!: Nat.gr0I)
+ obtain f' where f: "f = fpxs_compose_power (fpxs_of_fls f') (1 / rat_of_nat s)"
+ using fpxs_as_fls'[of f s] \<open>s > 0\<close> by (auto simp: s_def)
+ obtain g' where g: "g = fpxs_compose_power (fpxs_of_fls g') (1 / rat_of_nat s)"
+ using fpxs_as_fls'[of g s] \<open>s > 0\<close> by (auto simp: s_def)
+
+ define n where "n = (a * s) div b"
+ have "b dvd s"
+ by (auto simp: s_def)
+ have sr_eq: "r * rat_of_nat s = rat_of_int n"
+ using \<open>b > 0\<close> \<open>b dvd s\<close>
+ by (simp add: ab field_simps of_rat_divide of_rat_mult n_def rat_of_int_div_dvd)
+
+ show "f * fpxs_shift r g = fpxs_shift r (f * g)" "fpxs_shift r f * g = fpxs_shift r (f * g)"
+ unfolding f g using \<open>s > 0\<close>
+ by (simp_all flip: fpxs_compose_power_mult fpxs_of_fls_mult fpxs_of_fls_shift
+ add: sr_eq fls_shifted_times_simps mult_ac)
+qed
+
+lemma fpxs_shift_1: "fpxs_shift r 1 = fpxs_X_power (-r)"
+ by transfer (auto simp: fun_eq_iff)
+
+lemma fpxs_X_power_conv_shift: "fpxs_X_power r = fpxs_shift (-r) 1"
+ by (simp add: fpxs_shift_1)
+
+lemma fpxs_shift_power [simp]: "fpxs_shift n x ^ m = fpxs_shift (of_nat m * n) (x ^ m)"
+ by (induction m) (simp_all add: algebra_simps fpxs_shift_mult flip: fpxs_shift_add_left)
+
+lemma fpxs_compose_power_X_power [simp]:
+ "s > 0 \<Longrightarrow> fpxs_compose_power (fpxs_X_power r) s = fpxs_X_power (r * s)"
+ by transfer (simp add: field_simps)
+
+
+subsection \<open>The \<open>n\<close>-th root of a Puiseux series\<close>
+
+text \<open>
+ In this section, we define the formal root of a Puiseux series. This is done using the
+ same concept for formal power series. There is still one interesting theorems that is missing
+ here, e.g.\ the uniqueness (which could probably be lifted over from FPSs) somehow.
+\<close>
+
+definition fpxs_radical :: "(nat \<Rightarrow> 'a :: field_char_0 \<Rightarrow> 'a) \<Rightarrow> nat \<Rightarrow> 'a fpxs \<Rightarrow> 'a fpxs" where
+ "fpxs_radical rt r f = (if f = 0 then 0 else
+ (let f' = fls_base_factor_to_fps (fls_of_fpxs f);
+ f'' = fpxs_of_fls (fps_to_fls (fps_radical rt r f'))
+ in fpxs_shift (-fpxs_val f / rat_of_nat r)
+ (fpxs_compose_power f'' (1 / rat_of_nat (fpxs_root_order f)))))"
+
+lemma fpxs_radical_0 [simp]: "fpxs_radical rt r 0 = 0"
+ by (simp add: fpxs_radical_def)
+
+lemma
+ fixes r :: nat
+ assumes r: "r > 0"
+ shows fpxs_power_radical:
+ "rt r (fpxs_nth f (fpxs_val f)) ^ r = fpxs_nth f (fpxs_val f) \<Longrightarrow> fpxs_radical rt r f ^ r = f"
+ and fpxs_radical_lead_coeff:
+ "f \<noteq> 0 \<Longrightarrow> fpxs_nth (fpxs_radical rt r f) (fpxs_val f / rat_of_nat r) =
+ rt r (fpxs_nth f (fpxs_val f))"
+proof -
+ define q where "q = fpxs_root_order f"
+ define f' where "f' = fls_base_factor_to_fps (fls_of_fpxs f)"
+ have [simp]: "fps_nth f' 0 = fpxs_nth f (fpxs_val f)"
+ by (simp add: f'_def fls_nth_of_fpxs of_int_fls_subdegree_of_fpxs)
+ define f'' where "f'' = fpxs_of_fls (fps_to_fls (fps_radical rt r f'))"
+ have eq1: "fls_of_fpxs f = fls_shift (-fls_subdegree (fls_of_fpxs f)) (fps_to_fls f')"
+ by (subst fls_conv_base_factor_to_fps_shift_subdegree) (simp add: f'_def)
+ have eq2: "fpxs_compose_power (fpxs_of_fls (fls_of_fpxs f)) (1 / of_nat q) = f"
+ unfolding q_def by (rule fpxs_as_fls)
+ also note eq1
+ also have "fpxs_of_fls (fls_shift (- fls_subdegree (fls_of_fpxs f)) (fps_to_fls f')) =
+ fpxs_shift (- (fpxs_val f * rat_of_nat q)) (fpxs_of_fls (fps_to_fls f'))"
+ by (simp add: of_int_fls_subdegree_of_fpxs q_def)
+ finally have eq3: "fpxs_compose_power (fpxs_shift (- (fpxs_val f * rat_of_nat q))
+ (fpxs_of_fls (fps_to_fls f'))) (1 / rat_of_nat q) = f" .
+
+ {
+ assume rt: "rt r (fpxs_nth f (fpxs_val f)) ^ r = fpxs_nth f (fpxs_val f)"
+ show "fpxs_radical rt r f ^ r = f"
+ proof (cases "f = 0")
+ case [simp]: False
+ have "f'' ^ r = fpxs_of_fls (fps_to_fls (fps_radical rt r f' ^ r))"
+ by (simp add: fps_to_fls_power f''_def)
+ also have "fps_radical rt r f' ^ r = f'"
+ using power_radical[of f' rt "r - 1"] r rt by (simp add: fpxs_nth_val_nonzero)
+ finally have "f'' ^ r = fpxs_of_fls (fps_to_fls f')" .
+
+ have "fpxs_shift (-fpxs_val f / rat_of_nat r) (fpxs_compose_power f'' (1 / of_nat q)) ^ r =
+ fpxs_shift (-fpxs_val f) (fpxs_compose_power (f'' ^ r) (1 / of_nat q))"
+ unfolding q_def using r
+ by (subst fpxs_shift_power, subst fpxs_compose_power_power [symmetric]) simp_all
+ also have "f'' ^ r = fpxs_of_fls (fps_to_fls f')"
+ by fact
+ also have "fpxs_shift (-fpxs_val f) (fpxs_compose_power
+ (fpxs_of_fls (fps_to_fls f')) (1 / of_nat q)) = f"
+ using r eq3 by simp
+ finally show "fpxs_radical rt r f ^ r = f"
+ by (simp add: fpxs_radical_def f'_def f''_def q_def)
+ qed (use r in auto)
+ }
+
+ assume [simp]: "f \<noteq> 0"
+ have "fpxs_nth (fpxs_shift (-fpxs_val f / of_nat r) (fpxs_compose_power f'' (1 / of_nat q)))
+ (fpxs_val f / of_nat r) = fpxs_nth f'' 0"
+ using r by (simp add: q_def)
+ also have "fpxs_shift (-fpxs_val f / of_nat r) (fpxs_compose_power f'' (1 / of_nat q)) =
+ fpxs_radical rt r f"
+ by (simp add: fpxs_radical_def q_def f'_def f''_def)
+ also have "fpxs_nth f'' 0 = rt r (fpxs_nth f (fpxs_val f))"
+ using r by (simp add: f''_def fpxs_nth_of_fls)
+ finally show "fpxs_nth (fpxs_radical rt r f) (fpxs_val f / rat_of_nat r) =
+ rt r (fpxs_nth f (fpxs_val f))" .
+qed
+
+lemma fls_base_factor_power:
+ fixes f :: "'a::{semiring_1, semiring_no_zero_divisors} fls"
+ shows "fls_base_factor (f ^ n) = fls_base_factor f ^ n"
+proof (cases "f = 0")
+ case False
+ have [simp]: "f ^ n \<noteq> 0" for n
+ by (induction n) (use False in auto)
+ show ?thesis using False
+ by (induction n) (auto simp: fls_base_factor_mult simp flip: fls_times_both_shifted_simp)
+qed (cases n; simp)
+
+(* TODO: Uniqueness of radical. Also: composition and composition inverse *)
+
+hide_const (open) supp
+
+
+subsection \<open>Algebraic closedness\<close>
+
+text \<open>
+ We will now show that the field of formal Puiseux series over an algebraically closed field of
+ characteristic 0 is again algebraically closed.
+
+ The typeclass constraint \<^class>\<open>field_gcd\<close> is a technical constraint that mandates that
+ the field has a (trivial) GCD operation defined on it. It comes from some peculiarities of
+ Isabelle's typeclass system and can be considered unimportant, since any concrete type of
+ class \<^class>\<open>field\<close> can easily be made an instance of \<^class>\<open>field_gcd\<close>.
+
+ It would be possible to get rid of this constraint entirely here, but it is not worth
+ the effort.
+
+ The proof is a fairly standard one that uses Hensel's lemma. Some preliminary tricks are
+ required to be able to use it, however, namely a number of non-obvious changes of variables
+ to turn the polynomial with Puiseux coefficients into one with formal power series coefficients.
+ The overall approach was taken from an article by Nowak~\cite{nowak2000}.
+
+ Basically, what we need to show is this: Let
+ \[p(X,Z) = a_n(Z) X^n + a_{n-1}(Z) X^{n-1} + \ldots + a_0(Z)\]
+ be a polynomial in \<open>X\<close> of degree at least 2
+ with coefficients that are formal Puiseux series in \<open>Z\<close>. Then \<open>p\<close> is reducible, i.e. it splits
+ into two non-constant factors.
+
+ Due to work we have already done elsewhere, we may assume here that $a_n = 1$, $a_{n-1} = 0$, and
+ $a_0 \neq 0$, all of which will come in very useful.
+\<close>
+
+instance fpxs :: ("{alg_closed_field, field_char_0, field_gcd}") alg_closed_field
+proof (rule alg_closedI_reducible_coeff_deg_minus_one_eq_0)
+ fix p :: "'a fpxs poly"
+ assume deg_p: "degree p > 1" and lc_p: "lead_coeff p = 1"
+ assume coeff_deg_minus_1: "coeff p (degree p - 1) = 0"
+ assume "coeff p 0 \<noteq> 0"
+ define N where "N = degree p"
+
+ text \<open>
+ Let $a_0, \ldots, a_n$ be the coefficients of \<open>p\<close> with $a_n = 1$. Now let \<open>r\<close> be the maximum of
+ $-\frac{\text{val}(a_i)}{n-i}$ ranging over all $i < n$ such that $a_i \neq 0$.
+ \<close>
+ define r :: rat
+ where "r = (MAX i\<in>{i\<in>{..<N}. coeff p i \<noteq> 0}.
+ -fpxs_val (poly.coeff p i) / (rat_of_nat N - rat_of_nat i))"
+
+ text \<open>
+ We write $r = a / b$ such that all the $a_i$ can be written as Laurent series in
+ $X^{1/b}$, i.e. the root orders of all the $a_i$ divide $b$:
+ \<close>
+ obtain a b where ab: "b > 0" "r = of_int a / of_nat b" "\<forall>i\<le>N. fpxs_root_order (coeff p i) dvd b"
+ proof -
+ define b where "b = lcm (nat (snd (quotient_of r))) (LCM i\<in>{..N}. fpxs_root_order (coeff p i))"
+ define x where "x = b div nat (snd (quotient_of r))"
+ define a where "a = fst (quotient_of r) * int x"
+
+ show ?thesis
+ proof (rule that)
+ show "b > 0"
+ using quotient_of_denom_pos'[of r] by (auto simp: b_def intro!: Nat.gr0I)
+ have b_eq: "b = nat (snd (quotient_of r)) * x"
+ by (simp add: x_def b_def)
+ have "x > 0"
+ using b_eq \<open>b > 0\<close> by (auto intro!: Nat.gr0I)
+ have "r = rat_of_int (fst (quotient_of r)) / rat_of_int (int (nat (snd (quotient_of r))))"
+ using quotient_of_denom_pos'[of r] quotient_of_div[of r] by simp
+ also have "\<dots> = rat_of_int a / rat_of_nat b"
+ using \<open>x > 0\<close> by (simp add: a_def b_eq)
+ finally show "r = rat_of_int a / rat_of_nat b" .
+ show "\<forall>i\<le>N. fpxs_root_order (poly.coeff p i) dvd b"
+ by (auto simp: b_def)
+ qed
+ qed
+
+ text \<open>
+ We write all the coefficients of \<open>p\<close> as Laurent series in $X^{1/b}$:
+ \<close>
+ have "\<exists>c. coeff p i = fpxs_compose_power (fpxs_of_fls c) (1 / rat_of_nat b)" if i: "i \<le> N" for i
+ proof -
+ have "fpxs_root_order (coeff p i) dvd b"
+ using ab(3) i by auto
+ from fpxs_as_fls'[OF this \<open>b > 0\<close>] show ?thesis by metis
+ qed
+ then obtain c_aux where c_aux:
+ "coeff p i = fpxs_compose_power (fpxs_of_fls (c_aux i)) (1 / rat_of_nat b)" if "i \<le> N" for i
+ by metis
+ define c where "c = (\<lambda>i. if i \<le> N then c_aux i else 0)"
+ have c: "coeff p i = fpxs_compose_power (fpxs_of_fls (c i)) (1 / rat_of_nat b)" for i
+ using c_aux[of i] by (auto simp: c_def N_def coeff_eq_0)
+ have c_eq_0 [simp]: "c i = 0" if "i > N" for i
+ using that by (auto simp: c_def)
+ have c_eq: "fpxs_of_fls (c i) = fpxs_compose_power (coeff p i) (rat_of_nat b)" for i
+ using c[of i] \<open>b > 0\<close> by (simp add: fpxs_compose_power_distrib)
+
+ text \<open>
+ We perform another change of variables and multiply with a suitable power of \<open>X\<close> to turn our
+ Laurent coefficients into FPS coefficients:
+ \<close>
+ define c' where "c' = (\<lambda>i. fls_X_intpow ((int N - int i) * a) * c i)"
+ have "c' N = 1"
+ using c[of N] \<open>lead_coeff p = 1\<close> \<open>b > 0\<close> by (simp add: c'_def N_def)
+
+ have subdegree_c: "of_int (fls_subdegree (c i)) = fpxs_val (coeff p i) * rat_of_nat b"
+ if i: "i \<le> N" for i
+ proof -
+ have "rat_of_int (fls_subdegree (c i)) = fpxs_val (fpxs_of_fls (c i))"
+ by simp
+ also have "fpxs_of_fls (c i) = fpxs_compose_power (poly.coeff p i) (rat_of_nat b)"
+ by (subst c_eq) auto
+ also have "fpxs_val \<dots> = fpxs_val (coeff p i) * rat_of_nat b"
+ using \<open>b > 0\<close> by simp
+ finally show ?thesis .
+ qed
+
+ text \<open>
+ We now write all the coefficients as FPSs:
+ \<close>
+ have "\<exists>c''. c' i = fps_to_fls c''" if "i \<le> N" for i
+ proof (cases "i = N")
+ case True
+ hence "c' i = fps_to_fls 1"
+ using \<open>c' N = 1\<close> by simp
+ thus ?thesis by metis
+ next
+ case i: False
+ show ?thesis
+ proof (cases "c i = 0")
+ case True
+ hence "c' i = 0" by (auto simp: c'_def)
+ thus ?thesis by auto
+ next
+ case False
+ hence "coeff p i \<noteq> 0"
+ using c_eq[of i] by auto
+ hence r_ge: "r \<ge> -fpxs_val (poly.coeff p i) / (rat_of_nat N - rat_of_nat i)"
+ unfolding r_def using i that False by (intro Max.coboundedI) auto
+
+ have "fls_subdegree (c' i) = fls_subdegree (c i) + (int N - int i) * a"
+ using i that False by (simp add: c'_def fls_X_intpow_times_conv_shift subdegree_c)
+ also have "rat_of_int \<dots> =
+ fpxs_val (poly.coeff p i) * of_nat b + (of_nat N - of_nat i) * of_int a"
+ using i that False by (simp add: subdegree_c)
+ also have "\<dots> = of_nat b * (of_nat N - of_nat i) *
+ (fpxs_val (poly.coeff p i) / (of_nat N - of_nat i) + r)"
+ using \<open>b > 0\<close> i by (auto simp: field_simps ab(2))
+ also have "\<dots> \<ge> 0"
+ using r_ge that by (intro mult_nonneg_nonneg) auto
+ finally have "fls_subdegree (c' i) \<ge> 0" by simp
+ hence "\<exists>c''. c' i = fls_shift 0 (fps_to_fls c'')"
+ by (intro fls_as_fps') (auto simp: algebra_simps)
+ thus ?thesis by simp
+ qed
+ qed
+ then obtain c''_aux where c''_aux: "c' i = fps_to_fls (c''_aux i)" if "i \<le> N" for i
+ by metis
+ define c'' where "c'' = (\<lambda>i. if i \<le> N then c''_aux i else 0)"
+ have c': "c' i = fps_to_fls (c'' i)" for i
+ proof (cases "i \<le> N")
+ case False
+ thus ?thesis by (auto simp: c'_def c''_def)
+ qed (auto simp: c''_def c''_aux)
+ have c''_eq: "fps_to_fls (c'' i) = c' i" for i
+ using c'[of i] by simp
+
+ define p' where "p' = Abs_poly c''"
+ have coeff_p': "coeff p' = c''"
+ unfolding p'_def
+ proof (rule coeff_Abs_poly)
+ fix i assume "i > N"
+ hence "coeff p i = 0"
+ by (simp add: N_def coeff_eq_0)
+ thus "c'' i = 0" using c'[of i] c[of i] \<open>b > 0\<close>
+ by (auto simp: c'_def fls_shift_eq0_iff)
+ qed
+
+ text \<open>
+ We set up some homomorphisms to convert between the two polynomials:
+ \<close>
+ interpret comppow: map_poly_inj_idom_hom "(\<lambda>x::'a fpxs. fpxs_compose_power x (1/rat_of_nat b))"
+ by unfold_locales (use \<open>b > 0\<close> in simp_all)
+ define lift_poly :: "'a fps poly \<Rightarrow> 'a fpxs poly" where
+ "lift_poly = (\<lambda>p. pcompose p [:0, fpxs_X_power r:]) \<circ>
+ (map_poly ((\<lambda>x. fpxs_compose_power x (1/rat_of_nat b)) \<circ> fpxs_of_fls \<circ> fps_to_fls))"
+ have [simp]: "degree (lift_poly q) = degree q" for q
+ unfolding lift_poly_def by (simp add: degree_map_poly)
+
+ interpret fps_to_fls: map_poly_inj_idom_hom fps_to_fls
+ by unfold_locales (simp_all add: fls_times_fps_to_fls)
+ interpret fpxs_of_fls: map_poly_inj_idom_hom fpxs_of_fls
+ by unfold_locales simp_all
+ interpret lift_poly: inj_idom_hom lift_poly
+ unfolding lift_poly_def
+ by (intro inj_idom_hom_compose inj_idom_hom_pcompose inj_idom_hom.inj_idom_hom_map_poly
+ fps_to_fls.base.inj_idom_hom_axioms fpxs_of_fls.base.inj_idom_hom_axioms
+ comppow.base.inj_idom_hom_axioms) simp_all
+ interpret lift_poly: map_poly_inj_idom_hom lift_poly
+ by unfold_locales
+
+ define C :: "'a fpxs" where "C = fpxs_X_power (- (rat_of_nat N * r))"
+ have [simp]: "C \<noteq> 0"
+ by (auto simp: C_def)
+
+ text \<open>
+ Now, finally: the original polynomial and the new polynomial are related through the
+ \<^term>\<open>lift_poly\<close> homomorphism:
+ \<close>
+ have p_eq: "p = smult C (lift_poly p')"
+ using \<open>b > 0\<close>
+ by (intro poly_eqI)
+ (simp_all add: coeff_map_poly coeff_pcompose_linear coeff_p' c c''_eq c'_def C_def
+ ring_distribs fpxs_X_power_conv_shift fpxs_shift_mult lift_poly_def ab(2)
+ flip: fpxs_X_power_add fpxs_X_power_mult fpxs_shift_add_left)
+ have [simp]: "degree p' = N"
+ unfolding N_def using \<open>b > 0\<close> by (simp add: p_eq)
+ have lc_p': "lead_coeff p' = 1"
+ using c''_eq[of N] by (simp add: coeff_p' \<open>c' N = 1\<close>)
+ have "coeff p' (N - 1) = 0"
+ using coeff_deg_minus_1 \<open>b > 0\<close> unfolding N_def [symmetric]
+ by (simp add: p_eq lift_poly_def coeff_map_poly coeff_pcompose_linear)
+
+ text \<open>
+ We reduce $p'(X,Z)$ to $p'(X,0)$:
+ \<close>
+ define p'_proj where "p'_proj = reduce_fps_poly p'"
+ have [simp]: "degree p'_proj = N"
+ unfolding p'_proj_def using lc_p' by (subst degree_reduce_fps_poly_monic) simp_all
+ have lc_p'_proj: "lead_coeff p'_proj = 1"
+ unfolding p'_proj_def using lc_p' by (subst reduce_fps_poly_monic) simp_all
+ hence [simp]: "p'_proj \<noteq> 0"
+ by auto
+ have "coeff p'_proj (N - 1) = 0"
+ using \<open>coeff p' (N - 1) = 0\<close> by (simp add: p'_proj_def reduce_fps_poly_def)
+
+ text \<open>
+ We now show that \<^term>\<open>p'_proj\<close> splits into non-trivial coprime factors. To do this, we
+ have to show that it has two distinct roots, i.e. that it is not of the form $(X - c)^n$.
+ \<close>
+ obtain g h where gh: "degree g > 0" "degree h > 0" "coprime g h" "p'_proj = g * h"
+ proof -
+ have "degree p'_proj > 1"
+ using deg_p by (auto simp: N_def)
+ text \<open>Let \<open>x\<close> be an arbitrary root of \<^term>\<open>p'_proj\<close>:\<close>
+ then obtain x where x: "poly p'_proj x = 0"
+ using alg_closed_imp_poly_has_root[of p'_proj] by force
+
+ text \<open>Assume for the sake of contradiction that \<^term>\<open>p'_proj\<close> were equal to $(1-x)^n$:\<close>
+ have not_only_one_root: "p'_proj \<noteq> [:-x, 1:] ^ N"
+ proof safe
+ assume *: "p'_proj = [:-x, 1:] ^ N"
+
+ text \<open>
+ If \<open>x\<close> were non-zero, all the coefficients of \<open>p'_proj\<close> would also be non-zero by the
+ Binomial Theorem. Since we know that the coefficient of \<open>n - 1\<close> \<^emph>\<open>is\<close> zero, this means
+ that \<open>x\<close> must be zero:
+ \<close>
+ have "coeff p'_proj (N - 1) = 0" by fact
+ hence "x = 0"
+ by (subst (asm) *, subst (asm) coeff_linear_poly_power) auto
+
+ text \<open>
+ However, by our choice of \<open>r\<close>, we know that there is an index \<open>i\<close> such that \<open>c' i\<close> has
+ is non-zero and has valuation (i.e. subdegree) 0, which means that the \<open>i\<close>-th coefficient
+ of \<^term>\<open>p'_proj\<close> must also be non-zero.
+ \<close>
+ have "0 < N \<and> coeff p 0 \<noteq> 0"
+ using deg_p \<open>coeff p 0 \<noteq> 0\<close> by (auto simp: N_def)
+ hence "{i\<in>{..<N}. coeff p i \<noteq> 0} \<noteq> {}"
+ by blast
+ hence "r \<in> (\<lambda>i. -fpxs_val (poly.coeff p i) / (rat_of_nat N - rat_of_nat i)) `
+ {i\<in>{..<N}. coeff p i \<noteq> 0}"
+ unfolding r_def using deg_p by (intro Max_in) (auto simp: N_def)
+ then obtain i where i: "i < N" "coeff p i \<noteq> 0"
+ "-fpxs_val (coeff p i) / (rat_of_nat N - rat_of_nat i) = r"
+ by blast
+ hence [simp]: "c' i \<noteq> 0"
+ using i c[of i] by (auto simp: c'_def)
+ have "fpxs_val (poly.coeff p i) = rat_of_int (fls_subdegree (c i)) / rat_of_nat b"
+ using subdegree_c[of i] i \<open>b > 0\<close> by (simp add: field_simps)
+ also have "fpxs_val (coeff p i) = -r * (rat_of_nat N - rat_of_nat i)"
+ using i by (simp add: field_simps)
+ finally have "rat_of_int (fls_subdegree (c i)) = - r * (of_nat N - of_nat i) * of_nat b"
+ using \<open>b > 0\<close> by (simp add: field_simps)
+ also have "c i = fls_shift ((int N - int i) * a) (c' i)"
+ using i by (simp add: c'_def ring_distribs fls_X_intpow_times_conv_shift
+ flip: fls_shifted_times_simps(2))
+ also have "fls_subdegree \<dots> = fls_subdegree (c' i) - (int N - int i) * a"
+ by (subst fls_shift_subdegree) auto
+ finally have "fls_subdegree (c' i) = 0"
+ using \<open>b > 0\<close> by (simp add: ab(2))
+ hence "subdegree (coeff p' i) = 0"
+ by (simp flip: c''_eq add: fls_subdegree_fls_to_fps coeff_p')
+ moreover have "coeff p' i \<noteq> 0"
+ using \<open>c' i \<noteq> 0\<close> c' coeff_p' by auto
+ ultimately have "coeff p' i $ 0 \<noteq> 0"
+ using subdegree_eq_0_iff by blast
+
+ also have "coeff p' i $ 0 = coeff p'_proj i"
+ by (simp add: p'_proj_def reduce_fps_poly_def)
+ also have "\<dots> = 0"
+ by (subst *, subst coeff_linear_poly_power) (use i \<open>x = 0\<close> in auto)
+ finally show False by simp
+ qed
+
+ text \<open>
+ We can thus obtain our second root \<open>y\<close> from the factorisation:
+ \<close>
+ have "\<exists>y. x \<noteq> y \<and> poly p'_proj y = 0"
+ proof (rule ccontr)
+ assume *: "\<not>(\<exists>y. x \<noteq> y \<and> poly p'_proj y = 0)"
+ have "p'_proj \<noteq> 0" by simp
+ then obtain A where A: "size A = degree p'_proj"
+ "p'_proj = smult (lead_coeff p'_proj) (\<Prod>x\<in>#A. [:-x, 1:])"
+ using alg_closed_imp_factorization[of p'_proj] by blast
+ have "set_mset A = {x. poly p'_proj x = 0}"
+ using lc_p'_proj by (subst A) (auto simp: poly_prod_mset)
+ also have "\<dots> = {x}"
+ using x * by auto
+ finally have "A = replicate_mset N x"
+ using set_mset_subset_singletonD[of A x] A(1) by simp
+ with A(2) have "p'_proj = [:- x, 1:] ^ N"
+ using lc_p'_proj by simp
+ with not_only_one_root show False
+ by contradiction
+ qed
+ then obtain y where "x \<noteq> y" "poly p'_proj y = 0"
+ by blast
+
+ text \<open>
+ It now follows easily that \<^term>\<open>p'_proj\<close> splits into non-trivial and coprime factors:
+ \<close>
+ show ?thesis
+ proof (rule alg_closed_imp_poly_splits_coprime)
+ show "degree p'_proj > 1"
+ using deg_p by (simp add: N_def)
+ show "x \<noteq> y" "poly p'_proj x = 0" "poly p'_proj y = 0"
+ by fact+
+ qed (use that in metis)
+ qed
+
+ text \<open>
+ By Hensel's lemma, these factors give rise to corresponding factors of \<open>p'\<close>:
+ \<close>
+ interpret hensel: fps_hensel p' p'_proj g h
+ proof unfold_locales
+ show "lead_coeff p' = 1"
+ using lc_p' by simp
+ qed (use gh \<open>coprime g h\<close> in \<open>simp_all add: p'_proj_def\<close>)
+
+ text \<open>All that remains now is to undo the variable substitutions we did above:\<close>
+ have "p = [:C:] * lift_poly hensel.G * lift_poly hensel.H"
+ unfolding p_eq by (subst hensel.F_splits) (simp add: hom_distribs)
+ thus "\<not>irreducible p"
+ by (rule reducible_polyI) (use hensel.deg_G hensel.deg_H gh in simp_all)
+qed
+
+text \<open>
+ We do not actually show that this is the algebraic closure since this cannot be stated
+ idiomatically in the typeclass setting and is probably not very useful either, but it can
+ be motivated like this:
+
+ Suppose we have an algebraically closed extension $L$ of the field of Laurent series. Clearly,
+ $X^{a/b}\in L$ for any integer \<open>a\<close> and any positive integer \<open>b\<close> since
+ $(X^{a/b})^b - X^a = 0$. But any Puiseux series $F(X)$ with root order \<open>b\<close> can
+ be written as
+ \[F(X) = \sum_{k=0}^{b-1} X^{k/b} F_k(X)\]
+ where the Laurent series $F_k(X)$ are defined as follows:
+ \[F_k(X) := \sum_{n = n_{0,k}}^\infty [X^{n + k/b}] F(X) X^n\]
+ Thus, $F(X)$ can be written as a finite sum of products of elements in $L$ and must therefore
+ also be in $L$. Thus, the Puiseux series are all contained in $L$.
+\<close>
+
+
+subsection \<open>Metric and topology\<close>
+
+text \<open>
+ Formal Puiseux series form a metric space with the usual metric for formal series:
+ Two series are ``close'' to one another if they have many initial coefficients in common.
+\<close>
+
+instantiation fpxs :: (zero) norm
+begin
+
+definition norm_fpxs :: "'a fpxs \<Rightarrow> real" where
+ "norm f = (if f = 0 then 0 else 2 powr (-of_rat (fpxs_val f)))"
+
+instance ..
+
+end
+
+
+instantiation fpxs :: (group_add) dist
+begin
+
+definition dist_fpxs :: "'a fpxs \<Rightarrow> 'a fpxs \<Rightarrow> real" where
+ "dist f g = (if f = g then 0 else 2 powr (-of_rat (fpxs_val (f - g))))"
+
+instance ..
+
+end
+
+
+instantiation fpxs :: (group_add) metric_space
+begin
+
+definition uniformity_fpxs_def [code del]:
+ "(uniformity :: ('a fpxs \<times> 'a fpxs) filter) = (INF e\<in>{0 <..}. principal {(x, y). dist x y < e})"
+
+definition open_fpxs_def [code del]:
+ "open (U :: 'a fpxs set) \<longleftrightarrow> (\<forall>x\<in>U. eventually (\<lambda>(x', y). x' = x \<longrightarrow> y \<in> U) uniformity)"
+
+instance proof
+ fix f g h :: "'a fpxs"
+ show "dist f g \<le> dist f h + dist g h"
+ proof (cases "f \<noteq> g \<and> f \<noteq> h \<and> g \<noteq> h")
+ case True
+ have "dist f g \<le> 2 powr -real_of_rat (min (fpxs_val (f - h)) (fpxs_val (g - h)))"
+ using fpxs_val_add_ge[of "f - h" "h - g"] True
+ by (auto simp: algebra_simps fpxs_val_minus_commute dist_fpxs_def of_rat_less_eq)
+ also have "\<dots> \<le> dist f h + dist g h"
+ using True by (simp add: dist_fpxs_def min_def)
+ finally show ?thesis .
+ qed (auto simp: dist_fpxs_def fpxs_val_minus_commute)
+qed (simp_all add: uniformity_fpxs_def open_fpxs_def dist_fpxs_def)
+
+end
+
+
+instance fpxs :: (group_add) dist_norm
+ by standard (auto simp: dist_fpxs_def norm_fpxs_def)
+
+end
\ No newline at end of file
diff --git a/thys/Formal_Puiseux_Series/Puiseux_Laurent_Library.thy b/thys/Formal_Puiseux_Series/Puiseux_Laurent_Library.thy
new file mode 100644
--- /dev/null
+++ b/thys/Formal_Puiseux_Series/Puiseux_Laurent_Library.thy
@@ -0,0 +1,212 @@
+(*
+ File: Puiseux_Laurent_Library.thy
+ Author: Manuel Eberl, TU München
+*)
+subsection \<open>Facts about Laurent series\<close>
+theory Puiseux_Laurent_Library
+ imports "HOL-Computational_Algebra.Computational_Algebra"
+begin
+
+lemma filterlim_at_top_div_const_nat:
+ assumes "c > 0"
+ shows "filterlim (\<lambda>x::nat. x div c) at_top at_top"
+ unfolding filterlim_at_top
+proof
+ fix C :: nat
+ have *: "n div c \<ge> C" if "n \<ge> C * c" for n
+ using assms that by (metis div_le_mono div_mult_self_is_m)
+ have "eventually (\<lambda>n. n \<ge> C * c) at_top"
+ by (rule eventually_ge_at_top)
+ thus "eventually (\<lambda>n. n div c \<ge> C) at_top"
+ by eventually_elim (use * in auto)
+qed
+
+lemma fls_eq_iff: "f = g \<longleftrightarrow> (\<forall>n. fls_nth f n = fls_nth g n)"
+ by transfer auto
+
+lemma fls_shift_eq_1_iff: "fls_shift n f = 1 \<longleftrightarrow> f = fls_shift (-n) 1"
+proof -
+ have "fls_shift n f = 1 \<longleftrightarrow> fls_shift n f = fls_shift n (fls_shift (-n) 1)"
+ by (simp del: fls_shift_eq_iff)
+ also have "\<dots> \<longleftrightarrow> f = fls_shift (-n) 1"
+ by (subst fls_shift_eq_iff) auto
+ finally show ?thesis .
+qed
+
+lemma fps_to_fls_eq_iff [simp]: "fps_to_fls f = fps_to_fls g \<longleftrightarrow> f = g"
+proof safe
+ assume "fps_to_fls f = fps_to_fls g"
+ hence *: "n < 0 \<or> f $ nat n = g $ nat n" for n
+ by (force simp: fls_eq_iff split: if_splits)
+ have "f $ n = g $ n" for n
+ using *[of "int n"] by auto
+ thus "f = g"
+ by (auto simp: fps_eq_iff)
+qed
+
+lemma fps_to_fls_eq_0_iff [simp]: "fps_to_fls f = 0 \<longleftrightarrow> f = 0"
+ using fps_to_fls_eq_iff[of f 0] by (simp del: fps_to_fls_eq_iff)
+
+lemma fps_to_fls_eq_1_iff [simp]: "fps_to_fls f = 1 \<longleftrightarrow> f = 1"
+ using fps_to_fls_eq_iff[of f 1] by (simp del: fps_to_fls_eq_iff)
+
+lemma fps_to_fls_power: "fps_to_fls (f ^ n) = fps_to_fls f ^ n"
+ by (induction n) (auto simp: fls_times_fps_to_fls)
+
+lemma fls_as_fps:
+ fixes f :: "'a :: zero fls" and n :: int
+ assumes n: "n \<ge> -fls_subdegree f"
+ obtains f' where "f = fls_shift n (fps_to_fls f')"
+proof -
+ have "fls_subdegree (fls_shift (- n) f) \<ge> 0"
+ by (rule fls_shift_nonneg_subdegree) (use n in simp)
+ hence "f = fls_shift n (fps_to_fls (fls_regpart (fls_shift (-n) f)))"
+ by (subst fls_regpart_to_fls_trivial) simp_all
+ thus ?thesis
+ by (rule that)
+qed
+
+lemma fls_as_fps':
+ fixes f :: "'a :: zero fls" and n :: int
+ assumes n: "n \<ge> -fls_subdegree f"
+ shows "\<exists>f'. f = fls_shift n (fps_to_fls f')"
+ using fls_as_fps[OF assms] by metis
+
+
+definition fls_compose_fps :: "'a :: field fls \<Rightarrow> 'a fps \<Rightarrow> 'a fls" where
+ "fls_compose_fps f g =
+ (if f = 0 then 0
+ else if fls_subdegree f \<ge> 0 then fps_to_fls (fps_compose (fls_regpart f) g)
+ else fps_to_fls (fps_compose (fls_base_factor_to_fps f) g) /
+ fps_to_fls g ^ nat (-fls_subdegree f))"
+
+lemma fls_compose_fps_fps [simp]:
+ "fls_compose_fps (fps_to_fls f) g = fps_to_fls (fps_compose f g)"
+ by (auto simp: fls_compose_fps_def fls_subdegree_fls_to_fps)
+
+lemma fls_const_transfer [transfer_rule]:
+ "rel_fun (=) (pcr_fls (=))
+ (\<lambda>c n. if n = 0 then c else 0) fls_const"
+ by (auto simp: fls_const_def rel_fun_def pcr_fls_def OO_def cr_fls_def)
+
+lemma fls_shift_transfer [transfer_rule]:
+ "rel_fun (=) (rel_fun (pcr_fls (=)) (pcr_fls (=)))
+ (\<lambda>n f k. f (k+n)) fls_shift"
+ by (auto simp: fls_const_def rel_fun_def pcr_fls_def OO_def cr_fls_def)
+
+lift_definition fls_compose_power :: "'a :: zero fls \<Rightarrow> nat \<Rightarrow> 'a fls" is
+ "\<lambda>f d n. if d > 0 \<and> int d dvd n then f (n div int d) else 0"
+proof -
+ fix f :: "int \<Rightarrow> 'a" and d :: nat
+ assume *: "eventually (\<lambda>n. f (-int n) = 0) cofinite"
+ show "eventually (\<lambda>n. (if d > 0 \<and> int d dvd -int n then f (-int n div int d) else 0) = 0) cofinite"
+ proof (cases "d = 0")
+ case False
+ from * have "eventually (\<lambda>n. f (-int n) = 0) at_top"
+ by (simp add: cofinite_eq_sequentially)
+ hence "eventually (\<lambda>n. f (-int (n div d)) = 0) at_top"
+ by (rule eventually_compose_filterlim[OF _ filterlim_at_top_div_const_nat]) (use False in auto)
+ hence "eventually (\<lambda>n. (if d > 0 \<and> int d dvd -int n then f (-int n div int d) else 0) = 0) at_top"
+ by eventually_elim (auto simp: zdiv_int dvd_neg_div)
+ thus ?thesis
+ by (simp add: cofinite_eq_sequentially)
+ qed auto
+qed
+
+lemma fls_nth_compose_power:
+ assumes "d > 0"
+ shows "fls_nth (fls_compose_power f d) n = (if int d dvd n then fls_nth f (n div int d) else 0)"
+ using assms by transfer auto
+
+
+lemma fls_compose_power_0_left [simp]: "fls_compose_power 0 d = 0"
+ by transfer auto
+
+lemma fls_compose_power_1_left [simp]: "d > 0 \<Longrightarrow> fls_compose_power 1 d = 1"
+ by transfer (auto simp: fun_eq_iff)
+
+lemma fls_compose_power_const_left [simp]:
+ "d > 0 \<Longrightarrow> fls_compose_power (fls_const c) d = fls_const c"
+ by transfer (auto simp: fun_eq_iff)
+
+lemma fls_compose_power_shift [simp]:
+ "d > 0 \<Longrightarrow> fls_compose_power (fls_shift n f) d = fls_shift (d * n) (fls_compose_power f d)"
+ by transfer (auto simp: fun_eq_iff add_ac mult_ac)
+
+lemma fls_compose_power_X_intpow [simp]:
+ "d > 0 \<Longrightarrow> fls_compose_power (fls_X_intpow n) d = fls_X_intpow (int d * n)"
+ by simp
+
+lemma fls_compose_power_X [simp]:
+ "d > 0 \<Longrightarrow> fls_compose_power fls_X d = fls_X_intpow (int d)"
+ by transfer (auto simp: fun_eq_iff)
+
+lemma fls_compose_power_X_inv [simp]:
+ "d > 0 \<Longrightarrow> fls_compose_power fls_X_inv d = fls_X_intpow (-int d)"
+ by (simp add: fls_X_inv_conv_shift_1)
+
+lemma fls_compose_power_0_right [simp]: "fls_compose_power f 0 = 0"
+ by transfer auto
+
+lemma fls_compose_power_add [simp]:
+ "fls_compose_power (f + g) d = fls_compose_power f d + fls_compose_power g d"
+ by transfer auto
+
+lemma fls_compose_power_diff [simp]:
+ "fls_compose_power (f - g) d = fls_compose_power f d - fls_compose_power g d"
+ by transfer auto
+
+lemma fls_compose_power_uminus [simp]:
+ "fls_compose_power (-f) d = -fls_compose_power f d"
+ by transfer auto
+
+lemma fps_nth_compose_X_power:
+ "fps_nth (f oo (fps_X ^ d)) n = (if d dvd n then fps_nth f (n div d) else 0)"
+proof -
+ have "fps_nth (f oo (fps_X ^ d)) n = (\<Sum>i = 0..n. f $ i * (fps_X ^ (d * i)) $ n)"
+ unfolding fps_compose_def by (simp add: power_mult)
+ also have "\<dots> = (\<Sum>i\<in>(if d dvd n then {n div d} else {}). f $ i * (fps_X ^ (d * i)) $ n)"
+ by (intro sum.mono_neutral_right) auto
+ also have "\<dots> = (if d dvd n then fps_nth f (n div d) else 0)"
+ by auto
+ finally show ?thesis .
+qed
+
+lemma fls_compose_power_fps_to_fls:
+ assumes "d > 0"
+ shows "fls_compose_power (fps_to_fls f) d = fps_to_fls (fps_compose f (fps_X ^ d))"
+ using assms
+ by (intro fls_eqI) (auto simp: fls_nth_compose_power fps_nth_compose_X_power
+ pos_imp_zdiv_neg_iff div_neg_pos_less0 nat_div_distrib
+ simp flip: int_dvd_int_iff)
+
+lemma fls_compose_power_mult [simp]:
+ "fls_compose_power (f * g :: 'a :: idom fls) d = fls_compose_power f d * fls_compose_power g d"
+proof (cases "d > 0")
+ case True
+ define n where "n = nat (max 0 (max (- fls_subdegree f) (- fls_subdegree g)))"
+ have n_ge: "-fls_subdegree f \<le> int n" "-fls_subdegree g \<le> int n"
+ unfolding n_def by auto
+ obtain f' where f': "f = fls_shift n (fps_to_fls f')"
+ using fls_as_fps[OF n_ge(1)] by (auto simp: n_def)
+ obtain g' where g': "g = fls_shift n (fps_to_fls g')"
+ using fls_as_fps[OF n_ge(2)] by (auto simp: n_def)
+ show ?thesis using \<open>d > 0\<close>
+ by (simp add: f' g' fls_shifted_times_simps mult_ac fls_compose_power_fps_to_fls
+ fps_compose_mult_distrib flip: fls_times_fps_to_fls)
+qed auto
+
+lemma fls_compose_power_power [simp]:
+ assumes "d > 0 \<or> n > 0"
+ shows "fls_compose_power (f ^ n :: 'a :: idom fls) d = fls_compose_power f d ^ n"
+proof (cases "d > 0")
+ case True
+ thus ?thesis by (induction n) auto
+qed (use assms in auto)
+
+lemma fls_nth_compose_power' [simp]:
+ "d = 0 \<or> \<not>d dvd n \<Longrightarrow> fls_nth (fls_compose_power f d) n = 0"
+ "d dvd n \<Longrightarrow> d > 0 \<Longrightarrow> fls_nth (fls_compose_power f d) n = fls_nth f (n div d)"
+ by (transfer; force; fail)+
+
+end
\ No newline at end of file
diff --git a/thys/Formal_Puiseux_Series/Puiseux_Polynomial_Library.thy b/thys/Formal_Puiseux_Series/Puiseux_Polynomial_Library.thy
new file mode 100644
--- /dev/null
+++ b/thys/Formal_Puiseux_Series/Puiseux_Polynomial_Library.thy
@@ -0,0 +1,497 @@
+(*
+ File: Puiseux_Polynomial_Library.thy
+ Author: Manuel Eberl, TU München
+*)
+section \<open>Auxiliary material\<close>
+subsection \<open>Facts about polynomials\<close>
+theory Puiseux_Polynomial_Library
+ imports "HOL-Computational_Algebra.Computational_Algebra" "Polynomial_Interpolation.Ring_Hom_Poly"
+begin
+
+(* TODO: move a lot of this *)
+
+lemma poly_sum_mset: "poly (\<Sum>x\<in>#A. p x) y = (\<Sum>x\<in>#A. poly (p x) y)"
+ by (induction A) auto
+
+lemma poly_prod_mset: "poly (\<Prod>x\<in>#A. p x) y = (\<Prod>x\<in>#A. poly (p x) y)"
+ by (induction A) auto
+
+lemma set_mset_subset_singletonD:
+ assumes "set_mset A \<subseteq> {x}"
+ shows "A = replicate_mset (size A) x"
+ using assms by (induction A) auto
+
+lemma inj_idom_hom_compose [intro]:
+ assumes "inj_idom_hom f" "inj_idom_hom g"
+ shows "inj_idom_hom (f \<circ> g)"
+proof -
+ interpret f: inj_idom_hom f by fact
+ interpret g: inj_idom_hom g by fact
+ show ?thesis
+ by unfold_locales (auto simp: f.hom_add g.hom_add f.hom_mult g.hom_mult)
+qed
+
+lemma coeff_pcompose_linear:
+ "coeff (pcompose p [:0, a :: 'a :: comm_semiring_1:]) i = a ^ i * coeff p i"
+ by (induction p arbitrary: i) (auto simp: pcompose_pCons coeff_pCons mult_ac split: nat.splits)
+
+lemma degree_cong:
+ assumes "\<And>i. coeff p i = 0 \<longleftrightarrow> coeff q i = 0"
+ shows "degree p = degree q"
+proof -
+ have "(\<lambda>n. \<forall>i>n. poly.coeff p i = 0) = (\<lambda>n. \<forall>i>n. poly.coeff q i = 0)"
+ using assms by (auto simp: fun_eq_iff)
+ thus ?thesis
+ by (simp only: degree_def)
+qed
+
+lemma coeff_Abs_poly_If_le:
+ "coeff (Abs_poly (\<lambda>i. if i \<le> n then f i else 0)) = (\<lambda>i. if i \<le> n then f i else 0)"
+proof (rule Abs_poly_inverse, clarify)
+ have "eventually (\<lambda>i. i > n) cofinite"
+ by (auto simp: MOST_nat)
+ thus "eventually (\<lambda>i. (if i \<le> n then f i else 0) = 0) cofinite"
+ by eventually_elim auto
+qed
+
+lemma coeff_Abs_poly:
+ assumes "\<And>i. i > n \<Longrightarrow> f i = 0"
+ shows "coeff (Abs_poly f) = f"
+proof (rule Abs_poly_inverse, clarify)
+ have "eventually (\<lambda>i. i > n) cofinite"
+ by (auto simp: MOST_nat)
+ thus "eventually (\<lambda>i. f i = 0) cofinite"
+ by eventually_elim (use assms in auto)
+qed
+
+lemma (in inj_idom_hom) inj_idom_hom_map_poly [intro]: "inj_idom_hom (map_poly hom)"
+proof -
+ interpret map_poly_inj_idom_hom hom by unfold_locales
+ show ?thesis
+ by (simp add: inj_idom_hom_axioms)
+qed
+
+lemma inj_idom_hom_pcompose [intro]:
+ assumes [simp]: "degree (p :: 'a :: idom poly) \<noteq> 0"
+ shows "inj_idom_hom (\<lambda>q. pcompose q p)"
+ by unfold_locales (simp_all add: pcompose_eq_0)
+
+lemma degree_sum_less:
+ assumes "\<And>x. x \<in> A \<Longrightarrow> degree (f x) < n" "n > 0"
+ shows "degree (sum f A) < n"
+ using assms by (induction rule: infinite_finite_induct) (auto intro!: degree_add_less)
+
+lemma degree_lessI:
+ assumes "p \<noteq> 0 \<or> n > 0" "\<forall>k\<ge>n. coeff p k = 0"
+ shows "degree p < n"
+proof (cases "p = 0")
+ case False
+ show ?thesis
+ proof (rule ccontr)
+ assume *: "\<not>(degree p < n)"
+ define d where "d = degree p"
+ from \<open>p \<noteq> 0\<close> have "coeff p d \<noteq> 0"
+ by (auto simp: d_def)
+ moreover have "coeff p d = 0"
+ using assms(2) * by (auto simp: not_less)
+ ultimately show False by contradiction
+ qed
+qed (use assms in auto)
+
+lemma coeff_linear_poly_power:
+ fixes c :: "'a :: semiring_1"
+ assumes "i \<le> n"
+ shows "coeff ([:a, b:] ^ n) i = of_nat (n choose i) * b ^ i * a ^ (n - i)"
+proof -
+ have "[:a, b:] = monom b 1 + [:a:]"
+ by (simp add: monom_altdef)
+ also have "coeff (\<dots> ^ n) i = (\<Sum>k\<le>n. a^(n-k) * of_nat (n choose k) * (if k = i then b ^ k else 0))"
+ by (subst binomial_ring) (simp add: coeff_sum of_nat_poly monom_power poly_const_pow mult_ac)
+ also have "\<dots> = (\<Sum>k\<in>{i}. a ^ (n - i) * b ^ i * of_nat (n choose k))"
+ using assms by (intro sum.mono_neutral_cong_right) (auto simp: mult_ac)
+ finally show *: ?thesis by (simp add: mult_ac)
+qed
+
+lemma pcompose_altdef: "pcompose p q = poly (map_poly (\<lambda>x. [:x:]) p) q"
+ by (induction p) simp_all
+
+lemma coeff_mult_0: "coeff (p * q) 0 = coeff p 0 * coeff q 0"
+ by (simp add: coeff_mult)
+
+lemma coeff_pcompose_0 [simp]:
+ "coeff (pcompose p q) 0 = poly p (coeff q 0)"
+ by (induction p) (simp_all add: coeff_mult_0)
+
+lemma reducible_polyI:
+ fixes p :: "'a :: field poly"
+ assumes "p = q * r" "degree q > 0" "degree r > 0"
+ shows "\<not>irreducible p"
+ using assms by (auto simp: irreducible_def)
+
+lemma root_imp_reducible_poly:
+ fixes x :: "'a :: field"
+ assumes "poly p x = 0" and "degree p > 1"
+ shows "\<not>irreducible p"
+proof -
+ from assms have "p \<noteq> 0"
+ by auto
+ define q where "q = [:-x, 1:]"
+ have "q dvd p"
+ using assms by (simp add: poly_eq_0_iff_dvd q_def)
+ then obtain r where p_eq: "p = q * r"
+ by (elim dvdE)
+ have [simp]: "q \<noteq> 0" "r \<noteq> 0"
+ using \<open>p \<noteq> 0\<close> by (auto simp: p_eq)
+ have "degree p = Suc (degree r)"
+ unfolding p_eq by (subst degree_mult_eq) (auto simp: q_def)
+ with assms(2) have "degree r > 0"
+ by auto
+ hence "\<not>is_unit r"
+ by auto
+ moreover have "\<not>is_unit q"
+ by (auto simp: q_def)
+ ultimately show ?thesis using p_eq
+ by (auto simp: irreducible_def)
+qed
+
+
+subsection \<open>A typeclass for algebraically closed fields\<close>
+
+(* TODO: Move! *)
+
+text \<open>
+ Since the required sort constraints are not available inside the class, we have to resort
+ to a somewhat awkward way of writing the definition of algebraically closed fields:
+\<close>
+class alg_closed_field = field +
+ assumes alg_closed: "n > 0 \<Longrightarrow> f n \<noteq> 0 \<Longrightarrow> \<exists>x. (\<Sum>k\<le>n. f k * x ^ k) = 0"
+
+text \<open>
+ We can then however easily show the equivalence to the proper definition:
+\<close>
+lemma alg_closed_imp_poly_has_root:
+ assumes "degree (p :: 'a :: alg_closed_field poly) > 0"
+ shows "\<exists>x. poly p x = 0"
+proof -
+ have "\<exists>x. (\<Sum>k\<le>degree p. coeff p k * x ^ k) = 0"
+ using assms by (intro alg_closed) auto
+ thus ?thesis
+ by (simp add: poly_altdef)
+qed
+
+lemma alg_closedI [Pure.intro]:
+ assumes "\<And>p :: 'a poly. degree p > 0 \<Longrightarrow> lead_coeff p = 1 \<Longrightarrow> \<exists>x. poly p x = 0"
+ shows "OFCLASS('a :: field, alg_closed_field_class)"
+proof
+ fix n :: nat and f :: "nat \<Rightarrow> 'a"
+ assume n: "n > 0" "f n \<noteq> 0"
+ define p where "p = Abs_poly (\<lambda>k. if k \<le> n then f k else 0)"
+ have coeff_p: "coeff p k = (if k \<le> n then f k else 0)" for k
+ proof -
+ have "eventually (\<lambda>k. k > n) cofinite"
+ by (auto simp: MOST_nat)
+ hence "eventually (\<lambda>k. (if k \<le> n then f k else 0) = 0) cofinite"
+ by eventually_elim auto
+ thus ?thesis
+ unfolding p_def by (subst Abs_poly_inverse) auto
+ qed
+
+ from n have "degree p \<ge> n"
+ by (intro le_degree) (auto simp: coeff_p)
+ moreover have "degree p \<le> n"
+ by (intro degree_le) (auto simp: coeff_p)
+ ultimately have deg_p: "degree p = n"
+ by linarith
+ from deg_p and n have [simp]: "p \<noteq> 0"
+ by auto
+
+ define p' where "p' = smult (inverse (lead_coeff p)) p"
+ have deg_p': "degree p' = degree p"
+ by (auto simp: p'_def)
+ have lead_coeff_p' [simp]: "lead_coeff p' = 1"
+ by (auto simp: p'_def)
+
+ from deg_p and deg_p' and n have "degree p' > 0"
+ by simp
+ from assms[OF this] obtain x where "poly p' x = 0"
+ by auto
+ hence "poly p x = 0"
+ by (simp add: p'_def)
+ also have "poly p x = (\<Sum>k\<le>n. f k * x ^ k)"
+ unfolding poly_altdef by (intro sum.cong) (auto simp: deg_p coeff_p)
+ finally show "\<exists>x. (\<Sum>k\<le>n. f k * x ^ k) = 0" ..
+qed
+
+
+text \<open>
+ We can now prove by induction that every polynomial of degree \<open>n\<close> splits into a product of
+ \<open>n\<close> linear factors:
+\<close>
+lemma alg_closed_imp_factorization:
+ fixes p :: "'a :: alg_closed_field poly"
+ assumes "p \<noteq> 0"
+ shows "\<exists>A. size A = degree p \<and> p = smult (lead_coeff p) (\<Prod>x\<in>#A. [:-x, 1:])"
+ using assms
+proof (induction "degree p" arbitrary: p rule: less_induct)
+ case (less p)
+ show ?case
+ proof (cases "degree p = 0")
+ case True
+ thus ?thesis
+ by (intro exI[of _ "{#}"]) (auto elim!: degree_eq_zeroE)
+ next
+ case False
+ then obtain x where x: "poly p x = 0"
+ using alg_closed_imp_poly_has_root by blast
+ hence "[:-x, 1:] dvd p"
+ using poly_eq_0_iff_dvd by blast
+ then obtain q where p_eq: "p = [:-x, 1:] * q"
+ by (elim dvdE)
+ have "q \<noteq> 0"
+ using less.prems p_eq by auto
+ moreover from this have deg: "degree p = Suc (degree q)"
+ unfolding p_eq by (subst degree_mult_eq) auto
+ ultimately obtain A where A: "size A = degree q" "q = smult (lead_coeff q) (\<Prod>x\<in>#A. [:-x, 1:])"
+ using less.hyps[of q] by auto
+ have "smult (lead_coeff p) (\<Prod>y\<in>#add_mset x A. [:- y, 1:]) =
+ [:- x, 1:] * smult (lead_coeff q) (\<Prod>y\<in>#A. [:- y, 1:])"
+ unfolding p_eq lead_coeff_mult by simp
+ also note A(2) [symmetric]
+ also note p_eq [symmetric]
+ finally show ?thesis using A(1)
+ by (intro exI[of _ "add_mset x A"]) (auto simp: deg)
+ qed
+qed
+
+text \<open>
+ As an alternative characterisation of algebraic closure, one can also say that any
+ polynomial of degree at least 2 splits into non-constant factors:
+\<close>
+lemma alg_closed_imp_reducible:
+ assumes "degree (p :: 'a :: alg_closed_field poly) > 1"
+ shows "\<not>irreducible p"
+proof -
+ have "degree p > 0"
+ using assms by auto
+ then obtain z where z: "poly p z = 0"
+ using alg_closed_imp_poly_has_root[of p] by blast
+ then have dvd: "[:-z, 1:] dvd p"
+ by (subst dvd_iff_poly_eq_0) auto
+ then obtain q where q: "p = [:-z, 1:] * q"
+ by (erule dvdE)
+ have [simp]: "q \<noteq> 0"
+ using assms q by auto
+
+ show ?thesis
+ proof (rule reducible_polyI)
+ show "p = [:-z, 1:] * q"
+ by fact
+ next
+ have "degree p = degree ([:-z, 1:] * q)"
+ by (simp only: q)
+ also have "\<dots> = degree q + 1"
+ by (subst degree_mult_eq) auto
+ finally show "degree q > 0"
+ using assms by linarith
+ qed auto
+qed
+
+text \<open>
+ When proving algebraic closure through reducibility, we can assume w.l.o.g. that the polynomial
+ is monic and has a non-zero constant coefficient:
+\<close>
+lemma alg_closedI_reducible:
+ assumes "\<And>p :: 'a poly. degree p > 1 \<Longrightarrow> lead_coeff p = 1 \<Longrightarrow> coeff p 0 \<noteq> 0 \<Longrightarrow>
+ \<not>irreducible p"
+ shows "OFCLASS('a :: field, alg_closed_field_class)"
+proof
+ fix p :: "'a poly" assume p: "degree p > 0" "lead_coeff p = 1"
+ show "\<exists>x. poly p x = 0"
+ proof (cases "coeff p 0 = 0")
+ case True
+ hence "poly p 0 = 0"
+ by (simp add: poly_0_coeff_0)
+ thus ?thesis by blast
+ next
+ case False
+ from p and this show ?thesis
+ proof (induction "degree p" arbitrary: p rule: less_induct)
+ case (less p)
+ show ?case
+ proof (cases "degree p = 1")
+ case True
+ then obtain a b where p: "p = [:a, b:]"
+ by (cases p) (auto split: if_splits elim!: degree_eq_zeroE)
+ from True have [simp]: "b \<noteq> 0"
+ by (auto simp: p)
+ have "poly p (-a/b) = 0"
+ by (auto simp: p)
+ thus ?thesis by blast
+ next
+ case False
+ hence "degree p > 1"
+ using less.prems by auto
+ from assms[OF \<open>degree p > 1\<close> \<open>lead_coeff p = 1\<close> \<open>coeff p 0 \<noteq> 0\<close>]
+ have "\<not>irreducible p" by auto
+ then obtain r s where rs: "degree r > 0" "degree s > 0" "p = r * s"
+ using less.prems by (auto simp: irreducible_def)
+ hence "coeff r 0 \<noteq> 0"
+ using \<open>coeff p 0 \<noteq> 0\<close> by (auto simp: coeff_mult_0)
+
+ define r' where "r' = smult (inverse (lead_coeff r)) r"
+ have [simp]: "degree r' = degree r"
+ by (simp add: r'_def)
+ have lc: "lead_coeff r' = 1"
+ using rs by (auto simp: r'_def)
+ have nz: "coeff r' 0 \<noteq> 0"
+ using \<open>coeff r 0 \<noteq> 0\<close> by (auto simp: r'_def)
+
+ have "degree r < degree r + degree s"
+ using rs by linarith
+ also have "\<dots> = degree (r * s)"
+ using rs(3) less.prems by (subst degree_mult_eq) auto
+ also have "r * s = p"
+ using rs(3) by simp
+ finally have "\<exists>x. poly r' x = 0"
+ by (intro less) (use lc rs nz in auto)
+ thus ?thesis
+ using rs(3) by (auto simp: r'_def)
+ qed
+ qed
+ qed
+qed
+
+text \<open>
+ Using a clever Tschirnhausen transformation mentioned e.g. in the article by
+ Nowak~\cite{nowak2000}, we can also assume w.l.o.g. that the coefficient $a_{n-1}$ is zero.
+\<close>
+lemma alg_closedI_reducible_coeff_deg_minus_one_eq_0:
+ assumes "\<And>p :: 'a poly. degree p > 1 \<Longrightarrow> lead_coeff p = 1 \<Longrightarrow> coeff p (degree p - 1) = 0 \<Longrightarrow>
+ coeff p 0 \<noteq> 0 \<Longrightarrow> \<not>irreducible p"
+ shows "OFCLASS('a :: field_char_0, alg_closed_field_class)"
+proof (rule alg_closedI_reducible, goal_cases)
+ case (1 p)
+ define n where [simp]: "n = degree p"
+ define a where "a = coeff p (n - 1)"
+ define r where "r = [: -a / of_nat n, 1 :]"
+ define s where "s = [: a / of_nat n, 1 :]"
+ define q where "q = pcompose p r"
+
+ have "n > 0"
+ using 1 by simp
+ have r_altdef: "r = monom 1 1 + [:-a / of_nat n:]"
+ by (simp add: r_def monom_altdef)
+ have deg_q: "degree q = n"
+ by (simp add: q_def r_def)
+ have lc_q: "lead_coeff q = 1"
+ unfolding q_def using 1 by (subst lead_coeff_comp) (simp_all add: r_def)
+ have "q \<noteq> 0"
+ using 1 deg_q by auto
+
+ have "coeff q (n - 1) =
+ (\<Sum>i\<le>n. \<Sum>k\<le>i. coeff p i * (of_nat (i choose k) *
+ ((-a / of_nat n) ^ (i - k) * (if k = n - 1 then 1 else 0))))"
+ unfolding q_def pcompose_altdef poly_altdef r_altdef
+ by (simp_all add: degree_map_poly coeff_map_poly coeff_sum binomial_ring sum_distrib_left poly_const_pow
+ sum_distrib_right mult_ac monom_power coeff_monom_mult of_nat_poly cong: if_cong)
+ also have "\<dots> = (\<Sum>i\<le>n. \<Sum>k\<in>(if i \<ge> n - 1 then {n-1} else {}).
+ coeff p i * (of_nat (i choose k) * (-a / of_nat n) ^ (i - k)))"
+ by (rule sum.cong [OF refl], rule sum.mono_neutral_cong_right) (auto split: if_splits)
+ also have "\<dots> = (\<Sum>i\<in>{n-1,n}. \<Sum>k\<in>(if i \<ge> n - 1 then {n-1} else {}).
+ coeff p i * (of_nat (i choose k) * (-a / of_nat n) ^ (i - k)))"
+ by (rule sum.mono_neutral_right) auto
+ also have "\<dots> = a - of_nat (n choose (n - 1)) * a / of_nat n"
+ using 1 by (simp add: a_def)
+ also have "n choose (n - 1) = n"
+ using \<open>n > 0\<close> by (subst binomial_symmetric) auto
+ also have "a - of_nat n * a / of_nat n = 0"
+ using \<open>n > 0\<close> by simp
+ finally have "coeff q (n - 1) = 0" .
+
+ show ?case
+ proof (cases "coeff q 0 = 0")
+ case True
+ hence "poly p (- (a / of_nat (degree p))) = 0"
+ by (auto simp: q_def r_def)
+ thus ?thesis
+ by (rule root_imp_reducible_poly) (use 1 in auto)
+ next
+ case False
+ hence "\<not>irreducible q"
+ using assms[of q] and lc_q and 1 and \<open>coeff q (n - 1) = 0\<close>
+ by (auto simp: deg_q)
+ then obtain u v where uv: "degree u > 0" "degree v > 0" "q = u * v"
+ using \<open>q \<noteq> 0\<close> 1 deg_q by (auto simp: irreducible_def)
+
+ have "p = pcompose q s"
+ by (simp add: q_def r_def s_def flip: pcompose_assoc)
+ also have "q = u * v"
+ by fact
+ finally have "p = pcompose u s * pcompose v s"
+ by (simp add: pcompose_mult)
+ moreover have "degree (pcompose u s) > 0" "degree (pcompose v s) > 0"
+ using uv by (simp_all add: s_def)
+ ultimately show "\<not>irreducible p"
+ using 1 by (intro reducible_polyI)
+ qed
+qed
+
+text \<open>
+ As a consequence of the full factorisation lemma proven above, we can also show that any
+ polynomial with at least two different roots splits into two non-constant coprime factors:
+\<close>
+lemma alg_closed_imp_poly_splits_coprime:
+ assumes "degree (p :: 'a :: {alg_closed_field} poly) > 1"
+ assumes "poly p x = 0" "poly p y = 0" "x \<noteq> y"
+ obtains r s where "degree r > 0" "degree s > 0" "coprime r s" "p = r * s"
+proof -
+ define n where "n = order x p"
+ have "n > 0"
+ using assms by (metis degree_0 gr0I n_def not_one_less_zero order_root)
+ have "[:-x, 1:] ^ n dvd p"
+ unfolding n_def by (simp add: order_1)
+ then obtain q where p_eq: "p = [:-x, 1:] ^ n * q"
+ by (elim dvdE)
+ from assms have [simp]: "q \<noteq> 0"
+ by (auto simp: p_eq)
+ have "order x p = n + Polynomial.order x q"
+ unfolding p_eq by (subst order_mult) (auto simp: order_power_n_n)
+ hence "Polynomial.order x q = 0"
+ by (simp add: n_def)
+ hence "poly q x \<noteq> 0"
+ by (simp add: order_root)
+
+ show ?thesis
+ proof (rule that)
+ show "coprime ([:-x, 1:] ^ n) q"
+ proof (rule coprimeI)
+ fix d
+ assume d: "d dvd [:-x, 1:] ^ n" "d dvd q"
+ have "degree d = 0"
+ proof (rule ccontr)
+ assume "\<not>(degree d = 0)"
+ then obtain z where z: "poly d z = 0"
+ using alg_closed_imp_poly_has_root by blast
+ moreover from this and d(1) have "poly ([:-x, 1:] ^ n) z = 0"
+ using dvd_trans poly_eq_0_iff_dvd by blast
+ ultimately have "poly d x = 0"
+ by auto
+ with d(2) have "poly q x = 0"
+ using dvd_trans poly_eq_0_iff_dvd by blast
+ with \<open>poly q x \<noteq> 0\<close> show False by contradiction
+ qed
+ thus "is_unit d" using d
+ by auto
+ qed
+ next
+ have "poly q y = 0"
+ using \<open>poly p y = 0\<close> \<open>x \<noteq> y\<close> by (auto simp: p_eq)
+ with \<open>q \<noteq> 0\<close> show "degree q > 0"
+ using poly_zero by blast
+ qed (use \<open>n > 0\<close> in \<open>simp_all add: p_eq degree_power_eq\<close>)
+qed
+
+instance complex :: alg_closed_field
+ by standard (use constant_degree fundamental_theorem_of_algebra neq0_conv in blast)
+
+end
\ No newline at end of file
diff --git a/thys/Formal_Puiseux_Series/ROOT b/thys/Formal_Puiseux_Series/ROOT
new file mode 100644
--- /dev/null
+++ b/thys/Formal_Puiseux_Series/ROOT
@@ -0,0 +1,15 @@
+chapter AFP
+
+session Formal_Puiseux_Series (AFP) = "HOL-Computational_Algebra" +
+ options [timeout = 1200]
+ sessions
+ Polynomial_Interpolation
+ theories
+ Puiseux_Polynomial_Library
+ Puiseux_Laurent_Library
+ FPS_Hensel
+ Formal_Puiseux_Series
+ document_files
+ "root.tex"
+ "root.bib"
+
diff --git a/thys/Formal_Puiseux_Series/document/root.bib b/thys/Formal_Puiseux_Series/document/root.bib
new file mode 100644
--- /dev/null
+++ b/thys/Formal_Puiseux_Series/document/root.bib
@@ -0,0 +1,17 @@
+@article{nowak2000,
+ title={Some elementary proofs of {P}uiseux’s theorems},
+ author={Nowak, Krzysztof Jan},
+ journal={Univ. Iagel. Acta Math},
+ volume={38},
+ pages={279--282},
+ year={2000}
+}
+
+@book{abhyankar1990,
+ title={Algebraic Geometry for Scientists and Engineers},
+ author={Shreeram Shankar Abhyankar},
+ isbn={9780821815359},
+ series={Mathematical surveys and monographs},
+ year={1990},
+ publisher={American Mathematical Society}
+}
diff --git a/thys/Formal_Puiseux_Series/document/root.tex b/thys/Formal_Puiseux_Series/document/root.tex
new file mode 100644
--- /dev/null
+++ b/thys/Formal_Puiseux_Series/document/root.tex
@@ -0,0 +1,43 @@
+\documentclass[11pt,a4paper]{article}
+\usepackage{isabelle,isabellesym}
+\usepackage{amsfonts, amsmath, amssymb}
+\usepackage{pgfplots}
+
+% this should be the last package used
+\usepackage{pdfsetup}
+
+% urls in roman style, theory text in math-similar italics
+\urlstyle{rm}
+\isabellestyle{it}
+
+\begin{document}
+
+\title{Formal Puiseux Series}
+\author{Manuel Eberl}
+\maketitle
+
+\begin{abstract}
+Formal Puiseux series are generalisations of formal power series and formal Laurent series that also allow for fractional exponents. They have the following general form:
+\[\sum_{i=N}^\infty a_{i/d} X^{i/d}\]
+where $N$ is an integer and $d$ is a positive integer.
+
+This entry defines these series including their basic algebraic properties. Furthermore, it proves the Newton--Puiseux Theorem, namely that the Puiseux series over an algebraically closed field of characteristic 0 are also algebraically closed.
+\end{abstract}
+
+\newpage
+\tableofcontents
+\newpage
+\parindent 0pt\parskip 0.5ex
+
+\input{session}
+
+\nocite{corless96}
+\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,584 +1,586 @@
ADS_Functor
AI_Planning_Languages_Semantics
AODV
AVL-Trees
AWN
Abortable_Linearizable_Modules
Abs_Int_ITP2012
Abstract-Hoare-Logics
Abstract-Rewriting
Abstract_Completeness
Abstract_Soundness
Adaptive_State_Counting
Affine_Arithmetic
Aggregation_Algebras
Akra_Bazzi
Algebraic_Numbers
Algebraic_VCs
Allen_Calculus
Amicable_Numbers
Amortized_Complexity
AnselmGod
Applicative_Lifting
Approximation_Algorithms
Architectural_Design_Patterns
Aristotles_Assertoric_Syllogistic
Arith_Prog_Rel_Primes
ArrowImpossibilityGS
Attack_Trees
Auto2_HOL
Auto2_Imperative_HOL
AutoFocus-Stream
Automated_Stateful_Protocol_Verification
Automatic_Refinement
AxiomaticCategoryTheory
BDD
BNF_CC
BNF_Operations
+BTree
Banach_Steinhaus
Bell_Numbers_Spivey
Berlekamp_Zassenhaus
Bernoulli
Bertrands_Postulate
Bicategory
BinarySearchTree
Binding_Syntax_Theory
Binomial-Heaps
Binomial-Queues
BirdKMP
Blue_Eyes
Bondy
Boolean_Expression_Checkers
Bounded_Deducibility_Security
Buchi_Complementation
Budan_Fourier
Buffons_Needle
Buildings
BytecodeLogicJmlTypes
C2KA_DistributedSystems
CAVA_Automata
CAVA_LTL_Modelchecker
CCS
CISC-Kernel
CRDT
CYK
CakeML
CakeML_Codegen
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
Chandy_Lamport
Chord_Segments
Circus
Clean
ClockSynchInst
Closest_Pair_Points
CofGroups
Coinductive
Coinductive_Languages
Collections
Comparison_Sort_Lower_Bound
Compiling-Exceptions-Correctly
Complete_Non_Orders
Completeness
Complex_Geometry
Complx
ComponentDependencies
ConcurrentGC
ConcurrentIMP
Concurrent_Ref_Alg
Concurrent_Revisions
Consensus_Refined
Constructive_Cryptography
Constructor_Funs
Containers
CoreC++
Core_DOM
Core_SC_DOM
Count_Complex_Roots
CryptHOL
CryptoBasedCompositionalProperties
CSP_RefTK
DFS_Framework
DPT-SAT-Solver
DataRefinementIBP
Datatype_Order_Generator
Decl_Sem_Fun_PL
Decreasing-Diagrams
Decreasing-Diagrams-II
Deep_Learning
Delta_System_Lemma
Density_Compiler
Dependent_SIFUM_Refinement
Dependent_SIFUM_Type_Systems
Depth-First-Search
Derangements
Deriving
Descartes_Sign_Rule
Dict_Construction
Differential_Dynamic_Logic
Differential_Game_Logic
Dijkstra_Shortest_Path
Diophantine_Eqns_Lin_Hom
Dirichlet_L
Dirichlet_Series
DiscretePricing
Discrete_Summation
DiskPaxos
DOM_Components
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
Extended_Finite_State_Machine_Inference
Extended_Finite_State_Machines
FFT
FLP
FOL-Fitting
FOL_Harrison
FOL_Seq_Calc1
Factored_Transition_System_Bounding
Falling_Factorial_Sum
Farkas
FeatherweightJava
Featherweight_OCL
Fermat3_4
FileRefinement
FinFun
Finger-Trees
Finite-Map-Extras
Finite_Automata_HF
First_Order_Terms
First_Welfare_Theorem
Fishburn_Impossibility
Fisher_Yates
Flow_Networks
Floyd_Warshall
Flyspeck-Tame
FocusStreamsCaseStudies
Forcing
+Formal_Puiseux_Series
Formal_SSA
Formula_Derivatives
Fourier
Free-Boolean-Algebra
Free-Groups
FunWithFunctions
FunWithTilings
Functional-Automata
Functional_Ordered_Resolution_Prover
Furstenberg_Topology
GPU_Kernel_PL
Gabow_SCC
Game_Based_Crypto
Gauss-Jordan-Elim-Fun
Gauss_Jordan
Gauss_Sums
Gaussian_Integers
GenClock
General-Triangle
Generalized_Counting_Sort
Generic_Deriving
Generic_Join
GewirthPGCProof
Girth_Chromatic
GoedelGod
Goedel_HFSet_Semantic
Goedel_HFSet_Semanticless
Goedel_Incompleteness
Goodstein_Lambda
GraphMarkingIBP
Graph_Saturation
Graph_Theory
Green
Groebner_Bases
Groebner_Macaulay
Gromov_Hyperbolicity
Group-Ring-Module
HOL-CSP
HOLCF-Prelude
HRB-Slicing
Heard_Of
Hello_World
HereditarilyFinite
Hermite
Hidden_Markov_Models
Higher_Order_Terms
Hoare_Time
Hood_Melville_Queue
HotelKeyCards
Huffman
Hybrid_Logic
Hybrid_Multi_Lane_Spatial_Logic
Hybrid_Systems_VCs
HyperCTL
IEEE_Floating_Point
IMAP-CRDT
IMO2019
IMP2
IMP2_Binary_Heap
IP_Addresses
Imperative_Insertion_Sort
Impossible_Geometry
Incompleteness
Incredible_Proof_Machine
Inductive_Confidentiality
Inductive_Inference
InfPathElimination
InformationFlowSlicing
InformationFlowSlicing_Inter
Integration
Interpreter_Optimizations
Interval_Arithmetic_Word32
Iptables_Semantics
Irrational_Series_Erdos_Straus
Irrationality_J_Hancl
Isabelle_C
Isabelle_Marries_Dirac
Isabelle_Meta_Model
IsaGeoCoq
Jacobson_Basic_Algebra
Jinja
JinjaDCI
JinjaThreads
JiveDataStoreModel
Jordan_Hoelder
Jordan_Normal_Form
KAD
KAT_and_DRA
KBPs
KD_Tree
Key_Agreement_Strong_Adversaries
Kleene_Algebra
Knuth_Bendix_Order
Knot_Theory
Knuth_Bendix_Order
Knuth_Morris_Pratt
Koenigsberg_Friendship
Kruskal
Kuratowski_Closure_Complement
LLL_Basis_Reduction
LLL_Factorization
LOFT
LTL
LTL_Master_Theorem
LTL_Normal_Form
LTL_to_DRA
LTL_to_GBA
Lam-ml-Normalization
LambdaAuth
LambdaMu
Lambda_Free_EPO
Lambda_Free_KBOs
Lambda_Free_RPOs
Lambert_W
Landau_Symbols
Laplace_Transform
Latin_Square
LatticeProperties
Launchbury
Laws_of_Large_Numbers
Lazy-Lists-II
Lazy_Case
Lehmer
Lifting_Definition_Option
LightweightJava
LinearQuantifierElim
Linear_Inequalities
Linear_Programming
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
Lucas_Theorem
MFMC_Countable
MFODL_Monitor_Optimized
MFOTL_Monitor
MSO_Regex_Equivalence
Markov_Models
Marriage
Mason_Stothers
Matrices_for_ODEs
Matrix
Matrix_Tensor
Matroids
Max-Card-Matching
Median_Of_Medians_Selection
Menger
Mersenne_Primes
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
Multi_Party_Computation
Multirelations
Myhill-Nerode
Name_Carrying_Type_Inference
Nash_Williams
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
OpSets
Open_Induction
Optics
Optimal_BST
Orbit_Stabiliser
Order_Lattice_Props
Ordered_Resolution_Prover
Ordinal
Ordinal_Partitions
Ordinals_and_Cardinals
Ordinary_Differential_Equations
PAC_Checker
PCF
PLM
POPLmark-deBruijn
PSemigroupsConvolution
Pairing_Heap
Paraconsistency
Parity_Game
Partial_Function_MR
Partial_Order_Reduction
Password_Authentication_Protocol
Pell
Perfect-Number-Thm
Perron_Frobenius
Physical_Quantities
Pi_Calculus
Pi_Transcendental
Planarity_Certificates
Poincare_Bendixson
Poincare_Disc
Polynomial_Factorization
Polynomial_Interpolation
Polynomials
Pop_Refinement
Posix-Lexing
Possibilistic_Noninterference
Power_Sum_Polynomials
Pratt_Certificate
Presburger-Automata
Prim_Dijkstra_Simple
Prime_Distribution_Elementary
Prime_Harmonic_Series
Prime_Number_Theorem
Priority_Queue_Braun
Priority_Search_Trees
Probabilistic_Noninterference
Probabilistic_Prime_Tests
Probabilistic_System_Zoo
Probabilistic_Timed_Automata
Probabilistic_While
Program-Conflict-Analysis
Projective_Geometry
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
Random_Graph_Subgraph_Threshold
Randomised_BSTs
Randomised_Social_Choice
Rank_Nullity_Theorem
Real_Impl
Recursion-Addition
Recursion-Theory-I
Refine_Imperative_HOL
Refine_Monadic
RefinementReactive
Regex_Equivalence
Regular-Sets
Regular_Algebras
Relation_Algebra
Relational-Incorrectness-Logic
Relational_Disjoint_Set_Forests
Relational_Method
Relational_Minimum_Spanning_Trees
Relational_Paths
Rep_Fin_Groups
Residuated_Lattices
Resolution_FOL
Rewriting_Z
Ribbon_Proofs
Robbins-Conjecture
Robinson_Arithmetic
Root_Balanced_Tree
Routing
Roy_Floyd_Warshall
SATSolverVerification
SC_DOM_Components
SDS_Impossibility
SIFPL
SIFUM_Type_Systems
SPARCv8
Safe_Distance
Safe_OCL
Saturation_Framework
Saturation_Framework_Extensions
Shadow_DOM
Secondary_Sylow
Security_Protocol_Refinement
Selection_Heap_Sort
SenSocialChoice
Separata
Separation_Algebra
Separation_Logic_Imperative_HOL
SequentInvertibility
Shadow_SC_DOM
Shivers-CFA
ShortestPath
Show
Sigma_Commit_Crypto
Signature_Groebner
Simpl
Simple_Firewall
Simplex
Skew_Heap
Skip_Lists
Slicing
Sliding_Window_Algorithm
Smith_Normal_Form
Smooth_Manifolds
Sort_Encodings
Source_Coding_Theorem
Special_Function_Bounds
Splay_Tree
Sqrt_Babylonian
Stable_Matching
Statecharts
Stateful_Protocol_Composition_and_Typing
Stellar_Quorums
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
Subset_Boolean_Algebras
SumSquares
SuperCalc
Surprise_Paradox
Symmetric_Polynomials
Syntax_Independent_Logic
Szpilrajn
TESL_Language
TLA
Tail_Recursive_Functions
Tarskis_Geometry
Taylor_Models
Timed_Automata
Topological_Semantics
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
UPF
UPF_Firewall
UTP
Universal_Turing_Machine
UpDown_Scheme
Valuation
VectorSpace
VeriComp
Verified-Prover
Verified_SAT_Based_AI_Planning
VerifyThis2018
VerifyThis2019
Vickrey_Clarke_Groves
VolpanoSmith
WHATandWHERE_Security
WOOT_Strong_Eventual_Consistency
WebAssembly
Weight_Balanced_Trees
Well_Quasi_Orders
Winding_Number_Eval
Word_Lib
WorkerWrapper
XML
ZFC_in_HOL
Zeta_3_Irrational
Zeta_Function
pGCL
diff --git a/web/entries/ADS_Functor.html b/web/entries/ADS_Functor.html
--- a/web/entries/ADS_Functor.html
+++ b/web/entries/ADS_Functor.html
@@ -1,204 +1,210 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Authenticated Data Structures As 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>uthenticated
<font class="first">D</font>ata
<font class="first">S</font>tructures
<font class="first">A</font>s
<font class="first">F</font>unctors
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Authenticated Data Structures As Functors</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a> and
Ognjen Marić (ogi /dot/ afp /at/ mynosefroze /dot/ com)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-04-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Authenticated data structures allow several systems to convince each
other that they are referring to the same data structure, even if each
of them knows only a part of the data structure. Using inclusion
proofs, knowledgeable systems can selectively share their knowledge
with other systems and the latter can verify the authenticity of what
is being shared. In this article, we show how to modularly define
authenticated data structures, their inclusion proofs, and operations
thereon as datatypes in Isabelle/HOL, using a shallow embedding.
Modularity allows us to construct complicated trees from reusable
building blocks, which we call Merkle functors. Merkle functors
include sums, products, and function spaces and are closed under
composition and least fixpoints. As a practical application, we model
the hierarchical transactions of <a
href="https://www.canton.io">Canton</a>, a
practical interoperability protocol for distributed ledgers, as
authenticated data structures. This is a first step towards
formalizing the Canton protocol and verifying its integrity and
security guarantees.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{ADS_Functor-AFP,
author = {Andreas Lochbihler and Ognjen Marić},
title = {Authenticated Data Structures As Functors},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/ADS_Functor.html},
Formal proof development},
ISSN = {2150-914x},
}</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/ADS_Functor/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/ADS_Functor/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/ADS_Functor/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-ADS_Functor-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-ADS_Functor-2020-04-27.tar.gz">
+ afp-ADS_Functor-2020-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/AI_Planning_Languages_Semantics.html b/web/entries/AI_Planning_Languages_Semantics.html
--- a/web/entries/AI_Planning_Languages_Semantics.html
+++ b/web/entries/AI_Planning_Languages_Semantics.html
@@ -1,196 +1,202 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>AI Planning Languages 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>I
<font class="first">P</font>lanning
<font class="first">L</font>anguages
<font class="first">S</font>emantics
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">AI Planning Languages Semantics</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://home.in.tum.de/~mansour/">Mohammad Abdulaziz</a> and
Peter Lammich
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-10-29</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This is an Isabelle/HOL formalisation of the semantics of the
multi-valued planning tasks language that is used by the planning
system Fast-Downward, the STRIPS fragment of the Planning Domain
Definition Language (PDDL), and the STRIPS soundness meta-theory
developed by Vladimir Lifschitz. It also contains formally verified
checkers for checking the well-formedness of problems specified in
either language as well the correctness of potential solutions. The
formalisation in this entry was described in an earlier publication.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{AI_Planning_Languages_Semantics-AFP,
author = {Mohammad Abdulaziz and Peter Lammich},
title = {AI Planning Languages Semantics},
journal = {Archive of Formal Proofs},
month = oct,
year = 2020,
note = {\url{https://isa-afp.org/entries/AI_Planning_Languages_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="Certification_Monads.html">Certification_Monads</a>, <a href="Containers.html">Containers</a>, <a href="Propositional_Proof_Systems.html">Propositional_Proof_Systems</a>, <a href="Show.html">Show</a> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Verified_SAT_Based_AI_Planning.html">Verified_SAT_Based_AI_Planning</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/AI_Planning_Languages_Semantics/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/AI_Planning_Languages_Semantics/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/AI_Planning_Languages_Semantics/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-AI_Planning_Languages_Semantics-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-AI_Planning_Languages_Semantics-2020-10-30.tar.gz">
+ afp-AI_Planning_Languages_Semantics-2020-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/AODV.html b/web/entries/AODV.html
--- a/web/entries/AODV.html
+++ b/web/entries/AODV.html
@@ -1,252 +1,257 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-AODV-2020-04-18.tar.gz">
+ afp-AODV-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-AODV-2019-06-11.tar.gz">
afp-AODV-2019-06-11.tar.gz
</a>
</li>
<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,295 +1,300 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>VL
<font class="first">T</font>rees
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-AVL-Trees-2020-04-18.tar.gz">
+ afp-AVL-Trees-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-AVL-Trees-2019-06-11.tar.gz">
afp-AVL-Trees-2019-06-11.tar.gz
</a>
</li>
<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,253 +1,258 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-AWN-2020-04-18.tar.gz">
+ afp-AWN-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-AWN-2019-06-11.tar.gz">
afp-AWN-2019-06-11.tar.gz
</a>
</li>
<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,255 +1,260 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>bortable
<font class="first">L</font>inearizable
<font class="first">M</font>odules
</h1>
<p>&nbsp;</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 /at/ galois /dot/ com)
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Abortable_Linearizable_Modules-2020-04-18.tar.gz">
+ afp-Abortable_Linearizable_Modules-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Abortable_Linearizable_Modules-2019-06-11.tar.gz">
afp-Abortable_Linearizable_Modules-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Abs_Int_ITP2012-2020-04-18.tar.gz">
+ afp-Abs_Int_ITP2012-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Abs_Int_ITP2012-2019-06-11.tar.gz">
afp-Abs_Int_ITP2012-2019-06-11.tar.gz
</a>
</li>
<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,272 +1,277 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>bstract
<font class="first">H</font>oare
<font class="first">L</font>ogics
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Abstract-Hoare-Logics-2020-04-18.tar.gz">
+ afp-Abstract-Hoare-Logics-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Abstract-Hoare-Logics-2019-06-11.tar.gz">
afp-Abstract-Hoare-Logics-2019-06-11.tar.gz
</a>
</li>
<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,277 +1,282 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>bstract
<font class="first">R</font>ewriting
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Abstract-Rewriting-2020-04-18.tar.gz">
+ afp-Abstract-Rewriting-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Abstract-Rewriting-2019-06-11.tar.gz">
afp-Abstract-Rewriting-2019-06-11.tar.gz
</a>
</li>
<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,227 +1,232 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>bstract
<font class="first">C</font>ompleteness
</h1>
<p>&nbsp;</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),
<a href="https://www.andreipopescu.uk">Andrei Popescu</a> and
<a href="https://traytel.bitbucket.io">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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Abstract_Completeness-2020-04-18.tar.gz">
+ afp-Abstract_Completeness-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Abstract_Completeness-2019-06-11.tar.gz">
afp-Abstract_Completeness-2019-06-11.tar.gz
</a>
</li>
<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,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>bstract
<font class="first">S</font>oundness
</h1>
<p>&nbsp;</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),
<a href="https://www.andreipopescu.uk">Andrei Popescu</a> and
<a href="https://traytel.bitbucket.io">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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Abstract_Soundness-2020-04-18.tar.gz">
+ afp-Abstract_Soundness-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Abstract_Soundness-2019-06-11.tar.gz">
afp-Abstract_Soundness-2019-06-11.tar.gz
</a>
</li>
<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/Adaptive_State_Counting.html b/web/entries/Adaptive_State_Counting.html
--- a/web/entries/Adaptive_State_Counting.html
+++ b/web/entries/Adaptive_State_Counting.html
@@ -1,210 +1,215 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Formalisation of an Adaptive State Counting 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalisation
of
an
<font class="first">A</font>daptive
<font class="first">S</font>tate
<font class="first">C</font>ounting
<font class="first">A</font>lgorithm
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Formalisation of an Adaptive State Counting Algorithm</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Robert Sachtleben (rob_sac /at/ uni-bremen /dot/ de)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-08-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This entry provides a formalisation of a refinement of an adaptive
state counting algorithm, used to test for reduction between finite
state machines. The algorithm has been originally presented by Hierons
in the paper <a
href="https://doi.org/10.1109/TC.2004.85">Testing from a
Non-Deterministic Finite State Machine Using Adaptive State
Counting</a>. Definitions for finite state machines and
adaptive test cases are given and many useful theorems are derived
from these. The algorithm is formalised using mutually recursive
functions, for which it is proven that the generated test suite is
sufficient to test for reduction against finite state machines of a
certain fault domain. Additionally, the algorithm is specified in a
simple WHILE-language and its correctness is shown using Hoare-logic.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Adaptive_State_Counting-AFP,
author = {Robert Sachtleben},
title = {Formalisation of an Adaptive State Counting Algorithm},
journal = {Archive of Formal Proofs},
month = aug,
year = 2019,
note = {\url{https://isa-afp.org/entries/Adaptive_State_Counting.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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/Adaptive_State_Counting/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Adaptive_State_Counting/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Adaptive_State_Counting/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Adaptive_State_Counting-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Adaptive_State_Counting-2020-04-18.tar.gz">
+ afp-Adaptive_State_Counting-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Adaptive_State_Counting-2019-08-19.tar.gz">
afp-Adaptive_State_Counting-2019-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/Affine_Arithmetic.html b/web/entries/Affine_Arithmetic.html
--- a/web/entries/Affine_Arithmetic.html
+++ b/web/entries/Affine_Arithmetic.html
@@ -1,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>ffine
<font class="first">A</font>rithmetic
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Affine_Arithmetic-2020-04-18.tar.gz">
+ afp-Affine_Arithmetic-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Affine_Arithmetic-2019-06-11.tar.gz">
afp-Affine_Arithmetic-2019-06-11.tar.gz
</a>
</li>
<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,199 +1,204 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>ggregation
<font class="first">A</font>lgebras
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Relational_Minimum_Spanning_Trees.html">Relational_Minimum_Spanning_Trees</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Aggregation_Algebras-2020-04-18.tar.gz">
+ afp-Aggregation_Algebras-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Aggregation_Algebras-2019-06-11.tar.gz">
afp-Aggregation_Algebras-2019-06-11.tar.gz
</a>
</li>
<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,238 +1,243 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Closest_Pair_Points.html">Closest_Pair_Points</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Akra_Bazzi-2020-04-18.tar.gz">
+ afp-Akra_Bazzi-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Akra_Bazzi-2019-06-11.tar.gz">
afp-Akra_Bazzi-2019-06-11.tar.gz
</a>
</li>
<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,236 +1,241 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>lgebraic
<font class="first">N</font>umbers
in
<font class="first">I</font>sabelle/HOL
</h1>
<p>&nbsp;</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>,
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a> and
<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</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">2015-12-22</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Algebraic_Numbers-2020-04-18.tar.gz">
+ afp-Algebraic_Numbers-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Algebraic_Numbers-2019-06-11.tar.gz">
afp-Algebraic_Numbers-2019-06-11.tar.gz
</a>
</li>
<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,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Algebraic_VCs-2020-04-18.tar.gz">
+ afp-Algebraic_VCs-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Algebraic_VCs-2019-06-11.tar.gz">
afp-Algebraic_VCs-2019-06-11.tar.gz
</a>
</li>
<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,233 +1,238 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>llen's
<font class="first">I</font>nterval
<font class="first">C</font>alculus
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Allen_Calculus-2020-04-18.tar.gz">
+ afp-Allen_Calculus-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Allen_Calculus-2019-06-28.tar.gz">
afp-Allen_Calculus-2019-06-28.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Allen_Calculus-2019-06-11.tar.gz">
afp-Allen_Calculus-2019-06-11.tar.gz
</a>
</li>
<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/Amicable_Numbers.html b/web/entries/Amicable_Numbers.html
--- a/web/entries/Amicable_Numbers.html
+++ b/web/entries/Amicable_Numbers.html
@@ -1,186 +1,192 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Amicable 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>micable
<font class="first">N</font>umbers
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Amicable Numbers</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">2020-08-04</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This is a formalisation of Amicable Numbers, involving some relevant
material including Euler's sigma function, some relevant
definitions, results and examples as well as rules such as
Th&#257;bit ibn Qurra's Rule, Euler's Rule, te
Riele's Rule and Borho's Rule with breeders.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Amicable_Numbers-AFP,
author = {Angeliki Koutsoukou-Argyraki},
title = {Amicable Numbers},
journal = {Archive of Formal Proofs},
month = aug,
year = 2020,
note = {\url{https://isa-afp.org/entries/Amicable_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="Polynomial_Factorization.html">Polynomial_Factorization</a>, <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/Amicable_Numbers/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Amicable_Numbers/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Amicable_Numbers/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Amicable_Numbers-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Amicable_Numbers-2020-08-15.tar.gz">
+ afp-Amicable_Numbers-2020-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/Amortized_Complexity.html b/web/entries/Amortized_Complexity.html
--- a/web/entries/Amortized_Complexity.html
+++ b/web/entries/Amortized_Complexity.html
@@ -1,247 +1,252 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>mortized
<font class="first">C</font>omplexity
<font class="first">V</font>erified
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Amortized_Complexity-2020-04-18.tar.gz">
+ afp-Amortized_Complexity-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Amortized_Complexity-2019-06-11.tar.gz">
afp-Amortized_Complexity-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-AnselmGod-2020-04-18.tar.gz">
+ afp-AnselmGod-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-AnselmGod-2019-06-11.tar.gz">
afp-AnselmGod-2019-06-11.tar.gz
</a>
</li>
<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,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>pplicative
<font class="first">L</font>ifting
</h1>
<p>&nbsp;</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
</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Applicative_Lifting-2020-04-18.tar.gz">
+ afp-Applicative_Lifting-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Applicative_Lifting-2019-06-11.tar.gz">
afp-Applicative_Lifting-2019-06-11.tar.gz
</a>
</li>
<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/Approximation_Algorithms.html b/web/entries/Approximation_Algorithms.html
--- a/web/entries/Approximation_Algorithms.html
+++ b/web/entries/Approximation_Algorithms.html
@@ -1,195 +1,200 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Verified Approximation 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">V</font>erified
<font class="first">A</font>pproximation
<font class="first">A</font>lgorithms
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Verified Approximation Algorithms</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Robin Eßmann (robin /dot/ essmann /at/ tum /dot/ de),
<a href="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a> and
<a href="https://simon-robillard.net/">Simon Robillard</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-01-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We present the first formal verification of approximation algorithms
for NP-complete optimization problems: vertex cover, set cover, independent set,
load balancing, and bin packing. The proofs correct incompletenesses
in existing proofs and improve the approximation ratio in one case.
A detailed description of our work has been published in the proceedings of
<a href="https://doi.org/10.1007/978-3-030-51054-1_17">IJCAR 2020</a>.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Approximation_Algorithms-AFP,
author = {Robin Eßmann and Tobias Nipkow and Simon Robillard},
title = {Verified Approximation Algorithms},
journal = {Archive of Formal Proofs},
month = jan,
year = 2020,
note = {\url{https://isa-afp.org/entries/Approximation_Algorithms.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Approximation_Algorithms/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Approximation_Algorithms/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Approximation_Algorithms/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Approximation_Algorithms-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Approximation_Algorithms-2020-04-18.tar.gz">
+ afp-Approximation_Algorithms-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Approximation_Algorithms-2020-01-16.tar.gz">
afp-Approximation_Algorithms-2020-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/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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Architectural_Design_Patterns-2020-04-18.tar.gz">
+ afp-Architectural_Design_Patterns-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Architectural_Design_Patterns-2019-06-11.tar.gz">
afp-Architectural_Design_Patterns-2019-06-11.tar.gz
</a>
</li>
<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/Aristotles_Assertoric_Syllogistic.html b/web/entries/Aristotles_Assertoric_Syllogistic.html
--- a/web/entries/Aristotles_Assertoric_Syllogistic.html
+++ b/web/entries/Aristotles_Assertoric_Syllogistic.html
@@ -1,198 +1,203 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Aristotle's Assertoric Syllogistic - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>ristotle's
<font class="first">A</font>ssertoric
<font class="first">S</font>yllogistic
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Aristotle's Assertoric Syllogistic</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">2019-10-08</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We formalise with Isabelle/HOL some basic elements of Aristotle's
assertoric syllogistic following the <a
href="https://plato.stanford.edu/entries/aristotle-logic/">article from the Stanford Encyclopedia of Philosophy by Robin Smith.</a> To
this end, we use a set theoretic formulation (covering both individual
and general predication). In particular, we formalise the deductions
in the Figures and after that we present Aristotle's
metatheoretical observation that all deductions in the Figures can in
fact be reduced to either Barbara or Celarent. As the formal proofs
prove to be straightforward, the interest of this entry lies in
illustrating the functionality of Isabelle and high efficiency of
Sledgehammer for simple exercises in philosophy.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Aristotles_Assertoric_Syllogistic-AFP,
author = {Angeliki Koutsoukou-Argyraki},
title = {Aristotle's Assertoric Syllogistic},
journal = {Archive of Formal Proofs},
month = oct,
year = 2019,
note = {\url{https://isa-afp.org/entries/Aristotles_Assertoric_Syllogistic.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Aristotles_Assertoric_Syllogistic/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Aristotles_Assertoric_Syllogistic/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Aristotles_Assertoric_Syllogistic/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Aristotles_Assertoric_Syllogistic-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Aristotles_Assertoric_Syllogistic-2020-04-18.tar.gz">
+ afp-Aristotles_Assertoric_Syllogistic-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Aristotles_Assertoric_Syllogistic-2019-10-17.tar.gz">
afp-Aristotles_Assertoric_Syllogistic-2019-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/Arith_Prog_Rel_Primes.html b/web/entries/Arith_Prog_Rel_Primes.html
--- a/web/entries/Arith_Prog_Rel_Primes.html
+++ b/web/entries/Arith_Prog_Rel_Primes.html
@@ -1,198 +1,203 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Arithmetic progressions and relative 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>rithmetic
progressions
and
relative
primes
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Arithmetic progressions and relative primes</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
<a href="https://josephcmac.github.io/">José Manuel Rodríguez Caballero</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-02-01</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This article provides a formalization of the solution obtained by the
author of the Problem “ARITHMETIC PROGRESSIONS” from the
<a href="https://www.ocf.berkeley.edu/~wwu/riddles/putnam.shtml">
Putnam exam problems of 2002</a>. The statement of the problem is
as follows: For which integers <em>n</em> > 1 does the set of positive
integers less than and relatively prime to <em>n</em> constitute an
arithmetic progression?</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Arith_Prog_Rel_Primes-AFP,
author = {José Manuel Rodríguez Caballero},
title = {Arithmetic progressions and relative primes},
journal = {Archive of Formal Proofs},
month = feb,
year = 2020,
note = {\url{https://isa-afp.org/entries/Arith_Prog_Rel_Primes.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Arith_Prog_Rel_Primes/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Arith_Prog_Rel_Primes/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Arith_Prog_Rel_Primes/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Arith_Prog_Rel_Primes-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Arith_Prog_Rel_Primes-2020-04-18.tar.gz">
+ afp-Arith_Prog_Rel_Primes-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Arith_Prog_Rel_Primes-2020-02-10.tar.gz">
afp-Arith_Prog_Rel_Primes-2020-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/ArrowImpossibilityGS.html b/web/entries/ArrowImpossibilityGS.html
--- a/web/entries/ArrowImpossibilityGS.html
+++ b/web/entries/ArrowImpossibilityGS.html
@@ -1,272 +1,277 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>rrow
and
<font class="first">G</font>ibbard-Satterthwaite
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-ArrowImpossibilityGS-2020-04-18.tar.gz">
+ afp-ArrowImpossibilityGS-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-ArrowImpossibilityGS-2019-06-11.tar.gz">
afp-ArrowImpossibilityGS-2019-06-11.tar.gz
</a>
</li>
<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,197 +1,202 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>uto2
<font class="first">P</font>rover
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Auto2_HOL-2020-04-18.tar.gz">
+ afp-Auto2_HOL-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Auto2_HOL-2019-06-11.tar.gz">
afp-Auto2_HOL-2019-06-11.tar.gz
</a>
</li>
<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,208 +1,213 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Auto2_Imperative_HOL-2020-04-18.tar.gz">
+ afp-Auto2_Imperative_HOL-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Auto2_Imperative_HOL-2019-06-11.tar.gz">
afp-Auto2_Imperative_HOL-2019-06-11.tar.gz
</a>
</li>
<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,264 +1,269 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-AutoFocus-Stream-2020-04-18.tar.gz">
+ afp-AutoFocus-Stream-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-AutoFocus-Stream-2019-06-11.tar.gz">
afp-AutoFocus-Stream-2019-06-11.tar.gz
</a>
</li>
<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/Automated_Stateful_Protocol_Verification.html b/web/entries/Automated_Stateful_Protocol_Verification.html
--- a/web/entries/Automated_Stateful_Protocol_Verification.html
+++ b/web/entries/Automated_Stateful_Protocol_Verification.html
@@ -1,196 +1,202 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Automated Stateful Protocol 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>utomated
<font class="first">S</font>tateful
<font class="first">P</font>rotocol
<font class="first">V</font>erification
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Automated Stateful Protocol Verification</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Andreas V. Hess (avhe /at/ dtu /dot/ dk),
<a href="https://people.compute.dtu.dk/samo/">Sebastian Mödersheim</a>,
<a href="https://www.brucker.ch">Achim D. Brucker</a> and
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-04-08</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In protocol verification we observe a wide spectrum from fully
automated methods to interactive theorem proving with proof assistants
like Isabelle/HOL. In this AFP entry, we present a fully-automated
approach for verifying stateful security protocols, i.e., protocols
with mutable state that may span several sessions. The approach
supports reachability goals like secrecy and authentication. We also
include a simple user-friendly transaction-based protocol
specification language that is embedded into Isabelle.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Automated_Stateful_Protocol_Verification-AFP,
author = {Andreas V. Hess and Sebastian Mödersheim and Achim D. Brucker and Anders Schlichtkrull},
title = {Automated Stateful Protocol Verification},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/Automated_Stateful_Protocol_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="Stateful_Protocol_Composition_and_Typing.html">Stateful_Protocol_Composition_and_Typing</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Automated_Stateful_Protocol_Verification/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Automated_Stateful_Protocol_Verification/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Automated_Stateful_Protocol_Verification/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Automated_Stateful_Protocol_Verification-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Automated_Stateful_Protocol_Verification-2020-05-20.tar.gz">
+ afp-Automated_Stateful_Protocol_Verification-2020-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/Automatic_Refinement.html b/web/entries/Automatic_Refinement.html
--- a/web/entries/Automatic_Refinement.html
+++ b/web/entries/Automatic_Refinement.html
@@ -1,241 +1,246 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>utomatic
<font class="first">D</font>ata
<font class="first">R</font>efinement
</h1>
<p>&nbsp;</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">
Peter Lammich
</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Automatic_Refinement-2020-04-18.tar.gz">
+ afp-Automatic_Refinement-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Automatic_Refinement-2019-06-11.tar.gz">
afp-Automatic_Refinement-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-AxiomaticCategoryTheory-2020-04-18.tar.gz">
+ afp-AxiomaticCategoryTheory-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-AxiomaticCategoryTheory-2019-06-11.tar.gz">
afp-AxiomaticCategoryTheory-2019-06-11.tar.gz
</a>
</li>
<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,273 +1,278 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>DD
<font class="first">N</font>ormalisation
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-BDD-2020-04-18.tar.gz">
+ afp-BDD-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-BDD-2019-06-11.tar.gz">
afp-BDD-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-BNF_CC-2020-04-18.tar.gz">
+ afp-BNF_CC-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-BNF_CC-2019-06-11.tar.gz">
afp-BNF_CC-2019-06-11.tar.gz
</a>
</li>
<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,208 +1,213 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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),
<a href="https://www.andreipopescu.uk">Andrei Popescu</a> and
<a href="https://traytel.bitbucket.io">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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-BNF_Operations-2020-04-18.tar.gz">
+ afp-BNF_Operations-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-BNF_Operations-2019-06-11.tar.gz">
afp-BNF_Operations-2019-06-11.tar.gz
</a>
</li>
<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/BTree.html b/web/entries/BTree.html
new file mode 100644
--- /dev/null
+++ b/web/entries/BTree.html
@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>A Verified Imperative Implementation of B-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">
+<!-- MathJax for LaTeX support in abstracts -->
+<script>
+MathJax = {
+ tex: {
+ inlineMath: [['$', '$'], ['\\(', '\\)']]
+ },
+ processEscapes: true,
+ svg: {
+ fontCache: 'global'
+ }
+};
+</script>
+<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
+</head>
+
+<body class="mathjax_ignore">
+
+<table width="100%">
+<tbody>
+<tr>
+
+<!-- Navigation -->
+<td width="20%" align="center" valign="top">
+ <p>&nbsp;</p>
+ <a href="https://www.isa-afp.org/">
+ <img src="../images/isabelle.png" width="100" height="88" border=0>
+ </a>
+ <p>&nbsp;</p>
+ <p>&nbsp;</p>
+ <table class="nav" width="80%">
+ <tr>
+ <td class="nav" width="100%"><a href="../index.html">Home</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../about.html">About</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../submitting.html">Submission</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../updating.html">Updating Entries</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../using.html">Using Entries</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../search.html">Search</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../statistics.html">Statistics</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../topics.html">Index</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../download.html">Download</a></td>
+ </tr>
+ </table>
+ <p>&nbsp;</p>
+ <p>&nbsp;</p>
+</td>
+
+
+<!-- Content -->
+<td width="80%" valign="top">
+<div align="center">
+ <p>&nbsp;</p>
+ <h1> <font class="first">A</font>
+
+ <font class="first">V</font>erified
+
+ <font class="first">I</font>mperative
+
+ <font class="first">I</font>mplementation
+
+ of
+
+ <font class="first">B</font>-Trees
+
+</h1>
+ <p>&nbsp;</p>
+
+<table width="80%" class="data">
+<tbody>
+<tr>
+ <td class="datahead" width="20%">Title:</td>
+ <td class="data" width="80%">A Verified Imperative Implementation of B-Trees</td>
+</tr>
+
+<tr>
+ <td class="datahead">
+ Author:
+ </td>
+ <td class="data">
+ Niels Mündler (n /dot/ muendler /at/ tum /dot/ de)
+ </td>
+</tr>
+
+
+
+<tr>
+ <td class="datahead">Submission date:</td>
+ <td class="data">2021-02-24</td>
+</tr>
+
+<tr>
+ <td class="datahead" valign="top">Abstract:</td>
+ <td class="abstract mathjax_process">
+In this work, we use the interactive theorem prover Isabelle/HOL to
+verify an imperative implementation of the classical B-tree data
+structure invented by Bayer and McCreight [ACM 1970]. The
+implementation supports set membership and insertion queries with
+efficient binary search for intra-node navigation. This is
+accomplished by first specifying the structure abstractly in the
+functional modeling language HOL and proving functional correctness.
+Using manual refinement, we derive an imperative implementation in
+Imperative/HOL. We show the validity of this refinement using the
+separation logic utilities from the <a
+href="https://www.isa-afp.org/entries/Refine_Imperative_HOL.html">
+Isabelle Refinement Framework </a> . The code can be exported to
+the programming languages SML and Scala. We examine the runtime of all
+operations indirectly by reproducing results of the logarithmic
+relationship between height and the number of nodes. The results are
+discussed in greater detail in the corresponding <a
+href="https://mediatum.ub.tum.de/1596550">Bachelor's
+Thesis</a>.</td>
+</tr>
+
+
+<tr>
+ <td class="datahead" valign="top">BibTeX:</td>
+ <td class="formatted">
+ <pre>@article{BTree-AFP,
+ author = {Niels Mündler},
+ title = {A Verified Imperative Implementation of B-Trees},
+ journal = {Archive of Formal Proofs},
+ month = feb,
+ year = 2021,
+ note = {\url{https://isa-afp.org/entries/BTree.html},
+ Formal proof development},
+ ISSN = {2150-914x},
+}</pre>
+ </td>
+</tr>
+
+ <tr><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/BTree/outline.pdf">Proof outline</a><br>
+ <a href="../browser_info/current/AFP/BTree/document.pdf">Proof document</a>
+ </td>
+ </tr>
+ <tr>
+ <td class="links">
+ <a href="../browser_info/current/AFP/BTree/index.html">Browse theories</a>
+ </td></tr>
+ <tr>
+ <td class="links">
+ <a href="../release/afp-BTree-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/Banach_Steinhaus.html b/web/entries/Banach_Steinhaus.html
--- a/web/entries/Banach_Steinhaus.html
+++ b/web/entries/Banach_Steinhaus.html
@@ -1,186 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Banach-Steinhaus 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>anach-Steinhaus
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Banach-Steinhaus Theorem</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://kodu.ut.ee/~unruh/">Dominique Unruh</a> and
<a href="https://josephcmac.github.io/">Jose Manuel Rodriguez Caballero</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-05-02</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We formalize in Isabelle/HOL a result
due to S. Banach and H. Steinhaus known as
the Banach-Steinhaus theorem or Uniform boundedness principle: a
pointwise-bounded family of continuous linear operators from a Banach
space to a normed space is uniformly bounded. Our approach is an
adaptation to Isabelle/HOL of a proof due to A. Sokal.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Banach_Steinhaus-AFP,
author = {Dominique Unruh and Jose Manuel Rodriguez Caballero},
title = {Banach-Steinhaus Theorem},
journal = {Archive of Formal Proofs},
month = may,
year = 2020,
note = {\url{https://isa-afp.org/entries/Banach_Steinhaus.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Banach_Steinhaus/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Banach_Steinhaus/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Banach_Steinhaus/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Banach_Steinhaus-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Banach_Steinhaus-2020-05-11.tar.gz">
+ afp-Banach_Steinhaus-2020-05-11.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Banach_Steinhaus-2020-05-06.tar.gz">
+ afp-Banach_Steinhaus-2020-05-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/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,230 +1,235 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Bell_Numbers_Spivey-2020-04-18.tar.gz">
+ afp-Bell_Numbers_Spivey-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Bell_Numbers_Spivey-2019-06-11.tar.gz">
afp-Bell_Numbers_Spivey-2019-06-11.tar.gz
</a>
</li>
<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,236 +1,241 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://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
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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 mathjax_process">
<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{https://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">Used by:</td>
<td class="data"><a href="Algebraic_Numbers.html">Algebraic_Numbers</a>, <a href="LLL_Basis_Reduction.html">LLL_Basis_Reduction</a>, <a href="Smith_Normal_Form.html">Smith_Normal_Form</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Berlekamp_Zassenhaus-2020-04-18.tar.gz">
+ afp-Berlekamp_Zassenhaus-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Berlekamp_Zassenhaus-2019-06-11.tar.gz">
afp-Berlekamp_Zassenhaus-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>ernoulli
<font class="first">N</font>umbers
</h1>
<p>&nbsp;</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 mathjax_process">
<p>Bernoulli numbers were first discovered in the closed-form
expansion of the sum 1<sup>m</sup> +
2<sup>m</sup> + &hellip; + 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&ndash;Tanigawa algorithm for computing Bernoulli numbers
with reasonable efficiency, and we define the periodic Bernoulli
polynomials (which appear e.g. in the Euler&ndash;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{https://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="Lambert_W.html">Lambert_W</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Bernoulli-2020-04-18.tar.gz">
+ afp-Bernoulli-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Bernoulli-2019-06-11.tar.gz">
afp-Bernoulli-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>ertrand's
postulate
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Bertrands_Postulate-2020-04-18.tar.gz">
+ afp-Bertrands_Postulate-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Bertrands_Postulate-2019-06-11.tar.gz">
afp-Bertrands_Postulate-2019-06-11.tar.gz
</a>
</li>
<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/Bicategory.html b/web/entries/Bicategory.html
--- a/web/entries/Bicategory.html
+++ b/web/entries/Bicategory.html
@@ -1,218 +1,223 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Bicategories - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>icategories
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Bicategories</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">2020-01-06</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>
Taking as a starting point the author's previous work on
developing aspects of category theory in Isabelle/HOL, this article
gives a compatible formalization of the notion of
"bicategory" and develops a framework within which formal
proofs of facts about bicategories can be given. The framework
includes a number of basic results, including the Coherence Theorem,
the Strictness Theorem, pseudofunctors and biequivalence, and facts
about internal equivalences and adjunctions in a bicategory. As a
driving application and demonstration of the utility of the framework,
it is used to give a formal proof of a theorem, due to Carboni,
Kasangian, and Street, that characterizes up to biequivalence the
bicategories of spans in a category with pullbacks. The formalization
effort necessitated the filling-in of many details that were not
evident from the brief presentation in the original paper, as well as
identifying a few minor corrections along the way.
</p><p>
Revisions made subsequent to the first version of this article added
additional material on pseudofunctors, pseudonatural transformations,
modifications, and equivalence of bicategories; the main thrust being
to give a proof that a pseudofunctor is a biequivalence if and only
if it can be extended to an equivalence of bicategories.
</p></td>
</tr>
<tr>
<td class="datahead" valign="top">Change history:</td>
<td class="abstract">[2020-02-15]:
Move ConcreteCategory.thy from Bicategory to Category3 and use it systematically.
Make other minor improvements throughout.
(revision a51840d36867)<br>
[2020-11-04]:
Added new material on equivalence of bicategories, with associated changes.
(revision 472cb2268826)<br></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Bicategory-AFP,
author = {Eugene W. Stark},
title = {Bicategories},
journal = {Archive of Formal Proofs},
month = jan,
year = 2020,
note = {\url{https://isa-afp.org/entries/Bicategory.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="MonoidalCategory.html">MonoidalCategory</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Bicategory/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Bicategory/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Bicategory/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Bicategory-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Bicategory-2020-04-18.tar.gz">
+ afp-Bicategory-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Bicategory-2020-01-09.tar.gz">
afp-Bicategory-2020-01-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/BinarySearchTree.html b/web/entries/BinarySearchTree.html
--- a/web/entries/BinarySearchTree.html
+++ b/web/entries/BinarySearchTree.html
@@ -1,292 +1,297 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>inary
<font class="first">S</font>earch
<font class="first">T</font>rees
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-BinarySearchTree-2020-04-18.tar.gz">
+ afp-BinarySearchTree-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-BinarySearchTree-2019-06-11.tar.gz">
afp-BinarySearchTree-2019-06-11.tar.gz
</a>
</li>
<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,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Binding_Syntax_Theory-2020-04-18.tar.gz">
+ afp-Binding_Syntax_Theory-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Binding_Syntax_Theory-2019-06-11.tar.gz">
afp-Binding_Syntax_Theory-2019-06-11.tar.gz
</a>
</li>
<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,277 +1,282 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
Peter Lammich
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Binomial-Heaps-2020-04-18.tar.gz">
+ afp-Binomial-Heaps-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Binomial-Heaps-2019-06-11.tar.gz">
afp-Binomial-Heaps-2019-06-11.tar.gz
</a>
</li>
<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,247 +1,252 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>unctional
<font class="first">B</font>inomial
<font class="first">Q</font>ueues
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Binomial-Queues-2020-04-18.tar.gz">
+ afp-Binomial-Queues-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Binomial-Queues-2019-06-11.tar.gz">
afp-Binomial-Queues-2019-06-11.tar.gz
</a>
</li>
<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/BirdKMP.html b/web/entries/BirdKMP.html
--- a/web/entries/BirdKMP.html
+++ b/web/entries/BirdKMP.html
@@ -1,202 +1,208 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Putting the `K' into Bird's derivation of Knuth-Morris-Pratt string 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>utting
the
<font class="first">`</font>K'
into
<font class="first">B</font>ird's
derivation
of
<font class="first">K</font>nuth-Morris-Pratt
string
matching
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Putting the `K' into Bird's derivation of Knuth-Morris-Pratt string 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">2020-08-25</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Richard Bird and collaborators have proposed a derivation of an
intricate cyclic program that implements the Morris-Pratt string
matching algorithm. Here we provide a proof of total correctness for
Bird's derivation and complete it by adding Knuth's
optimisation.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{BirdKMP-AFP,
author = {Peter Gammie},
title = {Putting the `K' into Bird's derivation of Knuth-Morris-Pratt string matching},
journal = {Archive of Formal Proofs},
month = aug,
year = 2020,
note = {\url{https://isa-afp.org/entries/BirdKMP.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="HOLCF-Prelude.html">HOLCF-Prelude</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/BirdKMP/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/BirdKMP/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/BirdKMP/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-BirdKMP-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-BirdKMP-2020-09-02.tar.gz">
+ afp-BirdKMP-2020-09-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/Blue_Eyes.html b/web/entries/Blue_Eyes.html
--- a/web/entries/Blue_Eyes.html
+++ b/web/entries/Blue_Eyes.html
@@ -1,195 +1,201 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Solution to the xkcd Blue Eyes puzzle - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>olution
to
the
xkcd
<font class="first">B</font>lue
<font class="first">E</font>yes
puzzle
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Solution to the xkcd Blue Eyes puzzle</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Jakub Kądziołka (kuba /at/ kadziolka /dot/ net)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2021-01-30</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In a <a href="https://xkcd.com/blue_eyes.html">puzzle published by
Randall Munroe</a>, perfect logicians forbidden
from communicating are stranded on an island, and may only leave once
they have figured out their own eye color. We present a method of
modeling the behavior of perfect logicians and formalize a solution of
the puzzle.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Blue_Eyes-AFP,
author = {Jakub Kądziołka},
title = {Solution to the xkcd Blue Eyes puzzle},
journal = {Archive of Formal Proofs},
month = jan,
year = 2021,
note = {\url{https://isa-afp.org/entries/Blue_Eyes.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Blue_Eyes/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Blue_Eyes/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Blue_Eyes/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Blue_Eyes-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Blue_Eyes-2021-02-01.tar.gz">
+ afp-Blue_Eyes-2021-02-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/Bondy.html b/web/entries/Bondy.html
--- a/web/entries/Bondy.html
+++ b/web/entries/Bondy.html
@@ -1,236 +1,241 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>ondy's
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Bondy-2020-04-18.tar.gz">
+ afp-Bondy-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Bondy-2019-06-11.tar.gz">
afp-Bondy-2019-06-11.tar.gz
</a>
</li>
<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,232 +1,237 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>oolean
<font class="first">E</font>xpression
<font class="first">C</font>heckers
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Boolean_Expression_Checkers-2020-04-18.tar.gz">
+ afp-Boolean_Expression_Checkers-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Boolean_Expression_Checkers-2019-06-11.tar.gz">
afp-Boolean_Expression_Checkers-2019-06-11.tar.gz
</a>
</li>
<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,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>ounded-Deducibility
<font class="first">S</font>ecurity
</h1>
<p>&nbsp;</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">
<a href="https://www.andreipopescu.uk">Andrei Popescu</a> and
Peter Lammich
</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Bounded_Deducibility_Security-2020-04-18.tar.gz">
+ afp-Bounded_Deducibility_Security-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Bounded_Deducibility_Security-2019-06-11.tar.gz">
afp-Bounded_Deducibility_Security-2019-06-11.tar.gz
</a>
</li>
<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,206 +1,211 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>üchi
<font class="first">C</font>omplementation
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Buchi_Complementation-2020-04-18.tar.gz">
+ afp-Buchi_Complementation-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Buchi_Complementation-2019-06-11.tar.gz">
afp-Buchi_Complementation-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Budan_Fourier-2020-04-18.tar.gz">
+ afp-Budan_Fourier-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Budan_Fourier-2019-06-11.tar.gz">
afp-Budan_Fourier-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>uffon's
<font class="first">N</font>eedle
<font class="first">P</font>roblem
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Buffons_Needle-2020-04-18.tar.gz">
+ afp-Buffons_Needle-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Buffons_Needle-2019-06-11.tar.gz">
afp-Buffons_Needle-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Buildings-2020-04-18.tar.gz">
+ afp-Buildings-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Buildings-2019-06-11.tar.gz">
afp-Buildings-2019-06-11.tar.gz
</a>
</li>
<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,276 +1,281 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-BytecodeLogicJmlTypes-2020-04-18.tar.gz">
+ afp-BytecodeLogicJmlTypes-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-BytecodeLogicJmlTypes-2019-06-11.tar.gz">
afp-BytecodeLogicJmlTypes-2019-06-11.tar.gz
</a>
</li>
<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/C2KA_DistributedSystems.html b/web/entries/C2KA_DistributedSystems.html
--- a/web/entries/C2KA_DistributedSystems.html
+++ b/web/entries/C2KA_DistributedSystems.html
@@ -1,212 +1,217 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Communicating Concurrent Kleene Algebra for Distributed Systems Specification - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ommunicating
<font class="first">C</font>oncurrent
<font class="first">K</font>leene
<font class="first">A</font>lgebra
for
<font class="first">D</font>istributed
<font class="first">S</font>ystems
<font class="first">S</font>pecification
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Communicating Concurrent Kleene Algebra for Distributed Systems Specification</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Maxime Buyse (maxime /dot/ buyse /at/ polytechnique /dot/ edu) and
<a href="https://carleton.ca/jaskolka/">Jason Jaskolka</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-08-06</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Communicating Concurrent Kleene Algebra (C²KA) is a mathematical
framework for capturing the communicating and concurrent behaviour of
agents in distributed systems. It extends Hoare et al.'s
Concurrent Kleene Algebra (CKA) with communication actions through the
notions of stimuli and shared environments. C²KA has applications in
studying system-level properties of distributed systems such as
safety, security, and reliability. In this work, we formalize results
about C²KA and its application for distributed systems specification.
We first formalize the stimulus structure and behaviour structure
(CKA). Next, we combine them to formalize C²KA and its properties.
Then, we formalize notions and properties related to the topology of
distributed systems and the potential for communication via stimuli
and via shared environments of agents, all within the algebraic
setting of C²KA.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{C2KA_DistributedSystems-AFP,
author = {Maxime Buyse and Jason Jaskolka},
title = {Communicating Concurrent Kleene Algebra for Distributed Systems Specification},
journal = {Archive of Formal Proofs},
month = aug,
year = 2019,
note = {\url{https://isa-afp.org/entries/C2KA_DistributedSystems.html},
Formal proof development},
ISSN = {2150-914x},
}</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/C2KA_DistributedSystems/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/C2KA_DistributedSystems/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/C2KA_DistributedSystems/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-C2KA_DistributedSystems-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-C2KA_DistributedSystems-2020-04-18.tar.gz">
+ afp-C2KA_DistributedSystems-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-C2KA_DistributedSystems-2019-08-06.tar.gz">
afp-C2KA_DistributedSystems-2019-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/CAVA_Automata.html b/web/entries/CAVA_Automata.html
--- a/web/entries/CAVA_Automata.html
+++ b/web/entries/CAVA_Automata.html
@@ -1,250 +1,255 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Peter Lammich
</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 mathjax_process">
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{https://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">Used by:</td>
<td class="data"><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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CAVA_Automata-2020-04-18.tar.gz">
+ afp-CAVA_Automata-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CAVA_Automata-2019-06-11.tar.gz">
afp-CAVA_Automata-2019-06-11.tar.gz
</a>
</li>
<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,256 +1,261 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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>,
Peter Lammich,
René Neumann (rene /dot/ neumann /at/ in /dot/ tum /dot/ de),
<a href="http://www21.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 mathjax_process">
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{https://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>
</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CAVA_LTL_Modelchecker-2020-04-18.tar.gz">
+ afp-CAVA_LTL_Modelchecker-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CAVA_LTL_Modelchecker-2019-06-11.tar.gz">
afp-CAVA_LTL_Modelchecker-2019-06-11.tar.gz
</a>
</li>
<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,241 +1,246 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>CS
in
nominal
logic
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CCS-2020-04-18.tar.gz">
+ afp-CCS-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CCS-2019-06-11.tar.gz">
afp-CCS-2019-06-11.tar.gz
</a>
</li>
<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,253 +1,258 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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),
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a> 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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CISC-Kernel-2020-04-18.tar.gz">
+ afp-CISC-Kernel-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CISC-Kernel-2019-06-11.tar.gz">
afp-CISC-Kernel-2019-06-11.tar.gz
</a>
</li>
<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,237 +1,242 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CRDT-2020-04-18.tar.gz">
+ afp-CRDT-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CRDT-2019-06-11.tar.gz">
afp-CRDT-2019-06-11.tar.gz
</a>
</li>
<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/CSP_RefTK.html b/web/entries/CSP_RefTK.html
--- a/web/entries/CSP_RefTK.html
+++ b/web/entries/CSP_RefTK.html
@@ -1,203 +1,209 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>The HOL-CSP Refinement Toolkit - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">H</font>OL-CSP
<font class="first">R</font>efinement
<font class="first">T</font>oolkit
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">The HOL-CSP Refinement Toolkit</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Safouan Taha (safouan /dot/ taha /at/ lri /dot/ fr),
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a> and
Lina Ye (lina /dot/ ye /at/ lri /dot/ fr)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-11-19</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We use a formal development for CSP, called HOL-CSP2.0, to analyse a
family of refinement notions, comprising classic and new ones. This
analysis enables to derive a number of properties that allow to deepen
the understanding of these notions, in particular with respect to
specification decomposition principles for the case of infinite sets
of events. The established relations between the refinement relations
help to clarify some obscure points in the CSP literature, but also
provide a weapon for shorter refinement proofs. Furthermore, we
provide a framework for state-normalisation allowing to formally
reason on parameterised process architectures. As a result, we have a
modern environment for formal proofs of concurrent systems that allow
for the combination of general infinite processes with locally finite
ones in a logically safe way. We demonstrate these
verification-techniques for classical, generalised examples: The
CopyBuffer for arbitrary data and the Dijkstra's Dining
Philosopher Problem of arbitrary size.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{CSP_RefTK-AFP,
author = {Safouan Taha and Burkhart Wolff and Lina Ye},
title = {The HOL-CSP Refinement Toolkit},
journal = {Archive of Formal Proofs},
month = nov,
year = 2020,
note = {\url{https://isa-afp.org/entries/CSP_RefTK.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="HOL-CSP.html">HOL-CSP</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/CSP_RefTK/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/CSP_RefTK/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/CSP_RefTK/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-CSP_RefTK-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-CSP_RefTK-2021-01-12.tar.gz">
+ afp-CSP_RefTK-2021-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/CYK.html b/web/entries/CYK.html
--- a/web/entries/CYK.html
+++ b/web/entries/CYK.html
@@ -1,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
formalisation
of
the
<font class="first">C</font>ocke-Younger-Kasami
algorithm
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CYK-2020-04-18.tar.gz">
+ afp-CYK-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CYK-2019-06-11.tar.gz">
afp-CYK-2019-06-11.tar.gz
</a>
</li>
<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,207 +1,212 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>akeML
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="CakeML_Codegen.html">CakeML_Codegen</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CakeML-2020-04-18.tar.gz">
+ afp-CakeML-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CakeML-2019-06-11.tar.gz">
afp-CakeML-2019-06-11.tar.gz
</a>
</li>
<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/CakeML_Codegen.html b/web/entries/CakeML_Codegen.html
--- a/web/entries/CakeML_Codegen.html
+++ b/web/entries/CakeML_Codegen.html
@@ -1,205 +1,210 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Verified Code Generator from Isabelle/HOL to 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">V</font>erified
<font class="first">C</font>ode
<font class="first">G</font>enerator
from
<font class="first">I</font>sabelle/HOL
to
<font class="first">C</font>akeML
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Verified Code Generator from Isabelle/HOL to CakeML</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">2019-07-08</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This entry contains the formalization that accompanies my PhD thesis
(see https://lars.hupel.info/research/codegen/). I develop a verified
compilation toolchain from executable specifications in Isabelle/HOL
to CakeML abstract syntax trees. This improves over the
state-of-the-art in Isabelle by providing a trustworthy procedure for
code generation.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{CakeML_Codegen-AFP,
author = {Lars Hupel},
title = {A Verified Code Generator from Isabelle/HOL to CakeML},
journal = {Archive of Formal Proofs},
month = jul,
year = 2019,
note = {\url{https://isa-afp.org/entries/CakeML_Codegen.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="CakeML.html">CakeML</a>, <a href="Constructor_Funs.html">Constructor_Funs</a>, <a href="Dict_Construction.html">Dict_Construction</a>, <a href="Higher_Order_Terms.html">Higher_Order_Terms</a>, <a href="Huffman.html">Huffman</a>, <a href="Pairing_Heap.html">Pairing_Heap</a>, <a href="Root_Balanced_Tree.html">Root_Balanced_Tree</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_Codegen/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/CakeML_Codegen/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/CakeML_Codegen/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-CakeML_Codegen-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CakeML_Codegen-2020-04-18.tar.gz">
+ afp-CakeML_Codegen-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CakeML_Codegen-2019-07-11.tar.gz">
afp-CakeML_Codegen-2019-07-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/Call_Arity.html b/web/entries/Call_Arity.html
--- a/web/entries/Call_Arity.html
+++ b/web/entries/Call_Arity.html
@@ -1,255 +1,260 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Call_Arity-2020-04-18.tar.gz">
+ afp-Call_Arity-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Call_Arity-2019-06-11.tar.gz">
afp-Call_Arity-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ardinality
of
<font class="first">E</font>quivalence
<font class="first">R</font>elations
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Card_Equiv_Relations-2020-04-18.tar.gz">
+ afp-Card_Equiv_Relations-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Card_Equiv_Relations-2019-06-11.tar.gz">
afp-Card_Equiv_Relations-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ardinality
of
<font class="first">M</font>ultisets
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Card_Multisets-2020-04-18.tar.gz">
+ afp-Card_Multisets-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Card_Multisets-2019-06-11.tar.gz">
afp-Card_Multisets-2019-06-11.tar.gz
</a>
</li>
<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,225 +1,230 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ardinality
of
<font class="first">N</font>umber
<font class="first">P</font>artitions
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Card_Number_Partitions-2020-04-18.tar.gz">
+ afp-Card_Number_Partitions-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Card_Number_Partitions-2019-06-11.tar.gz">
afp-Card_Number_Partitions-2019-06-11.tar.gz
</a>
</li>
<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,227 +1,232 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ardinality
of
<font class="first">S</font>et
<font class="first">P</font>artitions
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Card_Partitions-2020-04-18.tar.gz">
+ afp-Card_Partitions-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Card_Partitions-2019-06-11.tar.gz">
afp-Card_Partitions-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Cartan_FP-2020-04-18.tar.gz">
+ afp-Cartan_FP-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Cartan_FP-2019-06-11.tar.gz">
afp-Cartan_FP-2019-06-11.tar.gz
</a>
</li>
<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,239 +1,244 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Case_Labeling-2020-04-18.tar.gz">
+ afp-Case_Labeling-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Case_Labeling-2019-06-11.tar.gz">
afp-Case_Labeling-2019-06-11.tar.gz
</a>
</li>
<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,215 +1,220 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>atalan
<font class="first">N</font>umbers
</h1>
<p>&nbsp;</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 mathjax_process">
<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> / (&radic;<span
style="text-decoration: overline">&pi;</span> &middot;
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Catalan_Numbers-2020-04-18.tar.gz">
+ afp-Catalan_Numbers-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Catalan_Numbers-2019-06-11.tar.gz">
afp-Catalan_Numbers-2019-06-11.tar.gz
</a>
</li>
<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,300 +1,305 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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://foss.heptapod.net/isa-afp/afp-devel/-/commit/3498bb1e4c7ba468db8588eb7184c1849641f7d3">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Category-2020-04-18.tar.gz">
+ afp-Category-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Category-2019-06-11.tar.gz">
afp-Category-2019-06-11.tar.gz
</a>
</li>
<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,260 +1,265 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ategory
<font class="first">T</font>heory
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Category2-2020-04-18.tar.gz">
+ afp-Category2-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Category2-2019-06-11.tar.gz">
afp-Category2-2019-06-11.tar.gz
</a>
</li>
<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,276 +1,281 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<p>
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.
</p><p>
Revisions made subsequent to the first version of this article added
material on equivalence of categories, cartesian categories,
categories with pullbacks, categories with finite limits, and
cartesian closed categories. A construction was given of the category
of hereditarily finite sets and functions between them, and it was
shown that this category is cartesian closed.
</p></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>
[2020-02-15]:
Move ConcreteCategory.thy from Bicategory to Category3 and use it systematically.
Make other minor improvements throughout.
(revision a51840d36867)<br>
[2020-07-10]:
Added new material, mostly centered around cartesian categories.
(revision 06640f317a79)<br>
[2020-11-04]:
Minor modifications and extensions made in conjunction with the addition
of new material to Bicategory.
(revision 472cb2268826)<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{https://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">Depends on:</td>
<td class="data"><a href="HereditarilyFinite.html">HereditarilyFinite</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Category3-2020-04-18.tar.gz">
+ afp-Category3-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Category3-2019-06-11.tar.gz">
afp-Category3-2019-06-11.tar.gz
</a>
</li>
<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,287 +1,292 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Cauchy-2020-04-18.tar.gz">
+ afp-Cauchy-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Cauchy-2019-06-11.tar.gz">
afp-Cauchy-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">C</font>ayley-Hamilton
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Cayley_Hamilton-2020-04-18.tar.gz">
+ afp-Cayley_Hamilton-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Cayley_Hamilton-2019-06-11.tar.gz">
afp-Cayley_Hamilton-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ertification
<font class="first">M</font>onads
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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="AI_Planning_Languages_Semantics.html">AI_Planning_Languages_Semantics</a>, <a href="WOOT_Strong_Eventual_Consistency.html">WOOT_Strong_Eventual_Consistency</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/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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Certification_Monads-2020-04-18.tar.gz">
+ afp-Certification_Monads-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Certification_Monads-2019-06-11.tar.gz">
afp-Certification_Monads-2019-06-11.tar.gz
</a>
</li>
<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/Chandy_Lamport.html b/web/entries/Chandy_Lamport.html
--- a/web/entries/Chandy_Lamport.html
+++ b/web/entries/Chandy_Lamport.html
@@ -1,201 +1,207 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Formal Proof of The Chandy--Lamport Distributed Snapshot 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">F</font>ormal
<font class="first">P</font>roof
of
<font class="first">T</font>he
<font class="first">C</font>handy--Lamport
<font class="first">D</font>istributed
<font class="first">S</font>napshot
<font class="first">A</font>lgorithm
</h1>
<p>&nbsp;</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 Chandy--Lamport Distributed Snapshot Algorithm</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Ben Fiedler (ben /dot/ fiedler /at/ inf /dot/ ethz /dot/ ch) and
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-07-21</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We provide a suitable distributed system model and implementation of the
Chandy--Lamport distributed snapshot algorithm [ACM Transactions on
Computer Systems, 3, 63-75, 1985]. Our main result is a formal
termination and correctness proof of the Chandy--Lamport algorithm and
its use in stable property detection.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Chandy_Lamport-AFP,
author = {Ben Fiedler and Dmitriy Traytel},
title = {A Formal Proof of The Chandy--Lamport Distributed Snapshot Algorithm},
journal = {Archive of Formal Proofs},
month = jul,
year = 2020,
note = {\url{https://isa-afp.org/entries/Chandy_Lamport.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="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/Chandy_Lamport/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Chandy_Lamport/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Chandy_Lamport/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Chandy_Lamport-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Chandy_Lamport-2020-08-04.tar.gz">
+ afp-Chandy_Lamport-2020-08-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/Chord_Segments.html b/web/entries/Chord_Segments.html
--- a/web/entries/Chord_Segments.html
+++ b/web/entries/Chord_Segments.html
@@ -1,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>ntersecting
<font class="first">C</font>hords
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Chord_Segments-2020-04-18.tar.gz">
+ afp-Chord_Segments-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Chord_Segments-2019-06-11.tar.gz">
afp-Chord_Segments-2019-06-11.tar.gz
</a>
</li>
<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,249 +1,254 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>sabelle/Circus
</h1>
<p>&nbsp;</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),
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a> 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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Circus-2020-04-18.tar.gz">
+ afp-Circus-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Circus-2019-06-11.tar.gz">
afp-Circus-2019-06-11.tar.gz
</a>
</li>
<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/Clean.html b/web/entries/Clean.html
--- a/web/entries/Clean.html
+++ b/web/entries/Clean.html
@@ -1,221 +1,226 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Clean - An Abstract Imperative Programming Language and its 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>lean
<font class="first">-</font>
<font class="first">A</font>n
<font class="first">A</font>bstract
<font class="first">I</font>mperative
<font class="first">P</font>rogramming
<font class="first">L</font>anguage
and
its
<font class="first">T</font>heory
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Clean - An Abstract Imperative Programming Language and its Theory</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://www.lri.fr/~ftuong/">Frédéric Tuong</a> and
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-10-04</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Clean is based on a simple, abstract execution model for an imperative
target language. “Abstract” is understood in contrast to “Concrete
Semantics”; alternatively, the term “shallow-style embedding” could be
used. It strives for a type-safe notion of program-variables, an
incremental construction of the typed state-space, support of
incremental verification, and open-world extensibility of new type
definitions being intertwined with the program definitions. Clean is
based on a “no-frills” state-exception monad with the usual
definitions of bind and unit for the compositional glue of state-based
computations. Clean offers conditionals and loops supporting C-like
control-flow operators such as break and return. The state-space
construction is based on the extensible record package. Direct
recursion of procedures is supported. Clean’s design strives for
extreme simplicity. It is geared towards symbolic execution and proven
correct verification tools. The underlying libraries of this package,
however, deliberately restrict themselves to the most elementary
infrastructure for these tasks. The package is intended to serve as
demonstrator semantic backend for Isabelle/C, or for the
test-generation techniques.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Clean-AFP,
author = {Frédéric Tuong and Burkhart Wolff},
title = {Clean - An Abstract Imperative Programming Language and its Theory},
journal = {Archive of Formal Proofs},
month = oct,
year = 2019,
note = {\url{https://isa-afp.org/entries/Clean.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Clean/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Clean/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Clean/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Clean-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Clean-2020-04-18.tar.gz">
+ afp-Clean-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Clean-2019-10-16.tar.gz">
afp-Clean-2019-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/ClockSynchInst.html b/web/entries/ClockSynchInst.html
--- a/web/entries/ClockSynchInst.html
+++ b/web/entries/ClockSynchInst.html
@@ -1,292 +1,297 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>nstances
of
<font class="first">S</font>chneider's
generalized
protocol
of
clock
synchronization
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-ClockSynchInst-2020-04-18.tar.gz">
+ afp-ClockSynchInst-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-ClockSynchInst-2019-06-11.tar.gz">
afp-ClockSynchInst-2019-06-11.tar.gz
</a>
</li>
<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/Closest_Pair_Points.html b/web/entries/Closest_Pair_Points.html
--- a/web/entries/Closest_Pair_Points.html
+++ b/web/entries/Closest_Pair_Points.html
@@ -1,204 +1,209 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Closest Pair of Points 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>losest
<font class="first">P</font>air
of
<font class="first">P</font>oints
<font class="first">A</font>lgorithms
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Closest Pair of Points Algorithms</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Martin Rau (martin /dot/ rau /at/ tum /dot/ de) and
<a href="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-01-13</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This entry provides two related verified divide-and-conquer algorithms
solving the fundamental <em>Closest Pair of Points</em>
problem in Computational Geometry. Functional correctness and the
optimal running time of <em>O</em>(<em>n</em> log <em>n</em>) are
proved. Executable code is generated which is empirically competitive
with handwritten reference implementations.</td>
</tr>
<tr>
<td class="datahead" valign="top">Change history:</td>
<td class="abstract">[2020-14-04]: Incorporate Time_Monad of the AFP entry Root_Balanced_Tree.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Closest_Pair_Points-AFP,
author = {Martin Rau and Tobias Nipkow},
title = {Closest Pair of Points Algorithms},
journal = {Archive of Formal Proofs},
month = jan,
year = 2020,
note = {\url{https://isa-afp.org/entries/Closest_Pair_Points.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Akra_Bazzi.html">Akra_Bazzi</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/Closest_Pair_Points/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Closest_Pair_Points/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Closest_Pair_Points/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Closest_Pair_Points-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Closest_Pair_Points-2020-04-18.tar.gz">
+ afp-Closest_Pair_Points-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Closest_Pair_Points-2020-01-14.tar.gz">
afp-Closest_Pair_Points-2020-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/CofGroups.html b/web/entries/CofGroups.html
--- a/web/entries/CofGroups.html
+++ b/web/entries/CofGroups.html
@@ -1,282 +1,287 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CofGroups-2020-04-18.tar.gz">
+ afp-CofGroups-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CofGroups-2019-06-11.tar.gz">
afp-CofGroups-2019-06-11.tar.gz
</a>
</li>
<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,310 +1,315 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>oinductive
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Coinductive-2020-04-18.tar.gz">
+ afp-Coinductive-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Coinductive-2019-06-11.tar.gz">
afp-Coinductive-2019-06-11.tar.gz
</a>
</li>
<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,251 +1,256 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://traytel.bitbucket.io">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 mathjax_process"><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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Coinductive_Languages-2020-04-18.tar.gz">
+ afp-Coinductive_Languages-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Coinductive_Languages-2019-06-11.tar.gz">
afp-Coinductive_Languages-2019-06-11.tar.gz
</a>
</li>
<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,307 +1,312 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ollections
<font class="first">F</font>ramework
</h1>
<p>&nbsp;</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">
Peter Lammich
</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 mathjax_process">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..&lt;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{https://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="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="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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Collections-2020-04-18.tar.gz">
+ afp-Collections-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Collections-2019-06-11.tar.gz">
afp-Collections-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ower
bound
on
comparison-based
sorting
algorithms
</h1>
<p>&nbsp;</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 mathjax_process">
<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>&nbsp;(n!)</em>
in the worst case, i.&thinsp;e.&nbsp;<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Comparison_Sort_Lower_Bound-2020-04-18.tar.gz">
+ afp-Comparison_Sort_Lower_Bound-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Comparison_Sort_Lower_Bound-2019-06-11.tar.gz">
afp-Comparison_Sort_Lower_Bound-2019-06-11.tar.gz
</a>
</li>
<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,282 +1,287 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ompiling
<font class="first">E</font>xceptions
<font class="first">C</font>orrectly
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Compiling-Exceptions-Correctly-2020-04-18.tar.gz">
+ afp-Compiling-Exceptions-Correctly-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Compiling-Exceptions-Correctly-2019-06-11.tar.gz">
afp-Compiling-Exceptions-Correctly-2019-06-11.tar.gz
</a>
</li>
<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/Complete_Non_Orders.html b/web/entries/Complete_Non_Orders.html
--- a/web/entries/Complete_Non_Orders.html
+++ b/web/entries/Complete_Non_Orders.html
@@ -1,205 +1,210 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Complete Non-Orders and Fixed Points - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>omplete
<font class="first">N</font>on-Orders
and
<font class="first">F</font>ixed
<font class="first">P</font>oints
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Complete Non-Orders and Fixed Points</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a> and
<a href="http://group-mmm.org/~dubut/">Jérémy Dubut</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-06-27</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We develop an Isabelle/HOL library of order-theoretic concepts, such
as various completeness conditions and fixed-point theorems. We keep
our formalization as general as possible: we reprove several
well-known results about complete orders, often without any properties
of ordering, thus complete non-orders. In particular, we generalize
the Knaster–Tarski theorem so that we ensure the existence of a
quasi-fixed point of monotone maps over complete non-orders, and show
that the set of quasi-fixed points is complete under a mild
condition—attractivity—which is implied by either antisymmetry or
transitivity. This result generalizes and strengthens a result by
Stauti and Maaden. Finally, we recover Kleene’s fixed-point theorem
for omega-complete non-orders, again using attractivity to prove that
Kleene’s fixed points are least quasi-fixed points.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Complete_Non_Orders-AFP,
author = {Akihisa Yamada and Jérémy Dubut},
title = {Complete Non-Orders and Fixed Points},
journal = {Archive of Formal Proofs},
month = jun,
year = 2019,
note = {\url{https://isa-afp.org/entries/Complete_Non_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>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Complete_Non_Orders/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Complete_Non_Orders/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Complete_Non_Orders/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Complete_Non_Orders-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Complete_Non_Orders-2020-04-18.tar.gz">
+ afp-Complete_Non_Orders-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Complete_Non_Orders-2019-06-28.tar.gz">
afp-Complete_Non_Orders-2019-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/Completeness.html b/web/entries/Completeness.html
--- a/web/entries/Completeness.html
+++ b/web/entries/Completeness.html
@@ -1,296 +1,301 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ompleteness
theorem
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Completeness-2020-04-18.tar.gz">
+ afp-Completeness-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Completeness-2019-06-11.tar.gz">
afp-Completeness-2019-06-11.tar.gz
</a>
</li>
<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/Complex_Geometry.html b/web/entries/Complex_Geometry.html
--- a/web/entries/Complex_Geometry.html
+++ b/web/entries/Complex_Geometry.html
@@ -1,195 +1,200 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Complex 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>omplex
<font class="first">G</font>eometry
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Complex Geometry</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Filip Marić (filip /at/ matf /dot/ bg /dot/ ac /dot/ rs) and
<a href="http://poincare.matf.bg.ac.rs/~danijela">Danijela Simić</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-12-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
A formalization of geometry of complex numbers is presented.
Fundamental objects that are investigated are the complex plane
extended by a single infinite point, its objects (points, lines and
circles), and groups of transformations that act on them (e.g.,
inversions and Möbius transformations). Most objects are defined
algebraically, but correspondence with classical geometric definitions
is shown.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Complex_Geometry-AFP,
author = {Filip Marić and Danijela Simić},
title = {Complex Geometry},
journal = {Archive of Formal Proofs},
month = dec,
year = 2019,
note = {\url{https://isa-afp.org/entries/Complex_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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Poincare_Disc.html">Poincare_Disc</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Complex_Geometry/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Complex_Geometry/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Complex_Geometry/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Complex_Geometry-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Complex_Geometry-2020-04-18.tar.gz">
+ afp-Complex_Geometry-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Complex_Geometry-2020-01-17.tar.gz">
afp-Complex_Geometry-2020-01-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/Complx.html b/web/entries/Complx.html
--- a/web/entries/Complx.html
+++ b/web/entries/Complx.html
@@ -1,245 +1,250 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Complx-2020-04-18.tar.gz">
+ afp-Complx-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Complx-2019-06-11.tar.gz">
afp-Complx-2019-06-11.tar.gz
</a>
</li>
<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,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-ComponentDependencies-2020-04-18.tar.gz">
+ afp-ComponentDependencies-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-ComponentDependencies-2019-06-11.tar.gz">
afp-ComponentDependencies-2019-06-11.tar.gz
</a>
</li>
<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,238 +1,243 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-ConcurrentGC-2020-04-18.tar.gz">
+ afp-ConcurrentGC-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-ConcurrentGC-2019-06-11.tar.gz">
afp-ConcurrentGC-2019-06-11.tar.gz
</a>
</li>
<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,219 +1,224 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>oncurrent
<font class="first">I</font>MP
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-ConcurrentIMP-2020-04-18.tar.gz">
+ afp-ConcurrentIMP-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-ConcurrentIMP-2019-06-11.tar.gz">
afp-ConcurrentIMP-2019-06-11.tar.gz
</a>
</li>
<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,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Concurrent_Ref_Alg-2020-04-18.tar.gz">
+ afp-Concurrent_Ref_Alg-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Concurrent_Ref_Alg-2019-06-11.tar.gz">
afp-Concurrent_Ref_Alg-2019-06-11.tar.gz
</a>
</li>
<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,203 +1,208 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalization
of
<font class="first">C</font>oncurrent
<font class="first">R</font>evisions
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Concurrent_Revisions-2020-04-18.tar.gz">
+ afp-Concurrent_Revisions-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Concurrent_Revisions-2019-06-11.tar.gz">
afp-Concurrent_Revisions-2019-06-11.tar.gz
</a>
</li>
<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,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>onsensus
<font class="first">R</font>efined
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Consensus_Refined-2020-04-18.tar.gz">
+ afp-Consensus_Refined-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Consensus_Refined-2019-06-11.tar.gz">
afp-Consensus_Refined-2019-06-11.tar.gz
</a>
</li>
<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,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>onstructive
<font class="first">C</font>ryptography
in
<font class="first">H</font>OL
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Constructive_Cryptography-2020-04-18.tar.gz">
+ afp-Constructive_Cryptography-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Constructive_Cryptography-2019-06-11.tar.gz">
afp-Constructive_Cryptography-2019-06-11.tar.gz
</a>
</li>
<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,208 +1,213 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>onstructor
<font class="first">F</font>unctions
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="CakeML_Codegen.html">CakeML_Codegen</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Constructor_Funs-2020-04-18.tar.gz">
+ afp-Constructor_Funs-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Constructor_Funs-2019-06-11.tar.gz">
afp-Constructor_Funs-2019-06-11.tar.gz
</a>
</li>
<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,258 +1,263 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ight-weight
<font class="first">C</font>ontainers
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="AI_Planning_Languages_Semantics.html">AI_Planning_Languages_Semantics</a>, <a href="MFOTL_Monitor.html">MFOTL_Monitor</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Containers-2020-04-18.tar.gz">
+ afp-Containers-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Containers-2019-06-11.tar.gz">
afp-Containers-2019-06-11.tar.gz
</a>
</li>
<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,278 +1,283 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>oreC++
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CoreC++-2020-04-18.tar.gz">
+ afp-CoreC++-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CoreC++-2019-06-11.tar.gz">
afp-CoreC++-2019-06-11.tar.gz
</a>
</li>
<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,219 +1,224 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Shadow_DOM.html">Shadow_DOM</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Core_DOM-2020-04-18.tar.gz">
+ afp-Core_DOM-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Core_DOM-2019-06-11.tar.gz">
afp-Core_DOM-2019-06-11.tar.gz
</a>
</li>
<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/Core_SC_DOM.html b/web/entries/Core_SC_DOM.html
--- a/web/entries/Core_SC_DOM.html
+++ b/web/entries/Core_SC_DOM.html
@@ -1,200 +1,206 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>The Safely Composable DOM - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">S</font>afely
<font class="first">C</font>omposable
<font class="first">D</font>OM
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">The Safely Composable DOM</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">2020-09-28</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In this AFP entry, we formalize the core of the Safely Composable
Document Object Model (SC DOM). The SC DOM improve the standard DOM
(as formalized in the AFP entry "Core DOM") by strengthening
the tree boundaries set by shadow roots: in the SC DOM, the shadow
root is a sub-class of the document class (instead of a base class).
This modifications also results in changes to some API methods (e.g.,
getOwnerDocument) to return the nearest shadow root rather than the
document root. As a result, many API methods that, when called on a
node inside a shadow tree, would previously ``break out''
and return or modify nodes that are possibly outside the shadow tree,
now stay within its boundaries. This change in behavior makes programs
that operate on shadow trees more predictable for the developer and
allows them to make more assumptions about other code accessing the
DOM.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Core_SC_DOM-AFP,
author = {Achim D. Brucker and Michael Herzberg},
title = {The Safely Composable DOM},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/Core_SC_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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Shadow_SC_DOM.html">Shadow_SC_DOM</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Core_SC_DOM/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Core_SC_DOM/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Core_SC_DOM/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Core_SC_DOM-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Core_SC_DOM-2020-11-26.tar.gz">
+ afp-Core_SC_DOM-2020-11-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/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,214 +1,219 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Count_Complex_Roots-2020-04-18.tar.gz">
+ afp-Count_Complex_Roots-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Count_Complex_Roots-2019-06-11.tar.gz">
afp-Count_Complex_Roots-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ryptHOL
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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>, <a href="Sigma_Commit_Crypto.html">Sigma_Commit_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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CryptHOL-2020-04-18.tar.gz">
+ afp-CryptHOL-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CryptHOL-2019-06-11.tar.gz">
afp-CryptHOL-2019-06-11.tar.gz
</a>
</li>
<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,231 +1,236 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-CryptoBasedCompositionalProperties-2020-04-18.tar.gz">
+ afp-CryptoBasedCompositionalProperties-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-CryptoBasedCompositionalProperties-2019-06-11.tar.gz">
afp-CryptoBasedCompositionalProperties-2019-06-11.tar.gz
</a>
</li>
<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,241 +1,246 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Peter Lammich 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 mathjax_process">
<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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-DFS_Framework-2020-04-18.tar.gz">
+ afp-DFS_Framework-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-DFS_Framework-2020-01-14.tar.gz">
afp-DFS_Framework-2020-01-14.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-DFS_Framework-2019-06-11.tar.gz">
afp-DFS_Framework-2019-06-11.tar.gz
</a>
</li>
<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,274 +1,279 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-DPT-SAT-Solver-2020-04-18.tar.gz">
+ afp-DPT-SAT-Solver-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-DPT-SAT-Solver-2019-06-11.tar.gz">
afp-DPT-SAT-Solver-2019-06-11.tar.gz
</a>
</li>
<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,278 +1,283 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-DataRefinementIBP-2020-04-18.tar.gz">
+ afp-DataRefinementIBP-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-DataRefinementIBP-2019-06-11.tar.gz">
afp-DataRefinementIBP-2019-06-11.tar.gz
</a>
</li>
<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,263 +1,268 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>enerating
linear
orders
for
datatypes
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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="WOOT_Strong_Eventual_Consistency.html">WOOT_Strong_Eventual_Consistency</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Datatype_Order_Generator-2020-04-18.tar.gz">
+ afp-Datatype_Order_Generator-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Datatype_Order_Generator-2019-06-11.tar.gz">
afp-Datatype_Order_Generator-2019-06-11.tar.gz
</a>
</li>
<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,225 +1,230 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Decl_Sem_Fun_PL-2020-04-18.tar.gz">
+ afp-Decl_Sem_Fun_PL-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Decl_Sem_Fun_PL-2019-06-11.tar.gz">
afp-Decl_Sem_Fun_PL-2019-06-11.tar.gz
</a>
</li>
<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,214 +1,219 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>ecreasing
<font class="first">D</font>iagrams
<font class="first">I</font>I
</h1>
<p>&nbsp;</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 (int-e /at/ gmx /dot/ de)
</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Decreasing-Diagrams-II-2020-04-18.tar.gz">
+ afp-Decreasing-Diagrams-II-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Decreasing-Diagrams-II-2019-06-11.tar.gz">
afp-Decreasing-Diagrams-II-2019-06-11.tar.gz
</a>
</li>
<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,232 +1,237 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>ecreasing
<font class="first">D</font>iagrams
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Decreasing-Diagrams-2020-04-18.tar.gz">
+ afp-Decreasing-Diagrams-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Decreasing-Diagrams-2019-06-11.tar.gz">
afp-Decreasing-Diagrams-2019-06-11.tar.gz
</a>
</li>
<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,214 +1,219 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">E</font>xpressiveness
of
<font class="first">D</font>eep
<font class="first">L</font>earning
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Deep_Learning-2020-04-18.tar.gz">
+ afp-Deep_Learning-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Deep_Learning-2019-06-11.tar.gz">
afp-Deep_Learning-2019-06-11.tar.gz
</a>
</li>
<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/Delta_System_Lemma.html b/web/entries/Delta_System_Lemma.html
--- a/web/entries/Delta_System_Lemma.html
+++ b/web/entries/Delta_System_Lemma.html
@@ -1,192 +1,198 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Cofinality and the Delta System 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ofinality
and
the
<font class="first">D</font>elta
<font class="first">S</font>ystem
<font class="first">L</font>emma
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Cofinality and the Delta System Lemma</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
<a href="https://cs.famaf.unc.edu.ar/~pedro/home_en.html">Pedro Sánchez Terraf</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-12-27</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We formalize the basic results on cofinality of linearly ordered sets
and ordinals and Šanin’s Lemma for uncountable families of finite
sets. This last result is used to prove the countable chain condition
for Cohen posets. We work in the set theory framework of Isabelle/ZF,
using the Axiom of Choice as needed.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Delta_System_Lemma-AFP,
author = {Pedro Sánchez Terraf},
title = {Cofinality and the Delta System Lemma},
journal = {Archive of Formal Proofs},
month = dec,
year = 2020,
note = {\url{https://isa-afp.org/entries/Delta_System_Lemma.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Delta_System_Lemma/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Delta_System_Lemma/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Delta_System_Lemma/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Delta_System_Lemma-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Delta_System_Lemma-2020-12-28.tar.gz">
+ afp-Delta_System_Lemma-2020-12-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/Density_Compiler.html b/web/entries/Density_Compiler.html
--- a/web/entries/Density_Compiler.html
+++ b/web/entries/Density_Compiler.html
@@ -1,248 +1,253 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Density_Compiler-2020-04-18.tar.gz">
+ afp-Density_Compiler-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Density_Compiler-2019-06-11.tar.gz">
afp-Density_Compiler-2019-06-11.tar.gz
</a>
</li>
<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,235 +1,240 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Dependent_SIFUM_Refinement-2020-04-18.tar.gz">
+ afp-Dependent_SIFUM_Refinement-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Dependent_SIFUM_Refinement-2019-06-11.tar.gz">
afp-Dependent_SIFUM_Refinement-2019-06-11.tar.gz
</a>
</li>
<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,242 +1,247 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Dependent_SIFUM_Type_Systems-2020-04-18.tar.gz">
+ afp-Dependent_SIFUM_Type_Systems-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Dependent_SIFUM_Type_Systems-2019-06-11.tar.gz">
afp-Dependent_SIFUM_Type_Systems-2019-06-11.tar.gz
</a>
</li>
<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,283 +1,288 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>epth
<font class="first">F</font>irst
<font class="first">S</font>earch
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Depth-First-Search-2020-04-18.tar.gz">
+ afp-Depth-First-Search-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Depth-First-Search-2019-06-11.tar.gz">
afp-Depth-First-Search-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>erangements
<font class="first">F</font>ormula
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Derangements-2020-04-18.tar.gz">
+ afp-Derangements-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Derangements-2019-06-11.tar.gz">
afp-Derangements-2019-06-11.tar.gz
</a>
</li>
<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,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>eriving
class
instances
for
datatypes
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Affine_Arithmetic.html">Affine_Arithmetic</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="LTL_Master_Theorem.html">LTL_Master_Theorem</a>, <a href="MSO_Regex_Equivalence.html">MSO_Regex_Equivalence</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Deriving-2020-04-18.tar.gz">
+ afp-Deriving-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Deriving-2019-06-11.tar.gz">
afp-Deriving-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>escartes'
<font class="first">R</font>ule
of
<font class="first">S</font>igns
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Descartes_Sign_Rule-2020-04-18.tar.gz">
+ afp-Descartes_Sign_Rule-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Descartes_Sign_Rule-2019-06-11.tar.gz">
afp-Descartes_Sign_Rule-2019-06-11.tar.gz
</a>
</li>
<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,206 +1,211 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>ictionary
<font class="first">C</font>onstruction
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="CakeML_Codegen.html">CakeML_Codegen</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Dict_Construction-2020-04-18.tar.gz">
+ afp-Dict_Construction-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Dict_Construction-2019-06-11.tar.gz">
afp-Dict_Construction-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>ifferential
<font class="first">D</font>ynamic
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Differential_Dynamic_Logic-2020-04-18.tar.gz">
+ afp-Differential_Dynamic_Logic-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Differential_Dynamic_Logic-2019-06-11.tar.gz">
afp-Differential_Dynamic_Logic-2019-06-11.tar.gz
</a>
</li>
<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/Differential_Game_Logic.html b/web/entries/Differential_Game_Logic.html
--- a/web/entries/Differential_Game_Logic.html
+++ b/web/entries/Differential_Game_Logic.html
@@ -1,200 +1,205 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Differential Game 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>ifferential
<font class="first">G</font>ame
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Differential Game Logic</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
<a href="http://www.cs.cmu.edu/~aplatzer/">André Platzer</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-06-03</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This formalization provides differential game logic (dGL), a logic for
proving properties of hybrid game. In addition to the syntax and
semantics, it formalizes a uniform substitution calculus for dGL.
Church's uniform substitutions substitute a term or formula for a
function or predicate symbol everywhere. The uniform substitutions for
dGL also substitute hybrid games for a game symbol everywhere. We
prove soundness of one-pass uniform substitutions and the axioms of
differential game logic with respect to their denotational semantics.
One-pass uniform substitutions are faster by postponing
soundness-critical admissibility checks with a linear pass homomorphic
application and regain soundness by a variable condition at the
replacements. The formalization is based on prior non-mechanized
soundness proofs for dGL.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Differential_Game_Logic-AFP,
author = {André Platzer},
title = {Differential Game Logic},
journal = {Archive of Formal Proofs},
month = jun,
year = 2019,
note = {\url{https://isa-afp.org/entries/Differential_Game_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/Differential_Game_Logic/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Differential_Game_Logic/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Differential_Game_Logic/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Differential_Game_Logic-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Differential_Game_Logic-2020-04-18.tar.gz">
+ afp-Differential_Game_Logic-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Differential_Game_Logic-2019-06-24.tar.gz">
afp-Differential_Game_Logic-2019-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/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,263 +1,268 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
Peter Lammich
</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Dijkstra_Shortest_Path-2020-04-18.tar.gz">
+ afp-Dijkstra_Shortest_Path-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Dijkstra_Shortest_Path-2019-06-11.tar.gz">
afp-Dijkstra_Shortest_Path-2019-06-11.tar.gz
</a>
</li>
<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,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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),
<a href="http://www.parsert.com/">Julian Parsert</a>,
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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Diophantine_Eqns_Lin_Hom-2020-04-18.tar.gz">
+ afp-Diophantine_Eqns_Lin_Hom-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Diophantine_Eqns_Lin_Hom-2019-06-11.tar.gz">
afp-Diophantine_Eqns_Lin_Hom-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<p>This article provides a formalisation of Dirichlet characters
and Dirichlet <em>L</em>-functions including proofs of
their basic properties &ndash; most notably their analyticity,
their areas of convergence, and their non-vanishing for &Re;(s)
&ge; 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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Gauss_Sums.html">Gauss_Sums</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Dirichlet_L-2020-04-18.tar.gz">
+ afp-Dirichlet_L-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Dirichlet_L-2019-06-11.tar.gz">
afp-Dirichlet_L-2019-06-11.tar.gz
</a>
</li>
<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,217 +1,222 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>irichlet
<font class="first">S</font>eries
</h1>
<p>&nbsp;</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 mathjax_process">
This entry is a formalisation of much of Chapters 2, 3, and 11 of
Apostol's &ldquo;Introduction to Analytic Number
Theory&rdquo;. This includes: <ul> <li>Definitions and
basic properties for several number-theoretic functions (Euler's
&phi;, M&ouml;bius &mu;, Liouville's &lambda;,
the divisor function &sigma;, von Mangoldt's
&Lambda;)</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{https://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="Gauss_Sums.html">Gauss_Sums</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Dirichlet_Series-2020-04-18.tar.gz">
+ afp-Dirichlet_Series-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Dirichlet_Series-2019-06-11.tar.gz">
afp-Dirichlet_Series-2019-06-11.tar.gz
</a>
</li>
<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,217 +1,222 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>ricing
in
discrete
financial
models
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-DiscretePricing-2020-04-18.tar.gz">
+ afp-DiscretePricing-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-DiscretePricing-2019-06-11.tar.gz">
afp-DiscretePricing-2019-06-11.tar.gz
</a>
</li>
<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,230 +1,235 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>iscrete
<font class="first">S</font>ummation
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Discrete_Summation-2020-04-18.tar.gz">
+ afp-Discrete_Summation-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Discrete_Summation-2019-06-11.tar.gz">
afp-Discrete_Summation-2019-06-11.tar.gz
</a>
</li>
<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,289 +1,294 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-DiskPaxos-2020-04-18.tar.gz">
+ afp-DiskPaxos-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-DiskPaxos-2019-06-11.tar.gz">
afp-DiskPaxos-2019-06-11.tar.gz
</a>
</li>
<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,230 +1,235 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>ynamic
<font class="first">A</font>rchitectures
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-DynamicArchitectures-2020-04-18.tar.gz">
+ afp-DynamicArchitectures-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-DynamicArchitectures-2019-06-11.tar.gz">
afp-DynamicArchitectures-2019-06-11.tar.gz
</a>
</li>
<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,225 +1,230 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>arameterized
<font class="first">D</font>ynamic
<font class="first">T</font>ables
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Dynamic_Tables-2020-04-18.tar.gz">
+ afp-Dynamic_Tables-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Dynamic_Tables-2019-06-11.tar.gz">
afp-Dynamic_Tables-2019-06-11.tar.gz
</a>
</li>
<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,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">T</font>ranscendence
of
e
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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>, <a href="Zeta_3_Irrational.html">Zeta_3_Irrational</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-E_Transcendental-2020-04-18.tar.gz">
+ afp-E_Transcendental-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-E_Transcendental-2019-06-11.tar.gz">
afp-E_Transcendental-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">E</font>chelon
<font class="first">F</font>orm
</h1>
<p>&nbsp;</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="https://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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Echelon_Form-2020-04-18.tar.gz">
+ afp-Echelon_Form-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Echelon_Form-2019-06-11.tar.gz">
afp-Echelon_Form-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalizing
the
<font class="first">E</font>dmonds-Karp
<font class="first">A</font>lgorithm
</h1>
<p>&nbsp;</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">
Peter Lammich 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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-EdmondsKarp_Maxflow-2020-04-18.tar.gz">
+ afp-EdmondsKarp_Maxflow-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-EdmondsKarp_Maxflow-2019-06-11.tar.gz">
afp-EdmondsKarp_Maxflow-2019-06-11.tar.gz
</a>
</li>
<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,264 +1,269 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">E</font>fficient
<font class="first">M</font>ergesort
</h1>
<p>&nbsp;</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 mathjax_process">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.
[2020-11-20]:
Additional theory Natural_Mergesort that developes an efficient mergesort
algorithm without key-functions for educational purposes.</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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Efficient-Mergesort-2020-04-18.tar.gz">
+ afp-Efficient-Mergesort-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Efficient-Mergesort-2019-06-11.tar.gz">
afp-Efficient-Mergesort-2019-06-11.tar.gz
</a>
</li>
<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,214 +1,219 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Elliptic_Curves_Group_Law-2020-04-18.tar.gz">
+ afp-Elliptic_Curves_Group_Law-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Elliptic_Curves_Group_Law-2019-06-11.tar.gz">
afp-Elliptic_Curves_Group_Law-2019-06-11.tar.gz
</a>
</li>
<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,239 +1,244 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Encodability_Process_Calculi-2020-04-18.tar.gz">
+ afp-Encodability_Process_Calculi-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Encodability_Process_Calculi-2019-06-11.tar.gz">
afp-Encodability_Process_Calculi-2019-06-11.tar.gz
</a>
</li>
<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,195 +1,200 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">E</font>pistemic
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</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="https://people.compute.dtu.dk/ahfrom/">Asta 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 mathjax_process">
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 = {Asta Halkjær From},
title = {Epistemic Logic},
journal = {Archive of Formal Proofs},
month = oct,
year = 2018,
note = {\url{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Epistemic_Logic-2020-04-18.tar.gz">
+ afp-Epistemic_Logic-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Epistemic_Logic-2019-06-11.tar.gz">
afp-Epistemic_Logic-2019-06-11.tar.gz
</a>
</li>
<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,215 +1,220 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">E</font>rgodic
<font class="first">T</font>heory
</h1>
<p>&nbsp;</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">
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">2015-12-01</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">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{https://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="Laws_of_Large_Numbers.html">Laws_of_Large_Numbers</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Ergodic_Theory-2020-04-18.tar.gz">
+ afp-Ergodic_Theory-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Ergodic_Theory-2019-06-11.tar.gz">
afp-Ergodic_Theory-2019-06-11.tar.gz
</a>
</li>
<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,203 +1,208 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">E</font>rror
<font class="first">F</font>unction
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Error_Function-2020-04-18.tar.gz">
+ afp-Error_Function-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Error_Function-2019-06-11.tar.gz">
afp-Error_Function-2019-06-11.tar.gz
</a>
</li>
<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,219 +1,224 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">E</font>uler–MacLaurin
<font class="first">F</font>ormula
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Euler_MacLaurin-2020-04-18.tar.gz">
+ afp-Euler_MacLaurin-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Euler_MacLaurin-2019-06-11.tar.gz">
afp-Euler_MacLaurin-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">E</font>uler's
<font class="first">P</font>artition
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Euler_Partition-2020-04-18.tar.gz">
+ afp-Euler_Partition-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Euler_Partition-2019-06-11.tar.gz">
afp-Euler_Partition-2019-06-11.tar.gz
</a>
</li>
<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/Extended_Finite_State_Machine_Inference.html b/web/entries/Extended_Finite_State_Machine_Inference.html
--- a/web/entries/Extended_Finite_State_Machine_Inference.html
+++ b/web/entries/Extended_Finite_State_Machine_Inference.html
@@ -1,208 +1,214 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Inference of Extended Finite State 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>nference
of
<font class="first">E</font>xtended
<font class="first">F</font>inite
<font class="first">S</font>tate
<font class="first">M</font>achines
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Inference of Extended Finite State Machines</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Michael Foster (jmafoster1 /at/ sheffield /dot/ ac /dot/ uk),
<a href="https://www.brucker.ch">Achim D. Brucker</a>,
Ramsay G. Taylor (r /dot/ g /dot/ taylor /at/ sheffield /dot/ ac /dot/ uk) and
John Derrick (j /dot/ derrick /at/ sheffield /dot/ ac /dot/ uk)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-09-07</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In this AFP entry, we provide a formal implementation of a
state-merging technique to infer extended finite state machines
(EFSMs), complete with output and update functions, from black-box
traces. In particular, we define the subsumption in context relation
as a means of determining whether one transition is able to account
for the behaviour of another. Building on this, we define the direct
subsumption relation, which lifts the subsumption in context relation
to EFSM level such that we can use it to determine whether it is safe
to merge a given pair of transitions. Key proofs include the
conditions necessary for subsumption to occur and that subsumption
and direct subsumption are preorder relations. We also provide a
number of different heuristics which can be used to abstract away
concrete values into registers so that more states and transitions can
be merged and provide proofs of the various conditions which must hold
for these abstractions to subsume their ungeneralised counterparts. A
Code Generator setup to create executable Scala code is also defined.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Extended_Finite_State_Machine_Inference-AFP,
author = {Michael Foster and Achim D. Brucker and Ramsay G. Taylor and John Derrick},
title = {Inference of Extended Finite State Machines},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/Extended_Finite_State_Machine_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>
<tr><td class="datahead">Depends on:</td>
<td class="data"><a href="Extended_Finite_State_Machines.html">Extended_Finite_State_Machines</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Extended_Finite_State_Machine_Inference/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Extended_Finite_State_Machine_Inference/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Extended_Finite_State_Machine_Inference/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Extended_Finite_State_Machine_Inference-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Extended_Finite_State_Machine_Inference-2020-09-19.tar.gz">
+ afp-Extended_Finite_State_Machine_Inference-2020-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/Extended_Finite_State_Machines.html b/web/entries/Extended_Finite_State_Machines.html
--- a/web/entries/Extended_Finite_State_Machines.html
+++ b/web/entries/Extended_Finite_State_Machines.html
@@ -1,206 +1,212 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Formal Model of Extended Finite State 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">F</font>ormal
<font class="first">M</font>odel
of
<font class="first">E</font>xtended
<font class="first">F</font>inite
<font class="first">S</font>tate
<font class="first">M</font>achines
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Formal Model of Extended Finite State Machines</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Michael Foster (jmafoster1 /at/ sheffield /dot/ ac /dot/ uk),
<a href="https://www.brucker.ch">Achim D. Brucker</a>,
Ramsay G. Taylor (r /dot/ g /dot/ taylor /at/ sheffield /dot/ ac /dot/ uk) and
John Derrick (j /dot/ derrick /at/ sheffield /dot/ ac /dot/ uk)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-09-07</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In this AFP entry, we provide a formalisation of extended finite state
machines (EFSMs) where models are represented as finite sets of
transitions between states. EFSMs execute traces to produce observable
outputs. We also define various simulation and equality metrics for
EFSMs in terms of traces and prove their strengths in relation to each
other. Another key contribution is a framework of function definitions
such that LTL properties can be phrased over EFSMs. Finally, we
provide a simple example case study in the form of a drinks machine.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Extended_Finite_State_Machines-AFP,
author = {Michael Foster and Achim D. Brucker and Ramsay G. Taylor and John Derrick},
title = {A Formal Model of Extended Finite State Machines},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/Extended_Finite_State_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="FinFun.html">FinFun</a> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Extended_Finite_State_Machine_Inference.html">Extended_Finite_State_Machine_Inference</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Extended_Finite_State_Machines/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Extended_Finite_State_Machines/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Extended_Finite_State_Machines/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Extended_Finite_State_Machines-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Extended_Finite_State_Machines-2020-09-19.tar.gz">
+ afp-Extended_Finite_State_Machines-2020-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/FFT.html b/web/entries/FFT.html
--- a/web/entries/FFT.html
+++ b/web/entries/FFT.html
@@ -1,277 +1,282 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ast
<font class="first">F</font>ourier
<font class="first">T</font>ransform
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FFT-2020-04-18.tar.gz">
+ afp-FFT-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FFT-2019-06-11.tar.gz">
afp-FFT-2019-06-11.tar.gz
</a>
</li>
<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,233 +1,238 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FLP-2020-04-18.tar.gz">
+ afp-FLP-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FLP-2019-06-11.tar.gz">
afp-FLP-2019-06-11.tar.gz
</a>
</li>
<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,295 +1,300 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://people.compute.dtu.dk/ahfrom/">Asta 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 mathjax_process">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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="FOL_Seq_Calc1.html">FOL_Seq_Calc1</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FOL-Fitting-2020-04-18.tar.gz">
+ afp-FOL-Fitting-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FOL-Fitting-2019-06-11.tar.gz">
afp-FOL-Fitting-2019-06-11.tar.gz
</a>
</li>
<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,226 +1,231 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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>,
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a> 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 mathjax_process">
<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 Asta 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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FOL_Harrison-2020-04-18.tar.gz">
+ afp-FOL_Harrison-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FOL_Harrison-2019-06-11.tar.gz">
afp-FOL_Harrison-2019-06-11.tar.gz
</a>
</li>
<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/FOL_Seq_Calc1.html b/web/entries/FOL_Seq_Calc1.html
--- a/web/entries/FOL_Seq_Calc1.html
+++ b/web/entries/FOL_Seq_Calc1.html
@@ -1,211 +1,216 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Sequent 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">S</font>equent
<font class="first">C</font>alculus
for
<font class="first">F</font>irst-Order
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Sequent Calculus for First-Order Logic</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
<a href="https://people.compute.dtu.dk/ahfrom/">Asta Halkjær From</a>
</td>
</tr>
<tr>
<td class="datahead">
Contributors:
</td>
<td class="data">
<a href="https://people.compute.dtu.dk/aleje/">Alexander Birch Jensen</a>,
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a> 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">2019-07-18</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This work formalizes soundness and completeness of a one-sided sequent
calculus for first-order logic. The completeness is shown via a
translation from a complete semantic tableau calculus, the proof of
which is based on the First-Order Logic According to Fitting theory.
The calculi and proof techniques are taken from Ben-Ari's
Mathematical Logic for Computer Science.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{FOL_Seq_Calc1-AFP,
author = {Asta Halkjær From},
title = {A Sequent Calculus for First-Order Logic},
journal = {Archive of Formal Proofs},
month = jul,
year = 2019,
note = {\url{https://isa-afp.org/entries/FOL_Seq_Calc1.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="FOL-Fitting.html">FOL-Fitting</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/FOL_Seq_Calc1/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/FOL_Seq_Calc1/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/FOL_Seq_Calc1/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-FOL_Seq_Calc1-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FOL_Seq_Calc1-2020-04-18.tar.gz">
+ afp-FOL_Seq_Calc1-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FOL_Seq_Calc1-2019-07-18.tar.gz">
afp-FOL_Seq_Calc1-2019-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/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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Factored_Transition_System_Bounding-2020-04-18.tar.gz">
+ afp-Factored_Transition_System_Bounding-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Factored_Transition_System_Bounding-2019-06-11.tar.gz">
afp-Factored_Transition_System_Bounding-2019-06-11.tar.gz
</a>
</li>
<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,216 +1,221 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Falling_Factorial_Sum-2020-04-18.tar.gz">
+ afp-Falling_Factorial_Sum-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Falling_Factorial_Sum-2019-06-11.tar.gz">
afp-Falling_Factorial_Sum-2019-06-11.tar.gz
</a>
</li>
<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,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Linear_Programming.html">Linear_Programming</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Farkas-2020-04-18.tar.gz">
+ afp-Farkas-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Farkas-2019-06-11.tar.gz">
afp-Farkas-2019-06-11.tar.gz
</a>
</li>
<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,291 +1,296 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FeatherweightJava-2020-04-18.tar.gz">
+ afp-FeatherweightJava-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FeatherweightJava-2019-06-11.tar.gz">
afp-FeatherweightJava-2019-06-11.tar.gz
</a>
</li>
<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,273 +1,278 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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>,
<a href="https://www.lri.fr/~ftuong/">Frédéric Tuong</a> and
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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 mathjax_process">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://foss.heptapod.net/isa-afp/afp-devel/-/commit/e68e1996d5d4926397c9244e786446e99ab17e63">afp-devel@ea3b38fc54d6</a> and
<a href="https://projects.brucker.ch/hol-testgen/log/trunk?rev=12148">hol-testgen@12148</a><br>
&nbsp;&nbsp;&nbsp;Update of Featherweight OCL including a change in the abstract.<br>
[2014-01-16]:
<a href="https://foss.heptapod.net/isa-afp/afp-devel/-/commit/6217cc5b29c560f24ecc64c81047778becb69f51">afp-devel@9091ce05cb20</a> and
<a href="https://projects.brucker.ch/hol-testgen/log/trunk?rev=10241">hol-testgen@10241</a><br>
&nbsp;&nbsp;&nbsp;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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Featherweight_OCL-2020-04-18.tar.gz">
+ afp-Featherweight_OCL-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Featherweight_OCL-2019-06-11.tar.gz">
afp-Featherweight_OCL-2019-06-11.tar.gz
</a>
</li>
<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,294 +1,299 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Fermat3_4-2020-04-18.tar.gz">
+ afp-Fermat3_4-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Fermat3_4-2019-06-11.tar.gz">
afp-Fermat3_4-2019-06-11.tar.gz
</a>
</li>
<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,281 +1,286 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ile
<font class="first">R</font>efinement
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FileRefinement-2020-04-18.tar.gz">
+ afp-FileRefinement-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FileRefinement-2019-06-11.tar.gz">
afp-FileRefinement-2019-06-11.tar.gz
</a>
</li>
<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,287 +1,292 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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="Extended_Finite_State_Machines.html">Extended_Finite_State_Machines</a>, <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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FinFun-2020-04-18.tar.gz">
+ afp-FinFun-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FinFun-2019-06-11.tar.gz">
afp-FinFun-2019-06-11.tar.gz
</a>
</li>
<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,269 +1,274 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>inger
<font class="first">T</font>rees
</h1>
<p>&nbsp;</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
Peter Lammich
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Finger-Trees-2020-04-18.tar.gz">
+ afp-Finger-Trees-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Finger-Trees-2019-06-11.tar.gz">
afp-Finger-Trees-2019-06-11.tar.gz
</a>
</li>
<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-Map-Extras.html b/web/entries/Finite-Map-Extras.html
--- a/web/entries/Finite-Map-Extras.html
+++ b/web/entries/Finite-Map-Extras.html
@@ -1,184 +1,190 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Finite Map Extras - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>inite
<font class="first">M</font>ap
<font class="first">E</font>xtras
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Finite Map Extras</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Javier Díaz (javier /dot/ diaz /dot/ manzi /at/ gmail /dot/ com)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-10-12</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This entry includes useful syntactic sugar, new operators and functions, and
their associated lemmas for finite maps which currently are not
present in the standard Finite_Map theory.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Finite-Map-Extras-AFP,
author = {Javier Díaz},
title = {Finite Map Extras},
journal = {Archive of Formal Proofs},
month = oct,
year = 2020,
note = {\url{https://isa-afp.org/entries/Finite-Map-Extras.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Finite-Map-Extras/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Finite-Map-Extras/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Finite-Map-Extras/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Finite-Map-Extras-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Finite-Map-Extras-2020-12-02.tar.gz">
+ afp-Finite-Map-Extras-2020-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/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,231 +1,236 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Finite_Automata_HF-2020-04-18.tar.gz">
+ afp-Finite_Automata_HF-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Finite_Automata_HF-2019-06-11.tar.gz">
afp-Finite_Automata_HF-2019-06-11.tar.gz
</a>
</li>
<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,214 +1,219 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>irst-Order
<font class="first">T</font>erms
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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="Knuth_Bendix_Order.html">Knuth_Bendix_Order</a>, <a href="Resolution_FOL.html">Resolution_FOL</a>, <a href="Saturation_Framework_Extensions.html">Saturation_Framework_Extensions</a>, <a href="Stateful_Protocol_Composition_and_Typing.html">Stateful_Protocol_Composition_and_Typing</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-First_Order_Terms-2020-04-18.tar.gz">
+ afp-First_Order_Terms-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-First_Order_Terms-2019-06-11.tar.gz">
afp-First_Order_Terms-2019-06-11.tar.gz
</a>
</li>
<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,233 +1,238 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
<a href="http://www.parsert.com/">Julian Parsert</a> and
<a href="http://cl-informatik.uibk.ac.at/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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-First_Welfare_Theorem-2020-04-18.tar.gz">
+ afp-First_Welfare_Theorem-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-First_Welfare_Theorem-2019-06-11.tar.gz">
afp-First_Welfare_Theorem-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Fishburn_Impossibility-2020-04-18.tar.gz">
+ afp-Fishburn_Impossibility-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Fishburn_Impossibility-2019-06-11.tar.gz">
afp-Fishburn_Impossibility-2019-06-11.tar.gz
</a>
</li>
<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,205 +1,210 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>isher–Yates
shuffle
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Fisher_Yates-2020-04-18.tar.gz">
+ afp-Fisher_Yates-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Fisher_Yates-2019-06-11.tar.gz">
afp-Fisher_Yates-2019-06-11.tar.gz
</a>
</li>
<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,222 +1,227 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Peter Lammich 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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Flow_Networks-2020-04-18.tar.gz">
+ afp-Flow_Networks-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Flow_Networks-2020-01-14.tar.gz">
afp-Flow_Networks-2020-01-14.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Flow_Networks-2019-06-11.tar.gz">
afp-Flow_Networks-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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://home.in.tum.de/~wimmers/">Simon Wimmer</a> and
Peter Lammich
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Floyd_Warshall-2020-04-18.tar.gz">
+ afp-Floyd_Warshall-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Floyd_Warshall-2019-06-11.tar.gz">
afp-Floyd_Warshall-2019-06-11.tar.gz
</a>
</li>
<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,299 +1,304 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">
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.html">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Flyspeck-Tame-2020-04-18.tar.gz">
+ afp-Flyspeck-Tame-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Flyspeck-Tame-2019-06-11.tar.gz">
afp-Flyspeck-Tame-2019-06-11.tar.gz
</a>
</li>
<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,245 +1,250 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FocusStreamsCaseStudies-2020-04-18.tar.gz">
+ afp-FocusStreamsCaseStudies-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FocusStreamsCaseStudies-2019-06-11.tar.gz">
afp-FocusStreamsCaseStudies-2019-06-11.tar.gz
</a>
</li>
<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/Forcing.html b/web/entries/Forcing.html
--- a/web/entries/Forcing.html
+++ b/web/entries/Forcing.html
@@ -1,191 +1,202 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Formalization of Forcing in Isabelle/ZF - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalization
of
<font class="first">F</font>orcing
in
<font class="first">I</font>sabelle/ZF
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Formalization of Forcing in Isabelle/ZF</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Emmanuel Gunther (gunther /at/ famaf /dot/ unc /dot/ edu /dot/ ar),
<a href="https://cs.famaf.unc.edu.ar/~mpagano/">Miguel Pagano</a> and
<a href="https://cs.famaf.unc.edu.ar/~pedro/home_en.html">Pedro Sánchez Terraf</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-05-06</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We formalize the theory of forcing in the set theory framework of
Isabelle/ZF. Under the assumption of the existence of a countable
transitive model of ZFC, we construct a proper generic extension and
show that the latter also satisfies ZFC.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Forcing-AFP,
author = {Emmanuel Gunther and Miguel Pagano and Pedro Sánchez Terraf},
title = {Formalization of Forcing in Isabelle/ZF},
journal = {Archive of Formal Proofs},
month = may,
year = 2020,
note = {\url{https://isa-afp.org/entries/Forcing.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Forcing/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Forcing/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Forcing/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Forcing-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Forcing-2020-05-07.tar.gz">
+ afp-Forcing-2020-05-07.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Forcing-2020-05-06.tar.gz">
+ afp-Forcing-2020-05-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/Formal_Puiseux_Series.html b/web/entries/Formal_Puiseux_Series.html
new file mode 100644
--- /dev/null
+++ b/web/entries/Formal_Puiseux_Series.html
@@ -0,0 +1,192 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Formal Puiseux 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">
+<!-- MathJax for LaTeX support in abstracts -->
+<script>
+MathJax = {
+ tex: {
+ inlineMath: [['$', '$'], ['\\(', '\\)']]
+ },
+ processEscapes: true,
+ svg: {
+ fontCache: 'global'
+ }
+};
+</script>
+<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
+</head>
+
+<body class="mathjax_ignore">
+
+<table width="100%">
+<tbody>
+<tr>
+
+<!-- Navigation -->
+<td width="20%" align="center" valign="top">
+ <p>&nbsp;</p>
+ <a href="https://www.isa-afp.org/">
+ <img src="../images/isabelle.png" width="100" height="88" border=0>
+ </a>
+ <p>&nbsp;</p>
+ <p>&nbsp;</p>
+ <table class="nav" width="80%">
+ <tr>
+ <td class="nav" width="100%"><a href="../index.html">Home</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../about.html">About</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../submitting.html">Submission</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../updating.html">Updating Entries</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../using.html">Using Entries</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../search.html">Search</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../statistics.html">Statistics</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../topics.html">Index</a></td>
+ </tr>
+ <tr>
+ <td class="nav"><a href="../download.html">Download</a></td>
+ </tr>
+ </table>
+ <p>&nbsp;</p>
+ <p>&nbsp;</p>
+</td>
+
+
+<!-- Content -->
+<td width="80%" valign="top">
+<div align="center">
+ <p>&nbsp;</p>
+ <h1> <font class="first">F</font>ormal
+
+ <font class="first">P</font>uiseux
+
+ <font class="first">S</font>eries
+
+</h1>
+ <p>&nbsp;</p>
+
+<table width="80%" class="data">
+<tbody>
+<tr>
+ <td class="datahead" width="20%">Title:</td>
+ <td class="data" width="80%">Formal Puiseux 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">2021-02-17</td>
+</tr>
+
+<tr>
+ <td class="datahead" valign="top">Abstract:</td>
+ <td class="abstract mathjax_process">
+<p>Formal Puiseux series are generalisations of formal power
+series and formal Laurent series that also allow for fractional
+exponents. They have the following general form: \[\sum_{i=N}^\infty
+a_{i/d} X^{i/d}\] where <em>N</em> is an integer and
+<em>d</em> is a positive integer.</p> <p>This
+entry defines these series including their basic algebraic properties.
+Furthermore, it proves the Newton–Puiseux Theorem, namely that the
+Puiseux series over an algebraically closed field of characteristic 0
+are also algebraically closed.</p></td>
+</tr>
+
+
+<tr>
+ <td class="datahead" valign="top">BibTeX:</td>
+ <td class="formatted">
+ <pre>@article{Formal_Puiseux_Series-AFP,
+ author = {Manuel Eberl},
+ title = {Formal Puiseux Series},
+ journal = {Archive of Formal Proofs},
+ month = feb,
+ year = 2021,
+ note = {\url{https://isa-afp.org/entries/Formal_Puiseux_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="Polynomial_Interpolation.html">Polynomial_Interpolation</a> </td></tr>
+
+
+
+
+ </tbody>
+</table>
+
+<p></p>
+
+<table class="links">
+ <tbody>
+ <tr>
+ <td class="links">
+ <a href="../browser_info/current/AFP/Formal_Puiseux_Series/outline.pdf">Proof outline</a><br>
+ <a href="../browser_info/current/AFP/Formal_Puiseux_Series/document.pdf">Proof document</a>
+ </td>
+ </tr>
+ <tr>
+ <td class="links">
+ <a href="../browser_info/current/AFP/Formal_Puiseux_Series/index.html">Browse theories</a>
+ </td></tr>
+ <tr>
+ <td class="links">
+ <a href="../release/afp-Formal_Puiseux_Series-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/Formal_SSA.html b/web/entries/Formal_SSA.html
--- a/web/entries/Formal_SSA.html
+++ b/web/entries/Formal_SSA.html
@@ -1,250 +1,255 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Formal_SSA-2020-04-18.tar.gz">
+ afp-Formal_SSA-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Formal_SSA-2019-06-11.tar.gz">
afp-Formal_SSA-2019-06-11.tar.gz
</a>
</li>
<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,231 +1,236 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>erivatives
of
<font class="first">L</font>ogical
<font class="first">F</font>ormulas
</h1>
<p>&nbsp;</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="https://traytel.bitbucket.io">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 mathjax_process">
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{https://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> </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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Formula_Derivatives-2020-04-18.tar.gz">
+ afp-Formula_Derivatives-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Formula_Derivatives-2019-06-11.tar.gz">
afp-Formula_Derivatives-2019-06-11.tar.gz
</a>
</li>
<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/Fourier.html b/web/entries/Fourier.html
--- a/web/entries/Fourier.html
+++ b/web/entries/Fourier.html
@@ -1,192 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Fourier 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ourier
<font class="first">S</font>eries
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Fourier Series</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">2019-09-06</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This development formalises the square integrable functions over the
reals and the basics of Fourier series. It culminates with a proof
that every well-behaved periodic function can be approximated by a
Fourier series. The material is ported from HOL Light:
https://github.com/jrh13/hol-light/blob/master/100/fourier.ml</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Fourier-AFP,
author = {Lawrence C Paulson},
title = {Fourier Series},
journal = {Archive of Formal Proofs},
month = sep,
year = 2019,
note = {\url{https://isa-afp.org/entries/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="Lp.html">Lp</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Fourier/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Fourier/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Fourier/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Fourier-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Fourier-2020-04-18.tar.gz">
+ afp-Fourier-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Fourier-2019-09-11.tar.gz">
afp-Fourier-2019-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/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,262 +1,267 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ree
<font class="first">B</font>oolean
<font class="first">A</font>lgebra
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Free-Boolean-Algebra-2020-04-18.tar.gz">
+ afp-Free-Boolean-Algebra-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Free-Boolean-Algebra-2019-06-11.tar.gz">
afp-Free-Boolean-Algebra-2019-06-11.tar.gz
</a>
</li>
<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,262 +1,267 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ree
<font class="first">G</font>roups
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Free-Groups-2020-04-18.tar.gz">
+ afp-Free-Groups-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Free-Groups-2019-06-11.tar.gz">
afp-Free-Groups-2019-06-11.tar.gz
</a>
</li>
<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,262 +1,267 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>un
<font class="first">W</font>ith
<font class="first">F</font>unctions
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FunWithFunctions-2020-04-18.tar.gz">
+ afp-FunWithFunctions-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FunWithFunctions-2019-06-11.tar.gz">
afp-FunWithFunctions-2019-06-11.tar.gz
</a>
</li>
<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,263 +1,268 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>un
<font class="first">W</font>ith
<font class="first">T</font>ilings
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-FunWithTilings-2020-04-18.tar.gz">
+ afp-FunWithTilings-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-FunWithTilings-2019-06-11.tar.gz">
afp-FunWithTilings-2019-06-11.tar.gz
</a>
</li>
<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,297 +1,302 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>unctional
<font class="first">A</font>utomata
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Functional-Automata-2020-04-18.tar.gz">
+ afp-Functional-Automata-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Functional-Automata-2019-06-11.tar.gz">
afp-Functional-Automata-2019-06-11.tar.gz
</a>
</li>
<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,217 +1,222 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>,
Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl) and
<a href="https://traytel.bitbucket.io">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 mathjax_process">
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{https://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="Knuth_Bendix_Order.html">Knuth_Bendix_Order</a>, <a href="Lambda_Free_RPOs.html">Lambda_Free_RPOs</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Functional_Ordered_Resolution_Prover-2020-04-18.tar.gz">
+ afp-Functional_Ordered_Resolution_Prover-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Functional_Ordered_Resolution_Prover-2019-06-11.tar.gz">
afp-Functional_Ordered_Resolution_Prover-2019-06-11.tar.gz
</a>
</li>
<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/Furstenberg_Topology.html b/web/entries/Furstenberg_Topology.html
--- a/web/entries/Furstenberg_Topology.html
+++ b/web/entries/Furstenberg_Topology.html
@@ -1,210 +1,215 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Furstenberg's topology and his proof of the infinitude 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>urstenberg's
topology
and
his
proof
of
the
infinitude
of
primes
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Furstenberg's topology and his proof of the infinitude 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">2020-03-22</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>This article gives a formal version of Furstenberg's
topological proof of the infinitude of primes. He defines a topology
on the integers based on arithmetic progressions (or, equivalently,
residue classes). Using some fairly obvious properties of this
topology, the infinitude of primes is then easily obtained.</p>
<p>Apart from this, this topology is also fairly ‘nice’ in
general: it is second countable, metrizable, and perfect. All of these
(well-known) facts are formally proven, including an explicit metric
for the topology given by Zulfeqarr.</p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Furstenberg_Topology-AFP,
author = {Manuel Eberl},
title = {Furstenberg's topology and his proof of the infinitude of primes},
journal = {Archive of Formal Proofs},
month = mar,
year = 2020,
note = {\url{https://isa-afp.org/entries/Furstenberg_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>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Furstenberg_Topology/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Furstenberg_Topology/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Furstenberg_Topology/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Furstenberg_Topology-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Furstenberg_Topology-2020-04-18.tar.gz">
+ afp-Furstenberg_Topology-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Furstenberg_Topology-2020-03-27.tar.gz">
afp-Furstenberg_Topology-2020-03-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/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,240 +1,245 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>yntax
and
semantics
of
a
<font class="first">G</font>PU
kernel
programming
language
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-GPU_Kernel_PL-2020-04-18.tar.gz">
+ afp-GPU_Kernel_PL-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-GPU_Kernel_PL-2019-06-11.tar.gz">
afp-GPU_Kernel_PL-2019-06-11.tar.gz
</a>
</li>
<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,246 +1,251 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Peter Lammich
</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 mathjax_process">
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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Gabow_SCC-2020-04-18.tar.gz">
+ afp-Gabow_SCC-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Gabow_SCC-2019-06-11.tar.gz">
afp-Gabow_SCC-2019-06-11.tar.gz
</a>
</li>
<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,232 +1,237 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>ame-based
cryptography
in
<font class="first">H</font>OL
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Game_Based_Crypto-2020-04-18.tar.gz">
+ afp-Game_Based_Crypto-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Game_Based_Crypto-2019-06-11.tar.gz">
afp-Game_Based_Crypto-2019-06-11.tar.gz
</a>
</li>
<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,262 +1,267 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Gauss-Jordan-Elim-Fun-2020-04-18.tar.gz">
+ afp-Gauss-Jordan-Elim-Fun-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Gauss-Jordan-Elim-Fun-2020-01-14.tar.gz">
afp-Gauss-Jordan-Elim-Fun-2020-01-14.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Gauss-Jordan-Elim-Fun-2019-06-11.tar.gz">
afp-Gauss-Jordan-Elim-Fun-2019-06-11.tar.gz
</a>
</li>
<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,226 +1,231 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://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 mathjax_process">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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Gauss_Jordan-2020-04-18.tar.gz">
+ afp-Gauss_Jordan-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Gauss_Jordan-2019-06-11.tar.gz">
afp-Gauss_Jordan-2019-06-11.tar.gz
</a>
</li>
<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/Gauss_Sums.html b/web/entries/Gauss_Sums.html
--- a/web/entries/Gauss_Sums.html
+++ b/web/entries/Gauss_Sums.html
@@ -1,206 +1,211 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Gauss Sums and the Pólya–Vinogradov 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>auss
<font class="first">S</font>ums
and
the
<font class="first">P</font>ólya–Vinogradov
<font class="first">I</font>nequality
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Gauss Sums and the Pólya–Vinogradov Inequality</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://people.epfl.ch/rodrigo.raya">Rodrigo Raya</a> 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-12-10</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>This article provides a full formalisation of Chapter 8 of
Apostol's <em><a
href="https://www.springer.com/de/book/9780387901633">Introduction
to Analytic Number Theory</a></em>. Subjects that are
covered are:</p> <ul> <li>periodic arithmetic
functions and their finite Fourier series</li>
<li>(generalised) Ramanujan sums</li> <li>Gauss sums
and separable characters</li> <li>induced moduli and
primitive characters</li> <li>the
Pólya&mdash;Vinogradov inequality</li> </ul></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Gauss_Sums-AFP,
author = {Rodrigo Raya and Manuel Eberl},
title = {Gauss Sums and the Pólya–Vinogradov Inequality},
journal = {Archive of Formal Proofs},
month = dec,
year = 2019,
note = {\url{https://isa-afp.org/entries/Gauss_Sums.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Dirichlet_L.html">Dirichlet_L</a>, <a href="Dirichlet_Series.html">Dirichlet_Series</a>, <a href="Polynomial_Interpolation.html">Polynomial_Interpolation</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Gauss_Sums/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Gauss_Sums/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Gauss_Sums/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Gauss_Sums-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Gauss_Sums-2020-04-18.tar.gz">
+ afp-Gauss_Sums-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Gauss_Sums-2020-01-10.tar.gz">
afp-Gauss_Sums-2020-01-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/Gaussian_Integers.html b/web/entries/Gaussian_Integers.html
--- a/web/entries/Gaussian_Integers.html
+++ b/web/entries/Gaussian_Integers.html
@@ -1,195 +1,201 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Gaussian Integers - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>aussian
<font class="first">I</font>ntegers
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Gaussian Integers</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">2020-04-24</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>The Gaussian integers are the subring &#8484;[i] of the
complex numbers, i. e. the ring of all complex numbers with integral
real and imaginary part. This article provides a definition of this
ring as well as proofs of various basic properties, such as that they
form a Euclidean ring and a full classification of their primes. An
executable (albeit not very efficient) factorisation algorithm is also
provided.</p> <p>Lastly, this Gaussian integer
formalisation is used in two short applications:</p> <ol>
<li> The characterisation of all positive integers that can be
written as sums of two squares</li> <li> Euclid's
formula for primitive Pythagorean triples</li> </ol>
<p>While elementary proofs for both of these are already
available in the AFP, the theory of Gaussian integers provides more
concise proofs and a more high-level view.</p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Gaussian_Integers-AFP,
author = {Manuel Eberl},
title = {Gaussian Integers},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/Gaussian_Integers.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Gaussian_Integers/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Gaussian_Integers/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Gaussian_Integers/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Gaussian_Integers-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Gaussian_Integers-2020-04-30.tar.gz">
+ afp-Gaussian_Integers-2020-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/GenClock.html b/web/entries/GenClock.html
--- a/web/entries/GenClock.html
+++ b/web/entries/GenClock.html
@@ -1,292 +1,297 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-GenClock-2020-04-18.tar.gz">
+ afp-GenClock-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-GenClock-2019-06-11.tar.gz">
afp-GenClock-2019-06-11.tar.gz
</a>
</li>
<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,251 +1,256 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-General-Triangle-2020-04-18.tar.gz">
+ afp-General-Triangle-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-General-Triangle-2019-06-11.tar.gz">
afp-General-Triangle-2019-06-11.tar.gz
</a>
</li>
<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/Generalized_Counting_Sort.html b/web/entries/Generalized_Counting_Sort.html
--- a/web/entries/Generalized_Counting_Sort.html
+++ b/web/entries/Generalized_Counting_Sort.html
@@ -1,222 +1,227 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>An Efficient Generalization of Counting Sort for Large, possibly Infinite Key Ranges - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>n
<font class="first">E</font>fficient
<font class="first">G</font>eneralization
of
<font class="first">C</font>ounting
<font class="first">S</font>ort
for
<font class="first">L</font>arge,
possibly
<font class="first">I</font>nfinite
<font class="first">K</font>ey
<font class="first">R</font>anges
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">An Efficient Generalization of Counting Sort for Large, possibly Infinite Key Ranges</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">2019-12-04</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Counting sort is a well-known algorithm that sorts objects of any kind
mapped to integer keys, or else to keys in one-to-one correspondence
with some subset of the integers (e.g. alphabet letters). However, it
is suitable for direct use, viz. not just as a subroutine of another
sorting algorithm (e.g. radix sort), only if the key range is not
significantly larger than the number of the objects to be sorted.
This paper describes a tail-recursive generalization of counting sort
making use of a bounded number of counters, suitable for direct use in
case of a large, or even infinite key range of any kind, subject to
the only constraint of being a subset of an arbitrary linear order.
After performing a pen-and-paper analysis of how such algorithm has to
be designed to maximize its efficiency, this paper formalizes the
resulting generalized counting sort (GCsort) algorithm and then
formally proves its correctness properties, namely that (a) the
counters' number is maximized never exceeding the fixed upper
bound, (b) objects are conserved, (c) objects get sorted, and (d) the
algorithm is stable.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Generalized_Counting_Sort-AFP,
author = {Pasquale Noce},
title = {An Efficient Generalization of Counting Sort for Large, possibly Infinite Key Ranges},
journal = {Archive of Formal Proofs},
month = dec,
year = 2019,
note = {\url{https://isa-afp.org/entries/Generalized_Counting_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/Generalized_Counting_Sort/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Generalized_Counting_Sort/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Generalized_Counting_Sort/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Generalized_Counting_Sort-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Generalized_Counting_Sort-2020-04-18.tar.gz">
+ afp-Generalized_Counting_Sort-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Generalized_Counting_Sort-2019-12-09.tar.gz">
afp-Generalized_Counting_Sort-2019-12-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/Generic_Deriving.html b/web/entries/Generic_Deriving.html
--- a/web/entries/Generic_Deriving.html
+++ b/web/entries/Generic_Deriving.html
@@ -1,208 +1,213 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">D</font>eriving
generic
class
instances
for
datatypes
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Generic_Deriving-2020-04-18.tar.gz">
+ afp-Generic_Deriving-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Generic_Deriving-2019-06-11.tar.gz">
afp-Generic_Deriving-2019-06-11.tar.gz
</a>
</li>
<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/Generic_Join.html b/web/entries/Generic_Join.html
--- a/web/entries/Generic_Join.html
+++ b/web/entries/Generic_Join.html
@@ -1,202 +1,207 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Formalization of Multiway-Join 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalization
of
<font class="first">M</font>ultiway-Join
<font class="first">A</font>lgorithms
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Formalization of Multiway-Join Algorithms</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Thibault Dardinier
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-09-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Worst-case optimal multiway-join algorithms are recent seminal
achievement of the database community. These algorithms compute the
natural join of multiple relational databases and improve in the worst
case over traditional query plan optimizations of nested binary joins.
In 2014, <a
href="https://doi.org/10.1145/2590989.2590991">Ngo, Ré,
and Rudra</a> gave a unified presentation of different multi-way
join algorithms. We formalized and proved correct their "Generic
Join" algorithm and extended it to support negative joins.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Generic_Join-AFP,
author = {Thibault Dardinier},
title = {Formalization of Multiway-Join Algorithms},
journal = {Archive of Formal Proofs},
month = sep,
year = 2019,
note = {\url{https://isa-afp.org/entries/Generic_Join.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="MFOTL_Monitor.html">MFOTL_Monitor</a> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="MFODL_Monitor_Optimized.html">MFODL_Monitor_Optimized</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Generic_Join/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Generic_Join/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Generic_Join/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Generic_Join-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Generic_Join-2020-04-18.tar.gz">
+ afp-Generic_Join-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Generic_Join-2019-09-18.tar.gz">
afp-Generic_Join-2019-09-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/GewirthPGCProof.html b/web/entries/GewirthPGCProof.html
--- a/web/entries/GewirthPGCProof.html
+++ b/web/entries/GewirthPGCProof.html
@@ -1,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-GewirthPGCProof-2020-04-18.tar.gz">
+ afp-GewirthPGCProof-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-GewirthPGCProof-2019-06-11.tar.gz">
afp-GewirthPGCProof-2019-06-11.tar.gz
</a>
</li>
<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,254 +1,259 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Girth_Chromatic-2020-04-18.tar.gz">
+ afp-Girth_Chromatic-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Girth_Chromatic-2019-06-11.tar.gz">
afp-Girth_Chromatic-2019-06-11.tar.gz
</a>
</li>
<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,238 +1,243 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-GoedelGod-2020-04-18.tar.gz">
+ afp-GoedelGod-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-GoedelGod-2019-06-11.tar.gz">
afp-GoedelGod-2019-06-11.tar.gz
</a>
</li>
<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/Goedel_HFSet_Semantic.html b/web/entries/Goedel_HFSet_Semantic.html
--- a/web/entries/Goedel_HFSet_Semantic.html
+++ b/web/entries/Goedel_HFSet_Semantic.html
@@ -1,205 +1,211 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>rom
<font class="first">A</font>bstract
to
<font class="first">C</font>oncrete
<font class="first">G</font>&ouml;del's
<font class="first">I</font>ncompleteness
<font class="first">T</font>heorems&mdash;Part
<font class="first">I</font>
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part I</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://www.andreipopescu.uk">Andrei Popescu</a> and
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-09-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We validate an abstract formulation of G&ouml;del's First and
Second Incompleteness Theorems from a <a
href="https://www.isa-afp.org/entries/Goedel_Incompleteness.html">separate
AFP entry</a> by instantiating them to the case of
<i>finite sound extensions of the Hereditarily Finite (HF) Set
theory</i>, i.e., FOL theories extending the HF Set theory with
a finite set of axioms that are sound in the standard model. The
concrete results had been previously formalised in an <a
href="https://www.isa-afp.org/entries/Incompleteness.html">AFP
entry by Larry Paulson</a>; our instantiation reuses the
infrastructure developed in that entry.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Goedel_HFSet_Semantic-AFP,
author = {Andrei Popescu and Dmitriy Traytel},
title = {From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part I},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/Goedel_HFSet_Semantic.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Goedel_Incompleteness.html">Goedel_Incompleteness</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/Goedel_HFSet_Semantic/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Goedel_HFSet_Semantic/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Goedel_HFSet_Semantic/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Goedel_HFSet_Semantic-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Goedel_HFSet_Semantic-2020-09-18.tar.gz">
+ afp-Goedel_HFSet_Semantic-2020-09-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/Goedel_HFSet_Semanticless.html b/web/entries/Goedel_HFSet_Semanticless.html
--- a/web/entries/Goedel_HFSet_Semanticless.html
+++ b/web/entries/Goedel_HFSet_Semanticless.html
@@ -1,211 +1,217 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>rom
<font class="first">A</font>bstract
to
<font class="first">C</font>oncrete
<font class="first">G</font>&ouml;del's
<font class="first">I</font>ncompleteness
<font class="first">T</font>heorems&mdash;Part
<font class="first">I</font>I
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part II</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://www.andreipopescu.uk">Andrei Popescu</a> and
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-09-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We validate an abstract formulation of G&ouml;del's Second
Incompleteness Theorem from a <a
href="https://www.isa-afp.org/entries/Goedel_Incompleteness.html">separate
AFP entry</a> by instantiating it to the case of <i>finite
consistent extensions of the Hereditarily Finite (HF) Set
theory</i>, i.e., consistent FOL theories extending the HF Set
theory with a finite set of axioms. The instantiation draws heavily
on infrastructure previously developed by Larry Paulson in his <a
href="https://www.isa-afp.org/entries/Incompleteness.html">direct
formalisation of the concrete result</a>. It strengthens
Paulson's formalization of G&ouml;del's Second from that
entry by <i>not</i> assuming soundness, and in fact not
relying on any notion of model or semantic interpretation. The
strengthening was obtained by first replacing some of Paulson’s
semantic arguments with proofs within his HF calculus, and then
plugging in some of Paulson's (modified) lemmas to instantiate
our soundness-free G&ouml;del's Second locale.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Goedel_HFSet_Semanticless-AFP,
author = {Andrei Popescu and Dmitriy Traytel},
title = {From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part II},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/Goedel_HFSet_Semanticless.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Goedel_Incompleteness.html">Goedel_Incompleteness</a>, <a href="HereditarilyFinite.html">HereditarilyFinite</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/Goedel_HFSet_Semanticless/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Goedel_HFSet_Semanticless/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Goedel_HFSet_Semanticless/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Goedel_HFSet_Semanticless-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Goedel_HFSet_Semanticless-2020-09-18.tar.gz">
+ afp-Goedel_HFSet_Semanticless-2020-09-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/Goedel_Incompleteness.html b/web/entries/Goedel_Incompleteness.html
--- a/web/entries/Goedel_Incompleteness.html
+++ b/web/entries/Goedel_Incompleteness.html
@@ -1,211 +1,222 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>An Abstract Formalization of G&ouml;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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>n
<font class="first">A</font>bstract
<font class="first">F</font>ormalization
of
<font class="first">G</font>&ouml;del's
<font class="first">I</font>ncompleteness
<font class="first">T</font>heorems
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">An Abstract Formalization of G&ouml;del's Incompleteness Theorems</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://www.andreipopescu.uk">Andrei Popescu</a> and
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-09-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We present an abstract formalization of G&ouml;del's
incompleteness theorems. We analyze sufficient conditions for the
theorems' applicability to a partially specified logic. Our
abstract perspective enables a comparison between alternative
approaches from the literature. These include Rosser's variation
of the first theorem, Jeroslow's variation of the second theorem,
and the Swierczkowski&ndash;Paulson semantics-based approach. This
AFP entry is the main entry point to the results described in our
CADE-27 paper <a
href="https://dx.doi.org/10.1007/978-3-030-29436-6_26">A
Formally Verified Abstract Account of Gödel's Incompleteness
Theorems</a>. As part of our abstract formalization's
validation, we instantiate our locales twice in the separate AFP
entries <a
href="https://www.isa-afp.org/entries/Goedel_HFSet_Semantic.html">Goedel_HFSet_Semantic</a>
and <a
href="https://www.isa-afp.org/entries/Goedel_HFSet_Semanticless.html">Goedel_HFSet_Semanticless</a>.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Goedel_Incompleteness-AFP,
author = {Andrei Popescu and Dmitriy Traytel},
title = {An Abstract Formalization of G&ouml;del's Incompleteness Theorems},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/Goedel_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="Syntax_Independent_Logic.html">Syntax_Independent_Logic</a> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Goedel_HFSet_Semantic.html">Goedel_HFSet_Semantic</a>, <a href="Goedel_HFSet_Semanticless.html">Goedel_HFSet_Semanticless</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Goedel_Incompleteness/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Goedel_Incompleteness/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Goedel_Incompleteness/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Goedel_Incompleteness-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Goedel_Incompleteness-2020-09-19.tar.gz">
+ afp-Goedel_Incompleteness-2020-09-19.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Goedel_Incompleteness-2020-09-18.tar.gz">
+ afp-Goedel_Incompleteness-2020-09-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/Goodstein_Lambda.html b/web/entries/Goodstein_Lambda.html
--- a/web/entries/Goodstein_Lambda.html
+++ b/web/entries/Goodstein_Lambda.html
@@ -1,200 +1,205 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Implementing the Goodstein Function in &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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>mplementing
the
<font class="first">G</font>oodstein
<font class="first">F</font>unction
in
<font class="first">&</font>lambda;-Calculus
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Implementing the Goodstein Function in &lambda;-Calculus</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Bertram Felgenhauer (int-e /at/ gmx /dot/ de)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-02-21</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In this formalization, we develop an implementation of the Goodstein
function G in plain &lambda;-calculus, linked to a concise, self-contained
specification. The implementation works on a Church-encoded
representation of countable ordinals. The initial conversion to
hereditary base 2 is not covered, but the material is sufficient to
compute the particular value G(16), and easily extends to other fixed
arguments.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Goodstein_Lambda-AFP,
author = {Bertram Felgenhauer},
title = {Implementing the Goodstein Function in &lambda;-Calculus},
journal = {Archive of Formal Proofs},
month = feb,
year = 2020,
note = {\url{https://isa-afp.org/entries/Goodstein_Lambda.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Goodstein_Lambda/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Goodstein_Lambda/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Goodstein_Lambda/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Goodstein_Lambda-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Goodstein_Lambda-2020-04-18.tar.gz">
+ afp-Goodstein_Lambda-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Goodstein_Lambda-2020-02-24.tar.gz">
afp-Goodstein_Lambda-2020-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/GraphMarkingIBP.html b/web/entries/GraphMarkingIBP.html
--- a/web/entries/GraphMarkingIBP.html
+++ b/web/entries/GraphMarkingIBP.html
@@ -1,283 +1,288 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-GraphMarkingIBP-2020-04-18.tar.gz">
+ afp-GraphMarkingIBP-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-GraphMarkingIBP-2019-06-11.tar.gz">
afp-GraphMarkingIBP-2019-06-11.tar.gz
</a>
</li>
<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,198 +1,203 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>raph
<font class="first">S</font>aturation
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Graph_Saturation-2020-04-18.tar.gz">
+ afp-Graph_Saturation-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Graph_Saturation-2019-06-11.tar.gz">
afp-Graph_Saturation-2019-06-11.tar.gz
</a>
</li>
<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,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>raph
<font class="first">T</font>heory
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Graph_Theory-2020-04-18.tar.gz">
+ afp-Graph_Theory-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Graph_Theory-2019-06-11.tar.gz">
afp-Graph_Theory-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Green-2020-04-18.tar.gz">
+ afp-Green-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Green-2019-06-11.tar.gz">
afp-Green-2019-06-11.tar.gz
</a>
</li>
<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,226 +1,231 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>röbner
<font class="first">B</font>ases
<font class="first">T</font>heory
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Groebner_Bases-2020-04-18.tar.gz">
+ afp-Groebner_Bases-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Groebner_Bases-2019-06-11.tar.gz">
afp-Groebner_Bases-2019-06-11.tar.gz
</a>
</li>
<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
--- a/web/entries/Groebner_Macaulay.html
+++ b/web/entries/Groebner_Macaulay.html
@@ -1,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Groebner_Macaulay-2020-04-18.tar.gz">
+ afp-Groebner_Macaulay-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Groebner_Macaulay-2019-06-17.tar.gz">
afp-Groebner_Macaulay-2019-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/Gromov_Hyperbolicity.html b/web/entries/Gromov_Hyperbolicity.html
--- a/web/entries/Gromov_Hyperbolicity.html
+++ b/web/entries/Gromov_Hyperbolicity.html
@@ -1,210 +1,215 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>romov
<font class="first">H</font>yperbolicity
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Gromov_Hyperbolicity-2020-04-18.tar.gz">
+ afp-Gromov_Hyperbolicity-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Gromov_Hyperbolicity-2019-06-11.tar.gz">
afp-Gromov_Hyperbolicity-2019-06-11.tar.gz
</a>
</li>
<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,303 +1,308 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>roups,
<font class="first">R</font>ings
and
<font class="first">M</font>odules
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Group-Ring-Module-2020-04-18.tar.gz">
+ afp-Group-Ring-Module-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Group-Ring-Module-2019-06-11.tar.gz">
afp-Group-Ring-Module-2019-06-11.tar.gz
</a>
</li>
<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,209 +1,214 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">H</font>OL-CSP
<font class="first">V</font>ersion
<font class="first">2</font>.0
</h1>
<p>&nbsp;</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
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="CSP_RefTK.html">CSP_RefTK</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-HOL-CSP-2020-04-18.tar.gz">
+ afp-HOL-CSP-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-HOL-CSP-2019-06-11.tar.gz">
afp-HOL-CSP-2019-06-11.tar.gz
</a>
</li>
<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,210 +1,215 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">H</font>OLCF-Prelude
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="BirdKMP.html">BirdKMP</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-HOLCF-Prelude-2020-04-18.tar.gz">
+ afp-HOLCF-Prelude-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-HOLCF-Prelude-2019-06-11.tar.gz">
afp-HOLCF-Prelude-2019-06-11.tar.gz
</a>
</li>
<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,278 +1,283 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-HRB-Slicing-2020-04-18.tar.gz">
+ afp-HRB-Slicing-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-HRB-Slicing-2019-06-11.tar.gz">
afp-HRB-Slicing-2019-06-11.tar.gz
</a>
</li>
<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,282 +1,287 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Heard_Of-2020-04-18.tar.gz">
+ afp-Heard_Of-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Heard_Of-2019-06-11.tar.gz">
afp-Heard_Of-2019-06-11.tar.gz
</a>
</li>
<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/Hello_World.html b/web/entries/Hello_World.html
--- a/web/entries/Hello_World.html
+++ b/web/entries/Hello_World.html
@@ -1,192 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Hello World - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">H</font>ello
<font class="first">W</font>orld
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Hello World</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">2020-03-07</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In this article, we present a formalization of the well-known
"Hello, World!" code, including a formal framework for
reasoning about IO. Our model is inspired by the handling of IO in
Haskell. We start by formalizing the 🌍 and embrace the IO monad
afterwards. Then we present a sample main :: IO (), followed by its
proof of correctness.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Hello_World-AFP,
author = {Cornelius Diekmann and Lars Hupel},
title = {Hello World},
journal = {Archive of Formal Proofs},
month = mar,
year = 2020,
note = {\url{https://isa-afp.org/entries/Hello_World.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Hello_World/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Hello_World/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Hello_World/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Hello_World-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Hello_World-2020-04-18.tar.gz">
+ afp-Hello_World-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Hello_World-2020-03-23.tar.gz">
afp-Hello_World-2020-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/HereditarilyFinite.html b/web/entries/HereditarilyFinite.html
--- a/web/entries/HereditarilyFinite.html
+++ b/web/entries/HereditarilyFinite.html
@@ -1,243 +1,248 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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="Category3.html">Category3</a>, <a href="Finite_Automata_HF.html">Finite_Automata_HF</a>, <a href="Goedel_HFSet_Semanticless.html">Goedel_HFSet_Semanticless</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-HereditarilyFinite-2020-04-18.tar.gz">
+ afp-HereditarilyFinite-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-HereditarilyFinite-2019-06-11.tar.gz">
afp-HereditarilyFinite-2019-06-11.tar.gz
</a>
</li>
<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,217 +1,222 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">H</font>ermite
<font class="first">N</font>ormal
<font class="first">F</font>orm
</h1>
<p>&nbsp;</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="https://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 mathjax_process">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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Smith_Normal_Form.html">Smith_Normal_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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Hermite-2020-04-18.tar.gz">
+ afp-Hermite-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Hermite-2019-06-11.tar.gz">
afp-Hermite-2019-06-11.tar.gz
</a>
</li>
<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,209 +1,214 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">H</font>idden
<font class="first">M</font>arkov
<font class="first">M</font>odels
</h1>
<p>&nbsp;</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://home.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Hidden_Markov_Models-2020-04-18.tar.gz">
+ afp-Hidden_Markov_Models-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Hidden_Markov_Models-2019-06-11.tar.gz">
afp-Hidden_Markov_Models-2019-06-11.tar.gz
</a>
</li>
<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,221 +1,226 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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.</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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="CakeML_Codegen.html">CakeML_Codegen</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Higher_Order_Terms-2020-04-18.tar.gz">
+ afp-Higher_Order_Terms-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Higher_Order_Terms-2019-06-11.tar.gz">
afp-Higher_Order_Terms-2019-06-11.tar.gz
</a>
</li>
<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,215 +1,220 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Hoare_Time-2020-04-18.tar.gz">
+ afp-Hoare_Time-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Hoare_Time-2019-06-11.tar.gz">
afp-Hoare_Time-2019-06-11.tar.gz
</a>
</li>
<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,274 +1,279 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-HotelKeyCards-2020-04-18.tar.gz">
+ afp-HotelKeyCards-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-HotelKeyCards-2019-06-11.tar.gz">
afp-HotelKeyCards-2019-06-11.tar.gz
</a>
</li>
<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,285 +1,290 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="CakeML_Codegen.html">CakeML_Codegen</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Huffman-2020-04-18.tar.gz">
+ afp-Huffman-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Huffman-2019-06-11.tar.gz">
afp-Huffman-2019-06-11.tar.gz
</a>
</li>
<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_Logic.html b/web/entries/Hybrid_Logic.html
--- a/web/entries/Hybrid_Logic.html
+++ b/web/entries/Hybrid_Logic.html
@@ -1,218 +1,223 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Formalizing a Seligman-Style Tableau System for Hybrid 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalizing
a
<font class="first">S</font>eligman-Style
<font class="first">T</font>ableau
<font class="first">S</font>ystem
for
<font class="first">H</font>ybrid
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Formalizing a Seligman-Style Tableau System for Hybrid Logic</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
<a href="https://people.compute.dtu.dk/ahfrom/">Asta Halkjær From</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-12-20</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This work is a formalization of soundness and completeness proofs
for a Seligman-style tableau system for hybrid logic. The completeness
result is obtained via a synthetic approach using maximally
consistent sets of tableau blocks. The formalization differs from
previous work in a few ways. First, to avoid the need to backtrack in
the construction of a tableau, the formalized system has no unnamed
initial segment, and therefore no Name rule. Second, I show that the
full Bridge rule is admissible in the system. Third, I start from rules
restricted to only extend the branch with new formulas, including only
witnessing diamonds that are not already witnessed, and show that
the unrestricted rules are admissible. Similarly, I start from simpler
versions of the @-rules and show that these are sufficient.
The GoTo rule is restricted using a notion of potential such that each
application consumes potential and potential is earned through applications of
the remaining rules. I show that if a branch can be closed then it can
be closed starting from a single unit. Finally, Nom is restricted by
a fixed set of allowed nominals. The resulting system should be terminating.</td>
</tr>
<tr>
<td class="datahead" valign="top">Change history:</td>
<td class="abstract">[2020-06-03]: The fully restricted system has been shown complete by updating the synthetic completeness proof.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Hybrid_Logic-AFP,
author = {Asta Halkjær From},
title = {Formalizing a Seligman-Style Tableau System for Hybrid Logic},
journal = {Archive of Formal Proofs},
month = dec,
year = 2019,
note = {\url{https://isa-afp.org/entries/Hybrid_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_Logic/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Hybrid_Logic/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Hybrid_Logic/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Hybrid_Logic-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Hybrid_Logic-2020-04-18.tar.gz">
+ afp-Hybrid_Logic-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Hybrid_Logic-2020-01-07.tar.gz">
afp-Hybrid_Logic-2020-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/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,208 +1,213 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Hybrid_Multi_Lane_Spatial_Logic-2020-04-18.tar.gz">
+ afp-Hybrid_Multi_Lane_Spatial_Logic-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Hybrid_Multi_Lane_Spatial_Logic-2019-06-11.tar.gz">
afp-Hybrid_Multi_Lane_Spatial_Logic-2019-06-11.tar.gz
</a>
</li>
<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/Hybrid_Systems_VCs.html b/web/entries/Hybrid_Systems_VCs.html
--- a/web/entries/Hybrid_Systems_VCs.html
+++ b/web/entries/Hybrid_Systems_VCs.html
@@ -1,207 +1,212 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Verification Components for Hybrid 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">V</font>erification
<font class="first">C</font>omponents
for
<font class="first">H</font>ybrid
<font class="first">S</font>ystems
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Verification Components for Hybrid Systems</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Jonathan Julian Huerta y Munive (jjhuertaymunive1 /at/ sheffield /dot/ ac /dot/ uk)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-09-10</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
These components formalise a semantic framework for the deductive
verification of hybrid systems. They support reasoning about
continuous evolutions of hybrid programs in the style of differential
dynamics logic. Vector fields or flows model these evolutions, and
their verification is done with invariants for the former or orbits
for the latter. Laws of modal Kleene algebra or categorical predicate
transformers implement the verification condition generation. Examples
show the approach at work.</td>
</tr>
<tr>
<td class="datahead" valign="top">Change history:</td>
<td class="abstract">[2020-12-13]: added components based on Kleene algebras with tests. These implement differential Hoare logic (dH) and a Morgan-style differential refinement calculus (dR) for verification of hybrid programs.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Hybrid_Systems_VCs-AFP,
author = {Jonathan Julian Huerta y Munive},
title = {Verification Components for Hybrid Systems},
journal = {Archive of Formal Proofs},
month = sep,
year = 2019,
note = {\url{https://isa-afp.org/entries/Hybrid_Systems_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>, <a href="Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a>, <a href="Transformer_Semantics.html">Transformer_Semantics</a> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Matrices_for_ODEs.html">Matrices_for_ODEs</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Hybrid_Systems_VCs/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Hybrid_Systems_VCs/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Hybrid_Systems_VCs/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Hybrid_Systems_VCs-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Hybrid_Systems_VCs-2020-04-18.tar.gz">
+ afp-Hybrid_Systems_VCs-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Hybrid_Systems_VCs-2019-09-10.tar.gz">
afp-Hybrid_Systems_VCs-2019-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/HyperCTL.html b/web/entries/HyperCTL.html
--- a/web/entries/HyperCTL.html
+++ b/web/entries/HyperCTL.html
@@ -1,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
shallow
embedding
of
<font class="first">H</font>yperCTL*
</h1>
<p>&nbsp;</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>,
Peter Lammich and
<a href="https://www.andreipopescu.uk">Andrei Popescu</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-HyperCTL-2020-04-18.tar.gz">
+ afp-HyperCTL-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-HyperCTL-2019-06-11.tar.gz">
afp-HyperCTL-2019-06-11.tar.gz
</a>
</li>
<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,263 +1,268 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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>, <a href="MFODL_Monitor_Optimized.html">MFODL_Monitor_Optimized</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-IEEE_Floating_Point-2020-04-18.tar.gz">
+ afp-IEEE_Floating_Point-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-IEEE_Floating_Point-2019-06-11.tar.gz">
afp-IEEE_Floating_Point-2019-06-11.tar.gz
</a>
</li>
<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,215 +1,220 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">I</font>MAP
<font class="first">C</font>mRDT
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-IMAP-CRDT-2020-04-18.tar.gz">
+ afp-IMAP-CRDT-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-IMAP-CRDT-2020-01-14.tar.gz">
afp-IMAP-CRDT-2020-01-14.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-IMAP-CRDT-2019-06-11.tar.gz">
afp-IMAP-CRDT-2019-06-11.tar.gz
</a>
</li>
<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/IMO2019.html b/web/entries/IMO2019.html
--- a/web/entries/IMO2019.html
+++ b/web/entries/IMO2019.html
@@ -1,207 +1,212 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Selected Problems from the International Mathematical Olympiad 2019 - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>elected
<font class="first">P</font>roblems
from
the
<font class="first">I</font>nternational
<font class="first">M</font>athematical
<font class="first">O</font>lympiad
<font class="first">2</font>019
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Selected Problems from the International Mathematical Olympiad 2019</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-08-05</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>This entry contains formalisations of the answers to three of
the six problem of the International Mathematical Olympiad 2019,
namely Q1, Q4, and Q5.</p> <p>The reason why these
problems were chosen is that they are particularly amenable to
formalisation: they can be solved with minimal use of libraries. The
remaining three concern geometry and graph theory, which, in the
author's opinion, are more difficult to formalise resp. require a
more complex library.</p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{IMO2019-AFP,
author = {Manuel Eberl},
title = {Selected Problems from the International Mathematical Olympiad 2019},
journal = {Archive of Formal Proofs},
month = aug,
year = 2019,
note = {\url{https://isa-afp.org/entries/IMO2019.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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_Distribution_Elementary.html">Prime_Distribution_Elementary</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/IMO2019/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/IMO2019/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/IMO2019/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-IMO2019-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-IMO2019-2020-04-18.tar.gz">
+ afp-IMO2019-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-IMO2019-2019-08-06.tar.gz">
afp-IMO2019-2019-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/IMP2.html b/web/entries/IMP2.html
--- a/web/entries/IMP2.html
+++ b/web/entries/IMP2.html
@@ -1,221 +1,226 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Peter Lammich and
<a href="http://home.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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-IMP2-2020-04-18.tar.gz">
+ afp-IMP2-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-IMP2-2019-06-11.tar.gz">
afp-IMP2-2019-06-11.tar.gz
</a>
</li>
<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
--- a/web/entries/IMP2_Binary_Heap.html
+++ b/web/entries/IMP2_Binary_Heap.html
@@ -1,201 +1,206 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>inary
<font class="first">H</font>eaps
for
<font class="first">I</font>MP2
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-IMP2_Binary_Heap-2020-04-18.tar.gz">
+ afp-IMP2_Binary_Heap-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-IMP2_Binary_Heap-2019-06-13.tar.gz">
afp-IMP2_Binary_Heap-2019-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/IP_Addresses.html b/web/entries/IP_Addresses.html
--- a/web/entries/IP_Addresses.html
+++ b/web/entries/IP_Addresses.html
@@ -1,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>P
<font class="first">A</font>ddresses
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-IP_Addresses-2020-04-18.tar.gz">
+ afp-IP_Addresses-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-IP_Addresses-2019-06-11.tar.gz">
afp-IP_Addresses-2019-06-11.tar.gz
</a>
</li>
<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,217 +1,222 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>mperative
<font class="first">I</font>nsertion
<font class="first">S</font>ort
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Imperative_Insertion_Sort-2020-04-18.tar.gz">
+ afp-Imperative_Insertion_Sort-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Imperative_Insertion_Sort-2019-06-11.tar.gz">
afp-Imperative_Insertion_Sort-2019-06-11.tar.gz
</a>
</li>
<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,259 +1,264 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Impossible_Geometry-2020-04-18.tar.gz">
+ afp-Impossible_Geometry-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Impossible_Geometry-2019-06-11.tar.gz">
afp-Impossible_Geometry-2019-06-11.tar.gz
</a>
</li>
<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,239 +1,244 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">G</font>ödel's
<font class="first">I</font>ncompleteness
<font class="first">T</font>heorems
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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="Goedel_HFSet_Semantic.html">Goedel_HFSet_Semantic</a>, <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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Incompleteness-2020-04-18.tar.gz">
+ afp-Incompleteness-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Incompleteness-2019-06-11.tar.gz">
afp-Incompleteness-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Incredible_Proof_Machine-2020-04-18.tar.gz">
+ afp-Incredible_Proof_Machine-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Incredible_Proof_Machine-2019-06-11.tar.gz">
afp-Incredible_Proof_Machine-2019-06-11.tar.gz
</a>
</li>
<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,244 +1,249 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>nductive
<font class="first">S</font>tudy
of
<font class="first">C</font>onfidentiality
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Inductive_Confidentiality-2020-04-18.tar.gz">
+ afp-Inductive_Confidentiality-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Inductive_Confidentiality-2019-06-11.tar.gz">
afp-Inductive_Confidentiality-2019-06-11.tar.gz
</a>
</li>
<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/Inductive_Inference.html b/web/entries/Inductive_Inference.html
--- a/web/entries/Inductive_Inference.html
+++ b/web/entries/Inductive_Inference.html
@@ -1,229 +1,235 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Some classical results in inductive inference of 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>ome
classical
results
in
inductive
inference
of
recursive
functions
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Some classical results in inductive inference of recursive functions</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Frank J. Balbach (frank-balbach /at/ gmx /dot/ de)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-08-31</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p> This entry formalizes some classical concepts and results
from inductive inference of recursive functions. In the basic setting
a partial recursive function ("strategy") must identify
("learn") all functions from a set ("class") of
recursive functions. To that end the strategy receives more and more
values $f(0), f(1), f(2), \ldots$ of some function $f$ from the given
class and in turn outputs descriptions of partial recursive functions,
for example, Gödel numbers. The strategy is considered successful if
the sequence of outputs ("hypotheses") converges to a
description of $f$. A class of functions learnable in this sense is
called "learnable in the limit". The set of all these
classes is denoted by LIM. </p> <p> Other types of
inference considered are finite learning (FIN), behaviorally correct
learning in the limit (BC), and some variants of LIM with restrictions
on the hypotheses: total learning (TOTAL), consistent learning (CONS),
and class-preserving learning (CP). The main results formalized are
the proper inclusions $\mathrm{FIN} \subset \mathrm{CP} \subset
\mathrm{TOTAL} \subset \mathrm{CONS} \subset \mathrm{LIM} \subset
\mathrm{BC} \subset 2^{\mathcal{R}}$, where $\mathcal{R}$ is the set
of all total recursive functions. Further results show that for all
these inference types except CONS, strategies can be assumed to be
total recursive functions; that all inference types but CP are closed
under the subset relation between classes; and that no inference type
is closed under the union of classes. </p> <p> The above
is based on a formalization of recursive functions heavily inspired by
the <a
href="https://www.isa-afp.org/entries/Universal_Turing_Machine.html">Universal
Turing Machine</a> entry by Xu et al., but different in that it
models partial functions with codomain <em>nat
option</em>. The formalization contains a construction of a
universal partial recursive function, without resorting to Turing
machines, introduces decidability and recursive enumerability, and
proves some standard results: existence of a Kleene normal form, the
<em>s-m-n</em> theorem, Rice's theorem, and assorted
fixed-point theorems (recursion theorems) by Kleene, Rogers, and
Smullyan. </p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Inductive_Inference-AFP,
author = {Frank J. Balbach},
title = {Some classical results in inductive inference of recursive functions},
journal = {Archive of Formal Proofs},
month = aug,
year = 2020,
note = {\url{https://isa-afp.org/entries/Inductive_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/Inductive_Inference/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Inductive_Inference/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Inductive_Inference/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Inductive_Inference-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Inductive_Inference-2020-09-02.tar.gz">
+ afp-Inductive_Inference-2020-09-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,245 +1,250 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-InfPathElimination-2020-04-18.tar.gz">
+ afp-InfPathElimination-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-InfPathElimination-2019-06-11.tar.gz">
afp-InfPathElimination-2019-06-11.tar.gz
</a>
</li>
<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,287 +1,292 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-InformationFlowSlicing-2020-04-18.tar.gz">
+ afp-InformationFlowSlicing-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-InformationFlowSlicing-2019-06-11.tar.gz">
afp-InformationFlowSlicing-2019-06-11.tar.gz
</a>
</li>
<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,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-InformationFlowSlicing_Inter-2020-04-18.tar.gz">
+ afp-InformationFlowSlicing_Inter-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-InformationFlowSlicing_Inter-2019-06-11.tar.gz">
afp-InformationFlowSlicing_Inter-2019-06-11.tar.gz
</a>
</li>
<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,295 +1,300 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>ntegration
theory
and
random
variables
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Integration-2020-04-18.tar.gz">
+ afp-Integration-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Integration-2019-06-11.tar.gz">
afp-Integration-2019-06-11.tar.gz
</a>
</li>
<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/Interval_Arithmetic_Word32.html b/web/entries/Interval_Arithmetic_Word32.html
--- a/web/entries/Interval_Arithmetic_Word32.html
+++ b/web/entries/Interval_Arithmetic_Word32.html
@@ -1,204 +1,209 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Interval Arithmetic on 32-bit Words - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>nterval
<font class="first">A</font>rithmetic
on
<font class="first">3</font>2-bit
<font class="first">W</font>ords
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Interval Arithmetic on 32-bit Words</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">2019-11-27</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Interval_Arithmetic implements conservative interval arithmetic
computations, then uses this interval arithmetic to implement a simple
programming language where all terms have 32-bit signed word values,
with explicit infinities for terms outside the representable bounds.
Our target use case is interpreters for languages that must have a
well-understood low-level behavior. We include a formalization of
bounded-length strings which are used for the identifiers of our
language. Bounded-length identifiers are useful in some applications,
for example the <a href="https://www.isa-afp.org/entries/Differential_Dynamic_Logic.html">Differential_Dynamic_Logic</a> article,
where a Euclidean space indexed by identifiers demands that identifiers
are finitely many.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Interval_Arithmetic_Word32-AFP,
author = {Brandon Bohrer},
title = {Interval Arithmetic on 32-bit Words},
journal = {Archive of Formal Proofs},
month = nov,
year = 2019,
note = {\url{https://isa-afp.org/entries/Interval_Arithmetic_Word32.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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/Interval_Arithmetic_Word32/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Interval_Arithmetic_Word32/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Interval_Arithmetic_Word32/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Interval_Arithmetic_Word32-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Interval_Arithmetic_Word32-2020-04-18.tar.gz">
+ afp-Interval_Arithmetic_Word32-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Interval_Arithmetic_Word32-2019-11-28.tar.gz">
afp-Interval_Arithmetic_Word32-2019-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/Iptables_Semantics.html b/web/entries/Iptables_Semantics.html
--- a/web/entries/Iptables_Semantics.html
+++ b/web/entries/Iptables_Semantics.html
@@ -1,225 +1,230 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>ptables
<font class="first">S</font>emantics
</h1>
<p>&nbsp;</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 mathjax_process">
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 &mdash;except for the <tt>iptables-save</tt> dump of
the analyzed firewall&mdash; 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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Iptables_Semantics-2020-04-18.tar.gz">
+ afp-Iptables_Semantics-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Iptables_Semantics-2019-06-11.tar.gz">
afp-Iptables_Semantics-2019-06-11.tar.gz
</a>
</li>
<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/Irrational_Series_Erdos_Straus.html b/web/entries/Irrational_Series_Erdos_Straus.html
--- a/web/entries/Irrational_Series_Erdos_Straus.html
+++ b/web/entries/Irrational_Series_Erdos_Straus.html
@@ -1,201 +1,212 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Irrationality Criteria for Series by Erdős and Straus - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>rrationality
<font class="first">C</font>riteria
for
<font class="first">S</font>eries
by
<font class="first">E</font>rdős
and
<font class="first">S</font>traus
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Irrationality Criteria for Series by Erdős and Straus</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">2020-05-12</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We formalise certain irrationality criteria for infinite series of the form:
\[\sum_{n=1}^\infty \frac{b_n}{\prod_{i=1}^n a_i} \]
where $\{b_n\}$ is a sequence of integers and $\{a_n\}$ a sequence of positive integers
with $a_n >1$ for all large n. The results are due to P. Erdős and E. G. Straus
<a href="https://projecteuclid.org/euclid.pjm/1102911140">[1]</a>.
In particular, we formalise Theorem 2.1, Corollary 2.10 and Theorem 3.1.
The latter is an application of Theorem 2.1 involving the prime numbers.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Irrational_Series_Erdos_Straus-AFP,
author = {Angeliki Koutsoukou-Argyraki and Wenda Li},
title = {Irrationality Criteria for Series by Erdős and Straus},
journal = {Archive of Formal Proofs},
month = may,
year = 2020,
note = {\url{https://isa-afp.org/entries/Irrational_Series_Erdos_Straus.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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_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/Irrational_Series_Erdos_Straus/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Irrational_Series_Erdos_Straus/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Irrational_Series_Erdos_Straus/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Irrational_Series_Erdos_Straus-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Irrational_Series_Erdos_Straus-2020-05-14.tar.gz">
+ afp-Irrational_Series_Erdos_Straus-2020-05-14.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Irrational_Series_Erdos_Straus-2020-05-13.tar.gz">
+ afp-Irrational_Series_Erdos_Straus-2020-05-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/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,206 +1,211 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Irrationality_J_Hancl-2020-04-18.tar.gz">
+ afp-Irrationality_J_Hancl-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Irrationality_J_Hancl-2019-06-11.tar.gz">
afp-Irrationality_J_Hancl-2019-06-11.tar.gz
</a>
</li>
<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/IsaGeoCoq.html b/web/entries/IsaGeoCoq.html
--- a/web/entries/IsaGeoCoq.html
+++ b/web/entries/IsaGeoCoq.html
@@ -1,239 +1,245 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Tarski's Parallel Postulate implies the 5th Postulate of Euclid, the Postulate of Playfair and the original Parallel Postulate of Euclid - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>arski's
<font class="first">P</font>arallel
<font class="first">P</font>ostulate
implies
the
<font class="first">5</font>th
<font class="first">P</font>ostulate
of
<font class="first">E</font>uclid,
the
<font class="first">P</font>ostulate
of
<font class="first">P</font>layfair
and
the
original
<font class="first">P</font>arallel
<font class="first">P</font>ostulate
of
<font class="first">E</font>uclid
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Tarski's Parallel Postulate implies the 5th Postulate of Euclid, the Postulate of Playfair and the original Parallel Postulate of Euclid</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Roland Coghetto (roland_coghetto /at/ hotmail /dot/ com)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2021-01-31</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>The <a href="https://geocoq.github.io/GeoCoq/">GeoCoq library</a> contains a formalization
of geometry using the Coq proof assistant. It contains both proofs
about the foundations of geometry and high-level proofs in the same
style as in high school. We port a part of the GeoCoq
2.4.0 library to Isabelle/HOL: more precisely,
the files Chap02.v to Chap13_3.v, suma.v as well as the associated
definitions and some useful files for the demonstration of certain
parallel postulates. The synthetic approach of the demonstrations is directly
inspired by those contained in GeoCoq. The names of the lemmas and
theorems used are kept as far as possible as well as the definitions.
</p>
<p>It should be noted that T.J.M. Makarios has done
<a href="https://www.isa-afp.org/entries/Tarskis_Geometry.html">some proofs in Tarski's Geometry</a>. It uses a definition that does not quite
coincide with the definition used in Geocoq and here.
Furthermore, corresponding definitions in the <a href="https://www.isa-afp.org/entries/Poincare_Disc.html">Poincaré Disc Model
development</a> are not identical to those defined in GeoCoq.
</p>
<p>In the last part, it is
formalized that, in the neutral/absolute space, the axiom of the
parallels of Tarski's system implies the Playfair axiom, the 5th
postulate of Euclid and Euclid's original parallel postulate. These
proofs, which are not constructive, are directly inspired by Pierre
Boutry, Charly Gries, Julien Narboux and Pascal Schreck.
</p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{IsaGeoCoq-AFP,
author = {Roland Coghetto},
title = {Tarski's Parallel Postulate implies the 5th Postulate of Euclid, the Postulate of Playfair and the original Parallel Postulate of Euclid},
journal = {Archive of Formal Proofs},
month = jan,
year = 2021,
note = {\url{https://isa-afp.org/entries/IsaGeoCoq.html},
Formal 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/IsaGeoCoq/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/IsaGeoCoq/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/IsaGeoCoq/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-IsaGeoCoq-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-IsaGeoCoq-2021-02-01.tar.gz">
+ afp-IsaGeoCoq-2021-02-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/Isabelle_C.html b/web/entries/Isabelle_C.html
--- a/web/entries/Isabelle_C.html
+++ b/web/entries/Isabelle_C.html
@@ -1,205 +1,210 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Isabelle/C - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>sabelle/C
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Isabelle/C</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://www.lri.fr/~ftuong/">Frédéric Tuong</a> and
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-10-22</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We present a framework for C code in C11 syntax deeply integrated into
the Isabelle/PIDE development environment. Our framework provides an
abstract interface for verification back-ends to be plugged-in
independently. Thus, various techniques such as deductive program
verification or white-box testing can be applied to the same source,
which is part of an integrated PIDE document model. Semantic back-ends
are free to choose the supported C fragment and its semantics. In
particular, they can differ on the chosen memory model or the
specification mechanism for framing conditions. Our framework supports
semantic annotations of C sources in the form of comments. Annotations
serve to locally control back-end settings, and can express the term
focus to which an annotation refers. Both the logical and the
syntactic context are available when semantic annotations are
evaluated. As a consequence, a formula in an annotation can refer both
to HOL or C variables. Our approach demonstrates the degree of
maturity and expressive power the Isabelle/PIDE sub-system has
achieved in recent years. Our integration technique employs Lex and
Yacc style grammars to ensure efficient deterministic parsing. This
is the core-module of Isabelle/C; the AFP package for Clean and
Clean_wrapper as well as AutoCorres and AutoCorres_wrapper (available
via git) are applications of this front-end.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Isabelle_C-AFP,
author = {Frédéric Tuong and Burkhart Wolff},
title = {Isabelle/C},
journal = {Archive of Formal Proofs},
month = oct,
year = 2019,
note = {\url{https://isa-afp.org/entries/Isabelle_C.html},
Formal proof development},
ISSN = {2150-914x},
}</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_C/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Isabelle_C/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Isabelle_C/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Isabelle_C-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Isabelle_C-2020-04-18.tar.gz">
+ afp-Isabelle_C-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Isabelle_C-2019-12-19.tar.gz">
afp-Isabelle_C-2019-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/Isabelle_Marries_Dirac.html b/web/entries/Isabelle_Marries_Dirac.html
--- a/web/entries/Isabelle_Marries_Dirac.html
+++ b/web/entries/Isabelle_Marries_Dirac.html
@@ -1,210 +1,216 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Isabelle Marries Dirac: a Library for Quantum Computation and Quantum Information - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>sabelle
<font class="first">M</font>arries
<font class="first">D</font>irac:
a
<font class="first">L</font>ibrary
for
<font class="first">Q</font>uantum
<font class="first">C</font>omputation
and
<font class="first">Q</font>uantum
<font class="first">I</font>nformation
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Isabelle Marries Dirac: a Library for Quantum Computation and Quantum Information</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Anthony Bordg (apdb3 /at/ cam /dot/ ac /dot/ uk),
Hanna Lachnitt (lachnitt /at/ stanford /dot/ edu) and
Yijun He (yh403 /at/ cam /dot/ ac /dot/ uk)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-11-22</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This work is an effort to formalise some quantum algorithms and
results in quantum information theory. Formal methods being critical
for the safety and security of algorithms and protocols, we foresee
their widespread use for quantum computing in the future. We have
developed a large library for quantum computing in Isabelle based on a
matrix representation for quantum circuits, successfully formalising
the no-cloning theorem, quantum teleportation, Deutsch's
algorithm, the Deutsch-Jozsa algorithm and the quantum Prisoner's
Dilemma.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Isabelle_Marries_Dirac-AFP,
author = {Anthony Bordg and Hanna Lachnitt and Yijun He},
title = {Isabelle Marries Dirac: a Library for Quantum Computation and Quantum Information},
journal = {Archive of Formal Proofs},
month = nov,
year = 2020,
note = {\url{https://isa-afp.org/entries/Isabelle_Marries_Dirac.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Matrix_Tensor.html">Matrix_Tensor</a>, <a href="VectorSpace.html">VectorSpace</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Isabelle_Marries_Dirac/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Isabelle_Marries_Dirac/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Isabelle_Marries_Dirac/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Isabelle_Marries_Dirac-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Isabelle_Marries_Dirac-2020-11-30.tar.gz">
+ afp-Isabelle_Marries_Dirac-2020-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/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,255 +1,260 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
<a href="https://www.lri.fr/~ftuong/">Frédéric Tuong</a> and
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Isabelle_Meta_Model-2020-04-18.tar.gz">
+ afp-Isabelle_Meta_Model-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Isabelle_Meta_Model-2019-06-11.tar.gz">
afp-Isabelle_Meta_Model-2019-06-11.tar.gz
</a>
</li>
<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/Jacobson_Basic_Algebra.html b/web/entries/Jacobson_Basic_Algebra.html
--- a/web/entries/Jacobson_Basic_Algebra.html
+++ b/web/entries/Jacobson_Basic_Algebra.html
@@ -1,199 +1,204 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Case Study in Basic 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">C</font>ase
<font class="first">S</font>tudy
in
<font class="first">B</font>asic
<font class="first">A</font>lgebra
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Case Study in Basic Algebra</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">2019-08-30</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
The focus of this case study is re-use in abstract algebra. It
contains locale-based formalisations of selected parts of set, group
and ring theory from Jacobson's <i>Basic Algebra</i>
leading to the respective fundamental homomorphism theorems. The
study is not intended as a library base for abstract algebra. It
rather explores an approach towards abstract algebra in Isabelle.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Jacobson_Basic_Algebra-AFP,
author = {Clemens Ballarin},
title = {A Case Study in Basic Algebra},
journal = {Archive of Formal Proofs},
month = aug,
year = 2019,
note = {\url{https://isa-afp.org/entries/Jacobson_Basic_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/Jacobson_Basic_Algebra/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Jacobson_Basic_Algebra/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Jacobson_Basic_Algebra/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Jacobson_Basic_Algebra-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Jacobson_Basic_Algebra-2020-04-18.tar.gz">
+ afp-Jacobson_Basic_Algebra-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Jacobson_Basic_Algebra-2019-09-01.tar.gz">
afp-Jacobson_Basic_Algebra-2019-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/Jinja.html b/web/entries/Jinja.html
--- a/web/entries/Jinja.html
+++ b/web/entries/Jinja.html
@@ -1,289 +1,294 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">J</font>inja
is
not
<font class="first">J</font>ava
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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="JinjaDCI.html">JinjaDCI</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Jinja-2020-04-18.tar.gz">
+ afp-Jinja-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Jinja-2019-06-11.tar.gz">
afp-Jinja-2019-06-11.tar.gz
</a>
</li>
<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/JinjaDCI.html b/web/entries/JinjaDCI.html
--- a/web/entries/JinjaDCI.html
+++ b/web/entries/JinjaDCI.html
@@ -1,198 +1,204 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>JinjaDCI: a Java semantics with dynamic class initialization - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">J</font>injaDCI:
a
<font class="first">J</font>ava
semantics
with
dynamic
class
initialization
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">JinjaDCI: a Java semantics with dynamic class initialization</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Susannah Mansky (sjohnsn2 /at/ illinois /dot/ edu)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2021-01-11</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We extend Jinja to include static fields, methods, and instructions,
and dynamic class initialization, based on the Java SE 8
specification. This includes extension of definitions and proofs. This
work is partially described in Mansky and Gunter's paper at CPP
2019 and Mansky's doctoral thesis (UIUC, 2020).</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{JinjaDCI-AFP,
author = {Susannah Mansky},
title = {JinjaDCI: a Java semantics with dynamic class initialization},
journal = {Archive of Formal Proofs},
month = jan,
year = 2021,
note = {\url{https://isa-afp.org/entries/JinjaDCI.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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>, <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/JinjaDCI/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/JinjaDCI/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/JinjaDCI/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-JinjaDCI-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-JinjaDCI-2021-01-13.tar.gz">
+ afp-JinjaDCI-2021-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/JinjaThreads.html b/web/entries/JinjaThreads.html
--- a/web/entries/JinjaThreads.html
+++ b/web/entries/JinjaThreads.html
@@ -1,335 +1,340 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">J</font>inja
with
<font class="first">T</font>hreads
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-JinjaThreads-2020-04-18.tar.gz">
+ afp-JinjaThreads-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-JinjaThreads-2019-06-11.tar.gz">
afp-JinjaThreads-2019-06-11.tar.gz
</a>
</li>
<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,282 +1,287 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-JiveDataStoreModel-2020-04-18.tar.gz">
+ afp-JiveDataStoreModel-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-JiveDataStoreModel-2019-06-11.tar.gz">
afp-JiveDataStoreModel-2019-06-11.tar.gz
</a>
</li>
<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,219 +1,224 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">J</font>ordan-Hölder
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Jordan_Hoelder-2020-04-18.tar.gz">
+ afp-Jordan_Hoelder-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Jordan_Hoelder-2019-06-11.tar.gz">
afp-Jordan_Hoelder-2019-06-11.tar.gz
</a>
</li>
<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,249 +1,254 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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 mathjax_process">
<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{https://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="Isabelle_Marries_Dirac.html">Isabelle_Marries_Dirac</a>, <a href="Linear_Programming.html">Linear_Programming</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Jordan_Normal_Form-2020-04-18.tar.gz">
+ afp-Jordan_Normal_Form-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Jordan_Normal_Form-2019-06-11.tar.gz">
afp-Jordan_Normal_Form-2019-06-11.tar.gz
</a>
</li>
<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,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">K</font>leene
<font class="first">A</font>lgebras
with
<font class="first">D</font>omain
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>, <a href="Hybrid_Systems_VCs.html">Hybrid_Systems_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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-KAD-2020-04-18.tar.gz">
+ afp-KAD-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-KAD-2019-06-11.tar.gz">
afp-KAD-2019-06-11.tar.gz
</a>
</li>
<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,247 +1,252 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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>, <a href="Hybrid_Systems_VCs.html">Hybrid_Systems_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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-KAT_and_DRA-2020-04-18.tar.gz">
+ afp-KAT_and_DRA-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-KAT_and_DRA-2019-06-11.tar.gz">
afp-KAT_and_DRA-2019-06-11.tar.gz
</a>
</li>
<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,258 +1,263 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">K</font>nowledge-based
programs
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-KBPs-2020-04-18.tar.gz">
+ afp-KBPs-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-KBPs-2019-06-11.tar.gz">
afp-KBPs-2019-06-11.tar.gz
</a>
</li>
<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,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 (martin /dot/ rau /at/ tum /dot/ de)
</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 mathjax_process">
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">Change history:</td>
<td class="abstract">[2020-15-04]: Change representation of k-dimensional points from 'list' to
HOL-Analysis.Finite_Cartesian_Product 'vec'. Update proofs
to incorporate HOL-Analysis 'dist' and 'cbox' primitives.</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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-KD_Tree-2020-04-18.tar.gz">
+ afp-KD_Tree-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-KD_Tree-2019-06-11.tar.gz">
afp-KD_Tree-2019-06-11.tar.gz
</a>
</li>
<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,222 +1,227 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Key_Agreement_Strong_Adversaries-2020-04-18.tar.gz">
+ afp-Key_Agreement_Strong_Adversaries-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Key_Agreement_Strong_Adversaries-2019-06-11.tar.gz">
afp-Key_Agreement_Strong_Adversaries-2019-06-11.tar.gz
</a>
</li>
<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,266 +1,271 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">K</font>leene
<font class="first">A</font>lgebra
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Kleene_Algebra-2020-04-18.tar.gz">
+ afp-Kleene_Algebra-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Kleene_Algebra-2019-06-11.tar.gz">
afp-Kleene_Algebra-2019-06-11.tar.gz
</a>
</li>
<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,219 +1,224 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">K</font>not
<font class="first">T</font>heory
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Knot_Theory-2020-04-18.tar.gz">
+ afp-Knot_Theory-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Knot_Theory-2019-06-11.tar.gz">
afp-Knot_Theory-2019-06-11.tar.gz
</a>
</li>
<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_Bendix_Order.html b/web/entries/Knuth_Bendix_Order.html
--- a/web/entries/Knuth_Bendix_Order.html
+++ b/web/entries/Knuth_Bendix_Order.html
@@ -1,195 +1,206 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Formalization of Knuth–Bendix 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">F</font>ormalization
of
<font class="first">K</font>nuth–Bendix
<font class="first">O</font>rders
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Formalization of Knuth–Bendix Orders</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">2020-05-13</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We define a generalized version of Knuth&ndash;Bendix orders,
including subterm coefficient functions. For these orders we formalize
several properties such as strong normalization, the subterm property,
closure properties under substitutions and contexts, as well as ground
totality.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Knuth_Bendix_Order-AFP,
author = {Christian Sternagel and René Thiemann},
title = {A Formalization of Knuth–Bendix Orders},
journal = {Archive of Formal Proofs},
month = may,
year = 2020,
note = {\url{https://isa-afp.org/entries/Knuth_Bendix_Order.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Matrix.html">Matrix</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</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/Knuth_Bendix_Order/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Knuth_Bendix_Order/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Knuth_Bendix_Order/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Knuth_Bendix_Order-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Knuth_Bendix_Order-2020-05-16.tar.gz">
+ afp-Knuth_Bendix_Order-2020-05-16.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Knuth_Bendix_Order-2020-05-15.tar.gz">
+ afp-Knuth_Bendix_Order-2020-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/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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
Peter Lammich
</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 mathjax_process">
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{https://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>
</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Knuth_Morris_Pratt-2020-04-18.tar.gz">
+ afp-Knuth_Morris_Pratt-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Knuth_Morris_Pratt-2019-06-11.tar.gz">
afp-Knuth_Morris_Pratt-2019-06-11.tar.gz
</a>
</li>
<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,244 +1,249 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Koenigsberg_Friendship-2020-04-18.tar.gz">
+ afp-Koenigsberg_Friendship-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Koenigsberg_Friendship-2019-06-11.tar.gz">
afp-Koenigsberg_Friendship-2019-06-11.tar.gz
</a>
</li>
<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,210 +1,215 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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>,
Peter Lammich 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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Kruskal-2020-04-18.tar.gz">
+ afp-Kruskal-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Kruskal-2019-06-11.tar.gz">
afp-Kruskal-2019-06-11.tar.gz
</a>
</li>
<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,206 +1,211 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Kuratowski_Closure_Complement-2020-04-18.tar.gz">
+ afp-Kuratowski_Closure_Complement-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Kuratowski_Closure_Complement-2019-06-11.tar.gz">
afp-Kuratowski_Closure_Complement-2019-06-11.tar.gz
</a>
</li>
<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,231 +1,236 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
verified
<font class="first">L</font>LL
algorithm
</h1>
<p>&nbsp;</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="https://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
<a href="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Maximilian Haslbeck</a>,
<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a> and
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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 mathjax_process">
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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LLL_Basis_Reduction-2020-04-20.tar.gz">
+ afp-LLL_Basis_Reduction-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LLL_Basis_Reduction-2019-06-11.tar.gz">
afp-LLL_Basis_Reduction-2019-06-11.tar.gz
</a>
</li>
<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,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
verified
factorization
algorithm
for
integer
polynomials
with
polynomial
complexity
</h1>
<p>&nbsp;</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="https://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
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LLL_Factorization-2020-04-20.tar.gz">
+ afp-LLL_Factorization-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LLL_Factorization-2019-06-11.tar.gz">
afp-LLL_Factorization-2019-06-11.tar.gz
</a>
</li>
<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,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LOFT-2020-04-20.tar.gz">
+ afp-LOFT-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LOFT-2019-06-11.tar.gz">
afp-LOFT-2019-06-11.tar.gz
</a>
</li>
<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,231 +1,236 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>inear
<font class="first">T</font>emporal
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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_Normal_Form.html">LTL_Normal_Form</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LTL-2020-04-20.tar.gz">
+ afp-LTL-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LTL-2019-06-11.tar.gz">
afp-LTL-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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="Deriving.html">Deriving</a>, <a href="LTL.html">LTL</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="LTL_Normal_Form.html">LTL_Normal_Form</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LTL_Master_Theorem-2020-04-20.tar.gz">
+ afp-LTL_Master_Theorem-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LTL_Master_Theorem-2019-06-11.tar.gz">
afp-LTL_Master_Theorem-2019-06-11.tar.gz
</a>
</li>
<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_Normal_Form.html b/web/entries/LTL_Normal_Form.html
--- a/web/entries/LTL_Normal_Form.html
+++ b/web/entries/LTL_Normal_Form.html
@@ -1,211 +1,217 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>An Efficient Normalisation Procedure for Linear Temporal Logic: Isabelle/HOL Formalisation - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>n
<font class="first">E</font>fficient
<font class="first">N</font>ormalisation
<font class="first">P</font>rocedure
for
<font class="first">L</font>inear
<font class="first">T</font>emporal
<font class="first">L</font>ogic:
<font class="first">I</font>sabelle/HOL
<font class="first">F</font>ormalisation
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">An Efficient Normalisation Procedure for Linear Temporal Logic: Isabelle/HOL Formalisation</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">2020-05-08</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In the mid 80s, Lichtenstein, Pnueli, and Zuck proved a classical
theorem stating that every formula of Past LTL (the extension of LTL
with past operators) is equivalent to a formula of the form
$\bigwedge_{i=1}^n \mathbf{G}\mathbf{F} \varphi_i \vee
\mathbf{F}\mathbf{G} \psi_i$, where $\varphi_i$ and $\psi_i$ contain
only past operators. Some years later, Chang, Manna, and Pnueli built
on this result to derive a similar normal form for LTL. Both
normalisation procedures have a non-elementary worst-case blow-up, and
follow an involved path from formulas to counter-free automata to
star-free regular expressions and back to formulas. We improve on both
points. We present an executable formalisation of a direct and purely
syntactic normalisation procedure for LTL yielding a normal form,
comparable to the one by Chang, Manna, and Pnueli, that has only a
single exponential blow-up.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{LTL_Normal_Form-AFP,
author = {Salomon Sickert},
title = {An Efficient Normalisation Procedure for Linear Temporal Logic: Isabelle/HOL Formalisation},
journal = {Archive of Formal Proofs},
month = may,
year = 2020,
note = {\url{https://isa-afp.org/entries/LTL_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="LTL.html">LTL</a>, <a href="LTL_Master_Theorem.html">LTL_Master_Theorem</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/LTL_Normal_Form/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/LTL_Normal_Form/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/LTL_Normal_Form/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-LTL_Normal_Form-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-LTL_Normal_Form-2020-05-09.tar.gz">
+ afp-LTL_Normal_Form-2020-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/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,231 +1,236 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LTL_to_DRA-2020-04-20.tar.gz">
+ afp-LTL_to_DRA-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LTL_to_DRA-2019-06-11.tar.gz">
afp-LTL_to_DRA-2019-06-11.tar.gz
</a>
</li>
<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,246 +1,251 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
Peter Lammich
</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 mathjax_process">
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{https://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>
</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LTL_to_GBA-2020-04-20.tar.gz">
+ afp-LTL_to_GBA-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LTL_to_GBA-2019-06-11.tar.gz">
afp-LTL_to_GBA-2019-06-11.tar.gz
</a>
</li>
<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,258 +1,263 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lam-ml-Normalization-2020-04-18.tar.gz">
+ afp-Lam-ml-Normalization-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lam-ml-Normalization-2019-06-11.tar.gz">
afp-Lam-ml-Normalization-2019-06-11.tar.gz
</a>
</li>
<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,217 +1,222 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://traytel.bitbucket.io">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 mathjax_process">
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>.</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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LambdaAuth-2020-04-18.tar.gz">
+ afp-LambdaAuth-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LambdaAuth-2019-06-11.tar.gz">
afp-LambdaAuth-2019-06-11.tar.gz
</a>
</li>
<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,210 +1,215 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">L</font>ambdaMu-calculus
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LambdaMu-2020-04-18.tar.gz">
+ afp-LambdaMu-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LambdaMu-2019-06-11.tar.gz">
afp-LambdaMu-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lambda_Free_EPO-2020-04-18.tar.gz">
+ afp-Lambda_Free_EPO-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lambda_Free_EPO-2019-06-11.tar.gz">
afp-Lambda_Free_EPO-2019-06-11.tar.gz
</a>
</li>
<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,217 +1,222 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lambda_Free_KBOs-2020-04-18.tar.gz">
+ afp-Lambda_Free_KBOs-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lambda_Free_KBOs-2019-06-11.tar.gz">
afp-Lambda_Free_KBOs-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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">Depends on:</td>
<td class="data"><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>, <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>, <a href="Saturation_Framework.html">Saturation_Framework</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lambda_Free_RPOs-2020-04-18.tar.gz">
+ afp-Lambda_Free_RPOs-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lambda_Free_RPOs-2019-06-11.tar.gz">
afp-Lambda_Free_RPOs-2019-06-11.tar.gz
</a>
</li>
<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/Lambert_W.html b/web/entries/Lambert_W.html
--- a/web/entries/Lambert_W.html
+++ b/web/entries/Lambert_W.html
@@ -1,209 +1,220 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>The Lambert W Function on the Reals - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">L</font>ambert
<font class="first">W</font>
<font class="first">F</font>unction
on
the
<font class="first">R</font>eals
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">The Lambert W Function on the Reals</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">2020-04-24</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>The Lambert <em>W</em> function is a multi-valued
function defined as the inverse function of <em>x</em>
&#x21A6; <em>x</em>
e<sup><em>x</em></sup>. Besides numerous
applications in combinatorics, physics, and engineering, it also
frequently occurs when solving equations containing both
e<sup><em>x</em></sup> and
<em>x</em>, or both <em>x</em> and log
<em>x</em>.</p> <p>This article provides a
definition of the two real-valued branches
<em>W</em><sub>0</sub>(<em>x</em>)
and
<em>W</em><sub>-1</sub>(<em>x</em>)
and proves various properties such as basic identities and
inequalities, monotonicity, differentiability, asymptotic expansions,
and the MacLaurin series of
<em>W</em><sub>0</sub>(<em>x</em>)
at <em>x</em> = 0.</p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Lambert_W-AFP,
author = {Manuel Eberl},
title = {The Lambert W Function on the Reals},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/Lambert_W.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="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/Lambert_W/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Lambert_W/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Lambert_W/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Lambert_W-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lambert_W-2020-05-12.tar.gz">
+ afp-Lambert_W-2020-05-12.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lambert_W-2020-04-29.tar.gz">
+ afp-Lambert_W-2020-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/Landau_Symbols.html b/web/entries/Landau_Symbols.html
--- a/web/entries/Landau_Symbols.html
+++ b/web/entries/Landau_Symbols.html
@@ -1,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>andau
<font class="first">S</font>ymbols
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Landau_Symbols-2020-04-18.tar.gz">
+ afp-Landau_Symbols-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Landau_Symbols-2019-06-11.tar.gz">
afp-Landau_Symbols-2019-06-11.tar.gz
</a>
</li>
<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/Laplace_Transform.html b/web/entries/Laplace_Transform.html
--- a/web/entries/Laplace_Transform.html
+++ b/web/entries/Laplace_Transform.html
@@ -1,192 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Laplace 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>aplace
<font class="first">T</font>ransform
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Laplace Transform</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">2019-08-14</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This entry formalizes the Laplace transform and concrete Laplace
transforms for arithmetic functions, frequency shift, integration and
(higher) differentiation in the time domain. It proves Lerch's
lemma and uniqueness of the Laplace transform for continuous
functions. In order to formalize the foundational assumptions, this
entry contains a formalization of piecewise continuous functions and
functions of exponential order.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Laplace_Transform-AFP,
author = {Fabian Immler},
title = {Laplace Transform},
journal = {Archive of Formal Proofs},
month = aug,
year = 2019,
note = {\url{https://isa-afp.org/entries/Laplace_Transform.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Laplace_Transform/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Laplace_Transform/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Laplace_Transform/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Laplace_Transform-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Laplace_Transform-2020-04-18.tar.gz">
+ afp-Laplace_Transform-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Laplace_Transform-2019-08-16.tar.gz">
afp-Laplace_Transform-2019-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/Latin_Square.html b/web/entries/Latin_Square.html
--- a/web/entries/Latin_Square.html
+++ b/web/entries/Latin_Square.html
@@ -1,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>atin
<font class="first">S</font>quare
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Latin_Square-2020-04-18.tar.gz">
+ afp-Latin_Square-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Latin_Square-2019-06-11.tar.gz">
afp-Latin_Square-2019-06-11.tar.gz
</a>
</li>
<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,259 +1,264 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>attice
<font class="first">P</font>roperties
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LatticeProperties-2020-04-18.tar.gz">
+ afp-LatticeProperties-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LatticeProperties-2019-06-28.tar.gz">
afp-LatticeProperties-2019-06-28.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-LatticeProperties-2019-06-11.tar.gz">
afp-LatticeProperties-2019-06-11.tar.gz
</a>
</li>
<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,268 +1,273 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Launchbury-2020-04-18.tar.gz">
+ afp-Launchbury-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Launchbury-2019-06-11.tar.gz">
afp-Launchbury-2019-06-11.tar.gz
</a>
</li>
<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/Laws_of_Large_Numbers.html b/web/entries/Laws_of_Large_Numbers.html
--- a/web/entries/Laws_of_Large_Numbers.html
+++ b/web/entries/Laws_of_Large_Numbers.html
@@ -1,206 +1,212 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>The Laws of Large 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">L</font>aws
of
<font class="first">L</font>arge
<font class="first">N</font>umbers
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">The Laws of Large 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">2021-02-10</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>The Law of Large Numbers states that, informally, if one
performs a random experiment $X$ many times and takes the average of
the results, that average will be very close to the expected value
$E[X]$.</p> <p> More formally, let
$(X_i)_{i\in\mathbb{N}}$ be a sequence of independently identically
distributed random variables whose expected value $E[X_1]$ exists.
Denote the running average of $X_1, \ldots, X_n$ as $\overline{X}_n$.
Then:</p> <ul> <li>The Weak Law of Large Numbers
states that $\overline{X}_{n} \longrightarrow E[X_1]$ in probability
for $n\to\infty$, i.e. $\mathcal{P}(|\overline{X}_{n} - E[X_1]| >
\varepsilon) \longrightarrow 0$ as $n\to\infty$ for any $\varepsilon
> 0$.</li> <li>The Strong Law of Large Numbers states
that $\overline{X}_{n} \longrightarrow E[X_1]$ almost surely for
$n\to\infty$, i.e. $\mathcal{P}(\overline{X}_{n} \longrightarrow
E[X_1]) = 1$.</li> </ul> <p>In this entry, I
formally prove the strong law and from it the weak law. The approach
used for the proof of the strong law is a particularly quick and slick
one based on ergodic theory, which was formalised by Gouëzel in
another AFP entry.</p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Laws_of_Large_Numbers-AFP,
author = {Manuel Eberl},
title = {The Laws of Large Numbers},
journal = {Archive of Formal Proofs},
month = feb,
year = 2021,
note = {\url{https://isa-afp.org/entries/Laws_of_Large_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="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/Laws_of_Large_Numbers/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Laws_of_Large_Numbers/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Laws_of_Large_Numbers/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Laws_of_Large_Numbers-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Laws_of_Large_Numbers-2021-02-11.tar.gz">
+ afp-Laws_of_Large_Numbers-2021-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/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,291 +1,296 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>azy
<font class="first">L</font>ists
<font class="first">I</font>I
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lazy-Lists-II-2020-04-18.tar.gz">
+ afp-Lazy-Lists-II-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lazy-Lists-II-2019-06-11.tar.gz">
afp-Lazy-Lists-II-2019-06-11.tar.gz
</a>
</li>
<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,216 +1,221 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>azifying
case
constants
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lazy_Case-2020-04-18.tar.gz">
+ afp-Lazy_Case-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lazy_Case-2019-06-11.tar.gz">
afp-Lazy_Case-2019-06-11.tar.gz
</a>
</li>
<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,231 +1,236 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ehmer's
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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://home.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lehmer-2020-04-18.tar.gz">
+ afp-Lehmer-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lehmer-2019-06-11.tar.gz">
afp-Lehmer-2019-06-11.tar.gz
</a>
</li>
<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,231 +1,236 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ifting
<font class="first">D</font>efinition
<font class="first">O</font>ption
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lifting_Definition_Option-2020-04-18.tar.gz">
+ afp-Lifting_Definition_Option-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lifting_Definition_Option-2019-06-11.tar.gz">
afp-Lifting_Definition_Option-2019-06-11.tar.gz
</a>
</li>
<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,246 +1,251 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ightweight
<font class="first">J</font>ava
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LightweightJava-2020-04-18.tar.gz">
+ afp-LightweightJava-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LightweightJava-2019-06-11.tar.gz">
afp-LightweightJava-2019-06-11.tar.gz
</a>
</li>
<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,291 +1,296 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LinearQuantifierElim-2020-04-18.tar.gz">
+ afp-LinearQuantifierElim-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LinearQuantifierElim-2019-06-11.tar.gz">
afp-LinearQuantifierElim-2019-06-11.tar.gz
</a>
</li>
<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
--- a/web/entries/Linear_Inequalities.html
+++ b/web/entries/Linear_Inequalities.html
@@ -1,199 +1,204 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>inear
<font class="first">I</font>nequalities
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Linear_Programming.html">Linear_Programming</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Linear_Inequalities-2020-04-18.tar.gz">
+ afp-Linear_Inequalities-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Linear_Inequalities-2019-06-24.tar.gz">
afp-Linear_Inequalities-2019-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/Linear_Programming.html b/web/entries/Linear_Programming.html
--- a/web/entries/Linear_Programming.html
+++ b/web/entries/Linear_Programming.html
@@ -1,194 +1,199 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Linear 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>inear
<font class="first">P</font>rogramming
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Linear Programming</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://www.parsert.com/">Julian Parsert</a> and
<a href="http://cl-informatik.uibk.ac.at/cek/">Cezary Kaliszyk</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-08-06</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We use the previous formalization of the general simplex algorithm to
formulate an algorithm for solving linear programs. We encode the
linear programs using only linear constraints. Solving these
constraints also solves the original linear program. This algorithm is
proven to be sound by applying the weak duality theorem which is also
part of this formalization.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Linear_Programming-AFP,
author = {Julian Parsert and Cezary Kaliszyk},
title = {Linear Programming},
journal = {Archive of Formal Proofs},
month = aug,
year = 2019,
note = {\url{https://isa-afp.org/entries/Linear_Programming.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Farkas.html">Farkas</a>, <a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a>, <a href="Linear_Inequalities.html">Linear_Inequalities</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Linear_Programming/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Linear_Programming/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Linear_Programming/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Linear_Programming-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Linear_Programming-2020-04-18.tar.gz">
+ afp-Linear_Programming-2020-04-18.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Linear_Programming-2019-09-23.tar.gz">
afp-Linear_Programming-2019-09-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/Linear_Recurrences.html b/web/entries/Linear_Recurrences.html
--- a/web/entries/Linear_Recurrences.html
+++ b/web/entries/Linear_Recurrences.html
@@ -1,214 +1,219 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>inear
<font class="first">R</font>ecurrences
</h1>
<p>&nbsp;</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 mathjax_process">
<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>&phi;</i><sup><i>n</i></sup>
-
(-<i>&phi;</i>)<sup>-<i>n</i></sup>)
/ &radic;<span style="text-decoration:
overline">5</span> where &phi; is the golden ratio.
</p> <p> In this work, I build on existing tools in
Isabelle &ndash; such as formal power series and polynomial
factorisation algorithms &ndash; 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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Linear_Recurrences-2020-04-20.tar.gz">
+ afp-Linear_Recurrences-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Linear_Recurrences-2019-06-11.tar.gz">
afp-Linear_Recurrences-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>iouville
numbers
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Liouville_Numbers-2020-04-20.tar.gz">
+ afp-Liouville_Numbers-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Liouville_Numbers-2019-06-11.tar.gz">
afp-Liouville_Numbers-2019-06-11.tar.gz
</a>
</li>
<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,257 +1,262 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ist
<font class="first">I</font>ndex
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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="JinjaDCI.html">JinjaDCI</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>, <a href="Smith_Normal_Form.html">Smith_Normal_Form</a>, <a href="Verified_SAT_Based_AI_Planning.html">Verified_SAT_Based_AI_Planning</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-List-Index-2020-04-20.tar.gz">
+ afp-List-Index-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-List-Index-2019-06-11.tar.gz">
afp-List-Index-2019-06-11.tar.gz
</a>
</li>
<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,252 +1,257 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>nfinite
<font class="first">L</font>ists
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-List-Infinite-2020-04-20.tar.gz">
+ afp-List-Infinite-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-List-Infinite-2019-06-11.tar.gz">
afp-List-Infinite-2019-06-11.tar.gz
</a>
</li>
<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,238 +1,243 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-List_Interleaving-2020-04-20.tar.gz">
+ afp-List_Interleaving-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-List_Interleaving-2019-06-11.tar.gz">
afp-List_Interleaving-2019-06-11.tar.gz
</a>
</li>
<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,202 +1,207 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">I</font>nversions
of
a
<font class="first">L</font>ist
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-List_Inversions-2020-04-20.tar.gz">
+ afp-List_Inversions-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-List_Inversions-2019-06-11.tar.gz">
afp-List_Inversions-2019-06-11.tar.gz
</a>
</li>
<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,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-List_Update-2020-04-20.tar.gz">
+ afp-List_Update-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-List_Update-2019-06-11.tar.gz">
afp-List_Update-2019-06-11.tar.gz
</a>
</li>
<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,209 +1,214 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ocal
<font class="first">L</font>exing
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-LocalLexing-2020-04-20.tar.gz">
+ afp-LocalLexing-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-LocalLexing-2019-06-11.tar.gz">
afp-LocalLexing-2019-06-11.tar.gz
</a>
</li>
<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,208 +1,213 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Anthony Bordg (apdb3 /at/ cam /dot/ ac /dot/ uk)
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Localization_Ring-2020-04-20.tar.gz">
+ afp-Localization_Ring-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Localization_Ring-2019-06-11.tar.gz">
afp-Localization_Ring-2019-06-11.tar.gz
</a>
</li>
<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,264 +1,269 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Locally-Nameless-Sigma-2020-04-20.tar.gz">
+ afp-Locally-Nameless-Sigma-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Locally-Nameless-Sigma-2019-06-11.tar.gz">
afp-Locally-Nameless-Sigma-2019-06-11.tar.gz
</a>
</li>
<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,222 +1,227 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lowe_Ontological_Argument-2020-04-20.tar.gz">
+ afp-Lowe_Ontological_Argument-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lowe_Ontological_Argument-2019-06-11.tar.gz">
afp-Lowe_Ontological_Argument-2019-06-11.tar.gz
</a>
</li>
<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,247 +1,252 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ower
<font class="first">S</font>emicontinuous
<font class="first">F</font>unctions
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lower_Semicontinuous-2020-04-20.tar.gz">
+ afp-Lower_Semicontinuous-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lower_Semicontinuous-2019-06-11.tar.gz">
afp-Lower_Semicontinuous-2019-06-11.tar.gz
</a>
</li>
<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,205 +1,210 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>p
spaces
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Fourier.html">Fourier</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lp-2020-04-20.tar.gz">
+ afp-Lp-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Lp-2019-06-11.tar.gz">
afp-Lp-2019-06-11.tar.gz
</a>
</li>
<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/Lucas_Theorem.html b/web/entries/Lucas_Theorem.html
--- a/web/entries/Lucas_Theorem.html
+++ b/web/entries/Lucas_Theorem.html
@@ -1,192 +1,198 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Lucas'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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ucas's
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Lucas's Theorem</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Chelsea Edmonds (cle47 /at/ cam /dot/ ac /dot/ uk)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-04-07</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This work presents a formalisation of a generating function proof for
Lucas's theorem. We first outline extensions to the existing
Formal Power Series (FPS) library, including an equivalence relation
for coefficients modulo <em>n</em>, an alternate binomial theorem statement,
and a formalised proof of the Freshman's dream (mod <em>p</em>) lemma.
The second part of the work presents the formal proof of Lucas's
Theorem. Working backwards, the formalisation first proves a well
known corollary of the theorem which is easier to formalise, and then
applies induction to prove the original theorem statement. The proof
of the corollary aims to provide a good example of a formalised
generating function equivalence proof using the FPS library. The final
theorem statement is intended to be integrated into the formalised
proof of Hilbert's 10th Problem.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Lucas_Theorem-AFP,
author = {Chelsea Edmonds},
title = {Lucas's Theorem},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/Lucas_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/Lucas_Theorem/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Lucas_Theorem/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Lucas_Theorem/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Lucas_Theorem-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Lucas_Theorem-2020-04-21.tar.gz">
+ afp-Lucas_Theorem-2020-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/MFMC_Countable.html b/web/entries/MFMC_Countable.html
--- a/web/entries/MFMC_Countable.html
+++ b/web/entries/MFMC_Countable.html
@@ -1,252 +1,257 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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>
[2020-12-19]:
simpler proof of linkability for bounded unhindered bipartite webs, leading to a simpler proof for networks with bounded out-capacities
(revision 93ca33f4d915)<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-MFMC_Countable-2020-04-20.tar.gz">
+ afp-MFMC_Countable-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-MFMC_Countable-2019-06-11.tar.gz">
afp-MFMC_Countable-2019-06-11.tar.gz
</a>
</li>
<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/MFODL_Monitor_Optimized.html b/web/entries/MFODL_Monitor_Optimized.html
--- a/web/entries/MFODL_Monitor_Optimized.html
+++ b/web/entries/MFODL_Monitor_Optimized.html
@@ -1,237 +1,242 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Formalization of an Optimized Monitoring Algorithm for Metric First-Order Dynamic Logic with Aggregations - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalization
of
an
<font class="first">O</font>ptimized
<font class="first">M</font>onitoring
<font class="first">A</font>lgorithm
for
<font class="first">M</font>etric
<font class="first">F</font>irst-Order
<font class="first">D</font>ynamic
<font class="first">L</font>ogic
with
<font class="first">A</font>ggregations
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Formalization of an Optimized Monitoring Algorithm for Metric First-Order Dynamic Logic with Aggregations</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Thibault Dardinier,
Lukas Heimes,
Martin Raszyk (martin /dot/ raszyk /at/ inf /dot/ ethz /dot/ ch),
Joshua Schneider and
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-04-09</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
A monitor is a runtime verification tool that solves the following
problem: Given a stream of time-stamped events and a policy formulated
in a specification language, decide whether the policy is satisfied at
every point in the stream. We verify the correctness of an executable
monitor for specifications given as formulas in metric first-order
dynamic logic (MFODL), which combines the features of metric
first-order temporal logic (MFOTL) and metric dynamic logic. Thus,
MFODL supports real-time constraints, first-order parameters, and
regular expressions. Additionally, the monitor supports aggregation
operations such as count and sum. This formalization, which is
described in a <a
href="http://people.inf.ethz.ch/trayteld/papers/ijcar20-verimonplus/verimonplus.pdf">
forthcoming paper at IJCAR 2020</a>, significantly extends <a
href="https://www.isa-afp.org/entries/MFOTL_Monitor.html">previous
work on a verified monitor</a> for MFOTL. Apart from the
addition of regular expressions and aggregations, we implemented <a
href="https://www.isa-afp.org/entries/Generic_Join.html">multi-way
joins</a> and a specialized sliding window algorithm to further
optimize the monitor.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{MFODL_Monitor_Optimized-AFP,
author = {Thibault Dardinier and Lukas Heimes and Martin Raszyk and Joshua Schneider and Dmitriy Traytel},
title = {Formalization of an Optimized Monitoring Algorithm for Metric First-Order Dynamic Logic with Aggregations},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/MFODL_Monitor_Optimized.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Generic_Join.html">Generic_Join</a>, <a href="IEEE_Floating_Point.html">IEEE_Floating_Point</a>, <a href="MFOTL_Monitor.html">MFOTL_Monitor</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/MFODL_Monitor_Optimized/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/MFODL_Monitor_Optimized/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/MFODL_Monitor_Optimized/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-MFODL_Monitor_Optimized-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-MFODL_Monitor_Optimized-2020-04-20.tar.gz">
+ afp-MFODL_Monitor_Optimized-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-MFODL_Monitor_Optimized-2020-04-12.tar.gz">
afp-MFODL_Monitor_Optimized-2020-04-12.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-MFODL_Monitor_Optimized-2020-04-11.tar.gz">
afp-MFODL_Monitor_Optimized-2020-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/MFOTL_Monitor.html b/web/entries/MFOTL_Monitor.html
--- a/web/entries/MFOTL_Monitor.html
+++ b/web/entries/MFOTL_Monitor.html
@@ -1,226 +1,231 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Formalization of a Monitoring Algorithm for Metric First-Order 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalization
of
a
<font class="first">M</font>onitoring
<font class="first">A</font>lgorithm
for
<font class="first">M</font>etric
<font class="first">F</font>irst-Order
<font class="first">T</font>emporal
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Formalization of a Monitoring Algorithm for Metric First-Order Temporal Logic</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Joshua Schneider and
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-07-04</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
A monitor is a runtime verification tool that solves the following
problem: Given a stream of time-stamped events and a policy formulated
in a specification language, decide whether the policy is satisfied at
every point in the stream. We verify the correctness of an executable
monitor for specifications given as formulas in metric first-order
temporal logic (MFOTL), an expressive extension of linear temporal
logic with real-time constraints and first-order quantification. The
verified monitor implements a simplified variant of the algorithm used
in the efficient MonPoly monitoring tool. The formalization is
presented in a <a href="https://doi.org/10.1007/978-3-030-32079-9_18">RV
2019 paper</a>, which also compares the output of the verified
monitor to that of other monitoring tools on randomly generated
inputs. This case study revealed several errors in the optimized but
unverified tools.</td>
</tr>
<tr>
<td class="datahead" valign="top">Change history:</td>
<td class="abstract">[2020-08-13]:
added the formalization of the abstract slicing framework and joint data
slicer (revision b1639ed541b7)<br></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{MFOTL_Monitor-AFP,
author = {Joshua Schneider and Dmitriy Traytel},
title = {Formalization of a Monitoring Algorithm for Metric First-Order Temporal Logic},
journal = {Archive of Formal Proofs},
month = jul,
year = 2019,
note = {\url{https://isa-afp.org/entries/MFOTL_Monitor.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Containers.html">Containers</a> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Generic_Join.html">Generic_Join</a>, <a href="MFODL_Monitor_Optimized.html">MFODL_Monitor_Optimized</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/MFOTL_Monitor/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/MFOTL_Monitor/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/MFOTL_Monitor/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-MFOTL_Monitor-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-MFOTL_Monitor-2020-04-20.tar.gz">
+ afp-MFOTL_Monitor-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-MFOTL_Monitor-2019-07-05.tar.gz">
afp-MFOTL_Monitor-2019-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/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,260 +1,265 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://traytel.bitbucket.io">Dmitriy Traytel</a> and
<a href="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-MSO_Regex_Equivalence-2020-04-20.tar.gz">
+ afp-MSO_Regex_Equivalence-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-MSO_Regex_Equivalence-2019-06-11.tar.gz">
afp-MSO_Regex_Equivalence-2019-06-11.tar.gz
</a>
</li>
<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,258 +1,263 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>arkov
<font class="first">M</font>odels
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Markov_Models-2020-04-20.tar.gz">
+ afp-Markov_Models-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Markov_Models-2019-06-11.tar.gz">
afp-Markov_Models-2019-06-11.tar.gz
</a>
</li>
<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,259 +1,264 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">H</font>all's
<font class="first">M</font>arriage
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Marriage-2020-04-20.tar.gz">
+ afp-Marriage-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Marriage-2019-06-11.tar.gz">
afp-Marriage-2019-06-11.tar.gz
</a>
</li>
<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,219 +1,224 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">M</font>ason–Stothers
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">
<p>This article provides a formalisation of Snyder’s simple and
elegant proof of the Mason&ndash;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.&thinsp;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&nbsp;&le;&nbsp;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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Mason_Stothers-2020-04-20.tar.gz">
+ afp-Mason_Stothers-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Mason_Stothers-2019-06-11.tar.gz">
afp-Mason_Stothers-2019-06-11.tar.gz
</a>
</li>
<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/Matrices_for_ODEs.html b/web/entries/Matrices_for_ODEs.html
--- a/web/entries/Matrices_for_ODEs.html
+++ b/web/entries/Matrices_for_ODEs.html
@@ -1,191 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Matrices for ODEs - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>atrices
for
<font class="first">O</font>DEs
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Matrices for ODEs</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Jonathan Julian Huerta y Munive (jjhuertaymunive1 /at/ sheffield /dot/ ac /dot/ uk)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-04-19</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Our theories formalise various matrix properties that serve to
establish existence, uniqueness and characterisation of the solution
to affine systems of ordinary differential equations (ODEs). In
particular, we formalise the operator and maximum norm of matrices.
Then we use them to prove that square matrices form a Banach space,
and in this setting, we show an instance of Picard-Lindelöf’s
theorem for affine systems of ODEs. Finally, we use this formalisation
to verify three simple hybrid programs.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Matrices_for_ODEs-AFP,
author = {Jonathan Julian Huerta y Munive},
title = {Matrices for ODEs},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/Matrices_for_ODEs.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Hybrid_Systems_VCs.html">Hybrid_Systems_VCs</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Matrices_for_ODEs/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Matrices_for_ODEs/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Matrices_for_ODEs/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Matrices_for_ODEs-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Matrices_for_ODEs-2020-05-09.tar.gz">
+ afp-Matrices_for_ODEs-2020-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/Matrix.html b/web/entries/Matrix.html
--- a/web/entries/Matrix.html
+++ b/web/entries/Matrix.html
@@ -1,288 +1,293 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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="Knuth_Bendix_Order.html">Knuth_Bendix_Order</a>, <a href="Matrix_Tensor.html">Matrix_Tensor</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Matrix-2020-04-20.tar.gz">
+ afp-Matrix-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Matrix-2019-06-11.tar.gz">
afp-Matrix-2019-06-11.tar.gz
</a>
</li>
<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,227 +1,232 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>ensor
<font class="first">P</font>roduct
of
<font class="first">M</font>atrices
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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="Isabelle_Marries_Dirac.html">Isabelle_Marries_Dirac</a>, <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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Matrix_Tensor-2020-04-20.tar.gz">
+ afp-Matrix_Tensor-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Matrix_Tensor-2019-06-11.tar.gz">
afp-Matrix_Tensor-2019-06-11.tar.gz
</a>
</li>
<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,198 +1,203 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>atroids
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Matroids-2020-04-20.tar.gz">
+ afp-Matroids-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Matroids-2019-06-11.tar.gz">
afp-Matroids-2019-06-11.tar.gz
</a>
</li>
<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,269 +1,274 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>aximum
<font class="first">C</font>ardinality
<font class="first">M</font>atching
</h1>
<p>&nbsp;</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 mathjax_process">
<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 &ge; 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 &ge; 0</i>, let <var>n(i)</var> be the number of nodes
labeled <i>i</i>. If <i>|M| = n(1) +
&sum;<sub>i &ge; 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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Max-Card-Matching-2020-04-20.tar.gz">
+ afp-Max-Card-Matching-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Max-Card-Matching-2019-06-11.tar.gz">
afp-Max-Card-Matching-2019-06-11.tar.gz
</a>
</li>
<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,207 +1,212 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Median_Of_Medians_Selection-2020-04-20.tar.gz">
+ afp-Median_Of_Medians_Selection-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Median_Of_Medians_Selection-2019-06-11.tar.gz">
afp-Median_Of_Medians_Selection-2019-06-11.tar.gz
</a>
</li>
<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,207 +1,212 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>enger's
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Menger-2020-04-20.tar.gz">
+ afp-Menger-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Menger-2019-06-11.tar.gz">
afp-Menger-2019-06-11.tar.gz
</a>
</li>
<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/Mersenne_Primes.html b/web/entries/Mersenne_Primes.html
--- a/web/entries/Mersenne_Primes.html
+++ b/web/entries/Mersenne_Primes.html
@@ -1,202 +1,207 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Mersenne primes and the Lucas–Lehmer test - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>ersenne
primes
and
the
<font class="first">L</font>ucas–Lehmer
test
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Mersenne primes and the Lucas–Lehmer test</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">2020-01-17</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>This article provides formal proofs of basic properties of
Mersenne numbers, i. e. numbers of the form
2<sup><em>n</em></sup> - 1, and especially of
Mersenne primes.</p> <p>In particular, an efficient,
verified, and executable version of the Lucas&ndash;Lehmer test is
developed. This test decides primality for Mersenne numbers in time
polynomial in <em>n</em>.</p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Mersenne_Primes-AFP,
author = {Manuel Eberl},
title = {Mersenne primes and the Lucas–Lehmer test},
journal = {Archive of Formal Proofs},
month = jan,
year = 2020,
note = {\url{https://isa-afp.org/entries/Mersenne_Primes.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Pell.html">Pell</a>, <a href="Probabilistic_Prime_Tests.html">Probabilistic_Prime_Tests</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Mersenne_Primes/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Mersenne_Primes/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Mersenne_Primes/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Mersenne_Primes-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Mersenne_Primes-2020-04-20.tar.gz">
+ afp-Mersenne_Primes-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Mersenne_Primes-2020-01-20.tar.gz">
afp-Mersenne_Primes-2020-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/MiniML.html b/web/entries/MiniML.html
--- a/web/entries/MiniML.html
+++ b/web/entries/MiniML.html
@@ -1,301 +1,311 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>ini
<font class="first">M</font>L
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-MiniML-2020-05-06.tar.gz">
+ afp-MiniML-2020-05-06.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2020:
+ <a href="../release/afp-MiniML-2020-04-20.tar.gz">
+ afp-MiniML-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-MiniML-2019-06-11.tar.gz">
afp-MiniML-2019-06-11.tar.gz
</a>
</li>
<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,226 +1,231 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Minimal_SSA-2020-04-20.tar.gz">
+ afp-Minimal_SSA-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Minimal_SSA-2019-06-11.tar.gz">
afp-Minimal_SSA-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>inkowski's
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">
<p>Minkowski's theorem relates a subset of
&#8477;<sup>n</sup>, the Lebesgue measure, and the
integer lattice &#8484;<sup>n</sup>: It states that
any convex subset of &#8477;<sup>n</sup> with volume
greater than 2<sup>n</sup> contains at least one lattice
point from &#8484;<sup>n</sup>\{0}, i.&thinsp;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
&#8477;<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Minkowskis_Theorem-2020-04-20.tar.gz">
+ afp-Minkowskis_Theorem-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Minkowskis_Theorem-2019-06-11.tar.gz">
afp-Minkowskis_Theorem-2019-06-11.tar.gz
</a>
</li>
<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,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>insky
<font class="first">M</font>achines
</h1>
<p>&nbsp;</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 (int-e /at/ gmx /dot/ de)
</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Minsky_Machines-2020-04-20.tar.gz">
+ afp-Minsky_Machines-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Minsky_Machines-2019-06-11.tar.gz">
afp-Minsky_Machines-2019-06-11.tar.gz
</a>
</li>
<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,239 +1,244 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Modal_Logics_for_NTS-2020-04-20.tar.gz">
+ afp-Modal_Logics_for_NTS-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Modal_Logics_for_NTS-2019-06-11.tar.gz">
afp-Modal_Logics_for_NTS-2019-06-11.tar.gz
</a>
</li>
<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,225 +1,230 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Modular_Assembly_Kit_Security-2020-04-20.tar.gz">
+ afp-Modular_Assembly_Kit_Security-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Modular_Assembly_Kit_Security-2019-06-11.tar.gz">
afp-Modular_Assembly_Kit_Security-2019-06-11.tar.gz
</a>
</li>
<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,217 +1,222 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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://home.in.tum.de/~wimmers/">Simon Wimmer</a>,
Shuwei Hu (shuwei /dot/ hu /at/ tum /dot/ de) and
<a href="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Monad_Memo_DP-2020-04-20.tar.gz">
+ afp-Monad_Memo_DP-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Monad_Memo_DP-2019-06-11.tar.gz">
afp-Monad_Memo_DP-2019-06-11.tar.gz
</a>
</li>
<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,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>onad
normalisation
</h1>
<p>&nbsp;</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,
<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 mathjax_process">
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{https://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>, <a href="Skip_Lists.html">Skip_Lists</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Monad_Normalisation-2020-04-20.tar.gz">
+ afp-Monad_Normalisation-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Monad_Normalisation-2019-06-11.tar.gz">
afp-Monad_Normalisation-2019-06-11.tar.gz
</a>
</li>
<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,253 +1,258 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-MonoBoolTranAlgebra-2020-04-20.tar.gz">
+ afp-MonoBoolTranAlgebra-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-MonoBoolTranAlgebra-2019-06-11.tar.gz">
afp-MonoBoolTranAlgebra-2019-06-11.tar.gz
</a>
</li>
<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,244 +1,249 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>onoidal
<font class="first">C</font>ategories
</h1>
<p>&nbsp;</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 mathjax_process">
<p>
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.
</p><p>
Revisions made subsequent to the first version of this article added
material on cartesian monoidal categories; showing that the underlying
category of a cartesian monoidal category is a cartesian category, and
that every cartesian category extends to a cartesian monoidal
category.
</p></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>
[2020-02-15]:
Cosmetic improvements.
(revision a51840d36867)<br>
[2020-07-10]:
Added new material on cartesian monoidal categories.
(revision 06640f317a79)<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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Bicategory.html">Bicategory</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-MonoidalCategory-2020-04-20.tar.gz">
+ afp-MonoidalCategory-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-MonoidalCategory-2019-06-11.tar.gz">
afp-MonoidalCategory-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">E</font>ffect
polymorphism
in
higher-order
logic
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Monomorphic_Monad-2020-04-20.tar.gz">
+ afp-Monomorphic_Monad-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Monomorphic_Monad-2019-06-11.tar.gz">
afp-Monomorphic_Monad-2019-06-11.tar.gz
</a>
</li>
<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,279 +1,284 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-MuchAdoAboutTwo-2020-04-20.tar.gz">
+ afp-MuchAdoAboutTwo-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-MuchAdoAboutTwo-2019-06-11.tar.gz">
afp-MuchAdoAboutTwo-2019-06-11.tar.gz
</a>
</li>
<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,205 +1,210 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">M</font>ulti-Party
<font class="first">C</font>omputation
</h1>
<p>&nbsp;</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
<a href="https://www.turing.ac.uk/people/doctoral-students/david-butler">David Butler</a>
</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Multi_Party_Computation-2020-04-20.tar.gz">
+ afp-Multi_Party_Computation-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Multi_Party_Computation-2019-06-11.tar.gz">
afp-Multi_Party_Computation-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">B</font>inary
<font class="first">M</font>ultirelations
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Multirelations-2020-04-20.tar.gz">
+ afp-Multirelations-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Multirelations-2019-06-11.tar.gz">
afp-Multirelations-2019-06-11.tar.gz
</a>
</li>
<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,267 +1,272 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Myhill-Nerode-2020-04-20.tar.gz">
+ afp-Myhill-Nerode-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Myhill-Nerode-2019-06-11.tar.gz">
afp-Myhill-Nerode-2019-06-11.tar.gz
</a>
</li>
<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,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Name_Carrying_Type_Inference-2020-04-20.tar.gz">
+ afp-Name_Carrying_Type_Inference-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Name_Carrying_Type_Inference-2019-06-11.tar.gz">
afp-Name_Carrying_Type_Inference-2019-06-11.tar.gz
</a>
</li>
<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/Nash_Williams.html b/web/entries/Nash_Williams.html
--- a/web/entries/Nash_Williams.html
+++ b/web/entries/Nash_Williams.html
@@ -1,191 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>The Nash-Williams 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">N</font>ash-Williams
<font class="first">P</font>artition
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">The Nash-Williams Partition Theorem</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">2020-05-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In 1965, Nash-Williams discovered a generalisation of the infinite
form of Ramsey's theorem. Where the latter concerns infinite sets
of n-element sets for some fixed n, the Nash-Williams theorem concerns
infinite sets of finite sets (or lists) subject to a “no initial
segment” condition. The present formalisation follows a
monograph on Ramsey Spaces by Todorčević.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Nash_Williams-AFP,
author = {Lawrence C. Paulson},
title = {The Nash-Williams Partition Theorem},
journal = {Archive of Formal Proofs},
month = may,
year = 2020,
note = {\url{https://isa-afp.org/entries/Nash_Williams.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Ordinal_Partitions.html">Ordinal_Partitions</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Nash_Williams/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Nash_Williams/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Nash_Williams/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Nash_Williams-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Nash_Williams-2020-06-02.tar.gz">
+ afp-Nash_Williams-2020-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/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,257 +1,262 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Nat-Interval-Logic-2020-04-20.tar.gz">
+ afp-Nat-Interval-Logic-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Nat-Interval-Logic-2019-06-11.tar.gz">
afp-Nat-Interval-Logic-2019-06-11.tar.gz
</a>
</li>
<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,253 +1,258 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">N</font>ative
<font class="first">W</font>ord
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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">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="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="Mersenne_Primes.html">Mersenne_Primes</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Native_Word-2020-04-20.tar.gz">
+ afp-Native_Word-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Native_Word-2019-06-11.tar.gz">
afp-Native_Word-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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),
<a href="http://fmv.jku.at/fleury">Mathias Fleury</a> and
<a href="https://traytel.bitbucket.io">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 mathjax_process">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{https://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="Lambda_Free_RPOs.html">Lambda_Free_RPOs</a>, <a href="Ordered_Resolution_Prover.html">Ordered_Resolution_Prover</a>, <a href="PAC_Checker.html">PAC_Checker</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Nested_Multisets_Ordinals-2020-04-20.tar.gz">
+ afp-Nested_Multisets_Ordinals-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Nested_Multisets_Ordinals-2019-06-11.tar.gz">
afp-Nested_Multisets_Ordinals-2019-06-11.tar.gz
</a>
</li>
<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,266 +1,271 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Network_Security_Policy_Verification-2020-04-20.tar.gz">
+ afp-Network_Security_Policy_Verification-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Network_Security_Policy_Verification-2019-06-11.tar.gz">
afp-Network_Security_Policy_Verification-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">V</font>on-Neumann-Morgenstern
<font class="first">U</font>tility
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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">
<a href="http://www.parsert.com/">Julian Parsert</a> and
<a href="http://cl-informatik.uibk.ac.at/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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Neumann_Morgenstern_Utility-2020-04-20.tar.gz">
+ afp-Neumann_Morgenstern_Utility-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Neumann_Morgenstern_Utility-2019-06-11.tar.gz">
afp-Neumann_Morgenstern_Utility-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">N</font>o
<font class="first">F</font>aster-Than-Light
<font class="first">O</font>bservers
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-No_FTL_observers-2020-04-20.tar.gz">
+ afp-No_FTL_observers-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-No_FTL_observers-2019-06-11.tar.gz">
afp-No_FTL_observers-2019-06-11.tar.gz
</a>
</li>
<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,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">N</font>ominal
<font class="first">2</font>
</h1>
<p>&nbsp;</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/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 mathjax_process">
<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{https://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="Goedel_HFSet_Semanticless.html">Goedel_HFSet_Semanticless</a>, <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>, <a href="Robinson_Arithmetic.html">Robinson_Arithmetic</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Nominal2-2020-04-20.tar.gz">
+ afp-Nominal2-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Nominal2-2019-06-11.tar.gz">
afp-Nominal2-2019-06-11.tar.gz
</a>
</li>
<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,258 +1,263 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Noninterference_CSP-2020-04-20.tar.gz">
+ afp-Noninterference_CSP-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Noninterference_CSP-2019-06-11.tar.gz">
afp-Noninterference_CSP-2019-06-11.tar.gz
</a>
</li>
<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,236 +1,241 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Noninterference_Concurrent_Composition-2020-04-20.tar.gz">
+ afp-Noninterference_Concurrent_Composition-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Noninterference_Concurrent_Composition-2019-06-11.tar.gz">
afp-Noninterference_Concurrent_Composition-2019-06-11.tar.gz
</a>
</li>
<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,256 +1,261 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Noninterference_Generic_Unwinding-2020-04-20.tar.gz">
+ afp-Noninterference_Generic_Unwinding-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Noninterference_Generic_Unwinding-2019-06-11.tar.gz">
afp-Noninterference_Generic_Unwinding-2019-06-11.tar.gz
</a>
</li>
<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,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Noninterference_Inductive_Unwinding-2020-04-20.tar.gz">
+ afp-Noninterference_Inductive_Unwinding-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Noninterference_Inductive_Unwinding-2019-06-11.tar.gz">
afp-Noninterference_Inductive_Unwinding-2019-06-11.tar.gz
</a>
</li>
<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,257 +1,262 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Noninterference_Ipurge_Unwinding-2020-04-20.tar.gz">
+ afp-Noninterference_Ipurge_Unwinding-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Noninterference_Ipurge_Unwinding-2019-06-11.tar.gz">
afp-Noninterference_Ipurge_Unwinding-2019-06-11.tar.gz
</a>
</li>
<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,237 +1,242 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Noninterference_Sequential_Composition-2020-04-20.tar.gz">
+ afp-Noninterference_Sequential_Composition-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Noninterference_Sequential_Composition-2019-06-11.tar.gz">
afp-Noninterference_Sequential_Composition-2019-06-11.tar.gz
</a>
</li>
<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,278 +1,283 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">N</font>ormalization
by
<font class="first">E</font>valuation
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-NormByEval-2020-04-20.tar.gz">
+ afp-NormByEval-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-NormByEval-2019-06-11.tar.gz">
afp-NormByEval-2019-06-11.tar.gz
</a>
</li>
<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
--- a/web/entries/Nullstellensatz.html
+++ b/web/entries/Nullstellensatz.html
@@ -1,199 +1,204 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">H</font>ilbert's
<font class="first">N</font>ullstellensatz
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Nullstellensatz-2020-04-20.tar.gz">
+ afp-Nullstellensatz-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Nullstellensatz-2019-06-17.tar.gz">
afp-Nullstellensatz-2019-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/Octonions.html b/web/entries/Octonions.html
--- a/web/entries/Octonions.html
+++ b/web/entries/Octonions.html
@@ -1,196 +1,201 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">O</font>ctonions
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Octonions-2020-04-20.tar.gz">
+ afp-Octonions-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Octonions-2019-06-11.tar.gz">
afp-Octonions-2019-06-11.tar.gz
</a>
</li>
<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,221 +1,226 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-OpSets-2020-04-20.tar.gz">
+ afp-OpSets-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-OpSets-2019-06-11.tar.gz">
afp-OpSets-2019-06-11.tar.gz
</a>
</li>
<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,240 +1,245 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">O</font>pen
<font class="first">I</font>nduction
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Open_Induction-2020-04-20.tar.gz">
+ afp-Open_Induction-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Open_Induction-2019-06-11.tar.gz">
afp-Open_Induction-2019-06-11.tar.gz
</a>
</li>
<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,227 +1,232 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">O</font>ptics
</h1>
<p>&nbsp;</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 mathjax_process">
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">Change history:</td>
<td class="abstract">[2020-03-02]:
Added partial bijective and symmetric lenses.
Improved alphabet command generating additional lenses and results.
Several additional lens relations, including observational equivalence.
Additional theorems throughout.
Adaptations for Isabelle 2020.
(revision 44e2e5c)
[2021-01-27]
Addition of new theorems throughout, particularly for prisms.
New "chantype" command allows the definition of an algebraic datatype with generated prisms.
New "dataspace" command allows the definition of a local-based state space, including lenses and prisms.
Addition of various examples for the above.
(revision 89cf045a)</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{https://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>
</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Optics-2020-04-20.tar.gz">
+ afp-Optics-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Optics-2019-06-11.tar.gz">
afp-Optics-2019-06-11.tar.gz
</a>
</li>
<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,208 +1,213 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Optimal_BST-2020-04-20.tar.gz">
+ afp-Optimal_BST-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Optimal_BST-2019-06-11.tar.gz">
afp-Optimal_BST-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Orbit_Stabiliser-2020-04-20.tar.gz">
+ afp-Orbit_Stabiliser-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Orbit_Stabiliser-2019-06-11.tar.gz">
afp-Orbit_Stabiliser-2019-06-11.tar.gz
</a>
</li>
<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,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>roperties
of
<font class="first">O</font>rderings
and
<font class="first">L</font>attices
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Order_Lattice_Props-2020-04-20.tar.gz">
+ afp-Order_Lattice_Props-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Order_Lattice_Props-2019-06-28.tar.gz">
afp-Order_Lattice_Props-2019-06-28.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Order_Lattice_Props-2019-06-11.tar.gz">
afp-Order_Lattice_Props-2019-06-11.tar.gz
</a>
</li>
<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,221 +1,226 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>,
Jasmin Christian Blanchette (j /dot/ c /dot/ blanchette /at/ vu /dot/ nl),
<a href="https://traytel.bitbucket.io">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 mathjax_process">
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{https://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="Chandy_Lamport.html">Chandy_Lamport</a>, <a href="Functional_Ordered_Resolution_Prover.html">Functional_Ordered_Resolution_Prover</a>, <a href="Saturation_Framework.html">Saturation_Framework</a>, <a href="Saturation_Framework_Extensions.html">Saturation_Framework_Extensions</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Ordered_Resolution_Prover-2020-04-20.tar.gz">
+ afp-Ordered_Resolution_Prover-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Ordered_Resolution_Prover-2019-06-11.tar.gz">
afp-Ordered_Resolution_Prover-2019-06-11.tar.gz
</a>
</li>
<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,277 +1,282 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">C</font>ountable
<font class="first">O</font>rdinals
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Ordinal-2020-04-20.tar.gz">
+ afp-Ordinal-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Ordinal-2019-06-11.tar.gz">
afp-Ordinal-2019-06-11.tar.gz
</a>
</li>
<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/Ordinal_Partitions.html b/web/entries/Ordinal_Partitions.html
--- a/web/entries/Ordinal_Partitions.html
+++ b/web/entries/Ordinal_Partitions.html
@@ -1,197 +1,203 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Ordinal 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">O</font>rdinal
<font class="first">P</font>artitions
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Ordinal Partitions</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">2020-08-03</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
The theory of partition relations concerns generalisations of
Ramsey's theorem. For any ordinal $\alpha$, write $\alpha \to
(\alpha, m)^2$ if for each function $f$ from unordered pairs of
elements of $\alpha$ into $\{0,1\}$, either there is a subset
$X\subseteq \alpha$ order-isomorphic to $\alpha$ such that
$f\{x,y\}=0$ for all $\{x,y\}\subseteq X$, or there is an $m$ element
set $Y\subseteq \alpha$ such that $f\{x,y\}=1$ for all
$\{x,y\}\subseteq Y$. (In both cases, with $\{x,y\}$ we require
$x\not=y$.) In particular, the infinite Ramsey theorem can be written
in this notation as $\omega \to (\omega, \omega)^2$, or if we
restrict $m$ to the positive integers as above, then $\omega \to
(\omega, m)^2$ for all $m$. This entry formalises Larson's proof
of $\omega^\omega \to (\omega^\omega, m)^2$ along with a similar proof
of a result due to Specker: $\omega^2 \to (\omega^2, m)^2$. Also
proved is a necessary result by Erdős and Milner:
$\omega^{1+\alpha\cdot n} \to (\omega^{1+\alpha}, 2^n)^2$.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Ordinal_Partitions-AFP,
author = {Lawrence C. Paulson},
title = {Ordinal Partitions},
journal = {Archive of Formal Proofs},
month = aug,
year = 2020,
note = {\url{https://isa-afp.org/entries/Ordinal_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="Nash_Williams.html">Nash_Williams</a>, <a href="ZFC_in_HOL.html">ZFC_in_HOL</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Ordinal_Partitions/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Ordinal_Partitions/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Ordinal_Partitions/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Ordinal_Partitions-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Ordinal_Partitions-2020-08-18.tar.gz">
+ afp-Ordinal_Partitions-2020-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/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,271 +1,276 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">O</font>rdinals
and
<font class="first">C</font>ardinals
</h1>
<p>&nbsp;</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">
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Ordinals_and_Cardinals-2020-04-20.tar.gz">
+ afp-Ordinals_and_Cardinals-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Ordinals_and_Cardinals-2019-06-11.tar.gz">
afp-Ordinals_and_Cardinals-2019-06-11.tar.gz
</a>
</li>
<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,268 +1,273 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">O</font>rdinary
<font class="first">D</font>ifferential
<font class="first">E</font>quations
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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="List-Index.html">List-Index</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>, <a href="Hybrid_Systems_VCs.html">Hybrid_Systems_VCs</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Ordinary_Differential_Equations-2020-04-20.tar.gz">
+ afp-Ordinary_Differential_Equations-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Ordinary_Differential_Equations-2019-06-11.tar.gz">
afp-Ordinary_Differential_Equations-2019-06-11.tar.gz
</a>
</li>
<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/PAC_Checker.html b/web/entries/PAC_Checker.html
--- a/web/entries/PAC_Checker.html
+++ b/web/entries/PAC_Checker.html
@@ -1,195 +1,201 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Practical Algebraic Calculus 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>ractical
<font class="first">A</font>lgebraic
<font class="first">C</font>alculus
<font class="first">C</font>hecker
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Practical Algebraic Calculus Checker</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://fmv.jku.at/fleury">Mathias Fleury</a> and
<a href="http://fmv.jku.at/kaufmann">Daniela Kaufmann</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-08-31</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Generating and checking proof certificates is important to increase
the trust in automated reasoning tools. In recent years formal
verification using computer algebra became more important and is
heavily used in automated circuit verification. An existing proof
format which covers algebraic reasoning and allows efficient proof
checking is the practical algebraic calculus (PAC). In this
development, we present the verified checker Pastèque that is obtained
by synthesis via the Refinement Framework. This is the formalization
going with our FMCAD'20 tool presentation.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{PAC_Checker-AFP,
author = {Mathias Fleury and Daniela Kaufmann},
title = {Practical Algebraic Calculus Checker},
journal = {Archive of Formal Proofs},
month = aug,
year = 2020,
note = {\url{https://isa-afp.org/entries/PAC_Checker.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Nested_Multisets_Ordinals.html">Nested_Multisets_Ordinals</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/PAC_Checker/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/PAC_Checker/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/PAC_Checker/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-PAC_Checker-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-PAC_Checker-2020-08-31.tar.gz">
+ afp-PAC_Checker-2020-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/PCF.html b/web/entries/PCF.html
--- a/web/entries/PCF.html
+++ b/web/entries/PCF.html
@@ -1,248 +1,253 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">L</font>ogical
<font class="first">R</font>elations
for
<font class="first">P</font>CF
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-PCF-2020-04-20.tar.gz">
+ afp-PCF-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-PCF-2019-06-11.tar.gz">
afp-PCF-2019-06-11.tar.gz
</a>
</li>
<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,253 +1,258 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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&uuml;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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-PLM-2020-04-20.tar.gz">
+ afp-PLM-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-PLM-2019-06-11.tar.gz">
afp-PLM-2019-06-11.tar.gz
</a>
</li>
<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,283 +1,288 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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>&lt;:</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>&lt;:</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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-POPLmark-deBruijn-2020-04-20.tar.gz">
+ afp-POPLmark-deBruijn-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-POPLmark-deBruijn-2019-06-11.tar.gz">
afp-POPLmark-deBruijn-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-PSemigroupsConvolution-2020-04-20.tar.gz">
+ afp-PSemigroupsConvolution-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-PSemigroupsConvolution-2019-06-11.tar.gz">
afp-PSemigroupsConvolution-2019-06-11.tar.gz
</a>
</li>
<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,214 +1,219 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>airing
<font class="first">H</font>eap
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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>, <a href="CakeML_Codegen.html">CakeML_Codegen</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Pairing_Heap-2020-04-20.tar.gz">
+ afp-Pairing_Heap-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Pairing_Heap-2019-06-11.tar.gz">
afp-Pairing_Heap-2019-06-11.tar.gz
</a>
</li>
<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,219 +1,224 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>araconsistency
</h1>
<p>&nbsp;</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">
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a> 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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Paraconsistency-2020-04-20.tar.gz">
+ afp-Paraconsistency-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Paraconsistency-2019-06-11.tar.gz">
afp-Paraconsistency-2019-06-11.tar.gz
</a>
</li>
<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,221 +1,226 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Parity_Game-2020-04-20.tar.gz">
+ afp-Parity_Game-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Parity_Game-2019-06-11.tar.gz">
afp-Parity_Game-2019-06-11.tar.gz
</a>
</li>
<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,226 +1,231 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Partial_Function_MR-2020-04-20.tar.gz">
+ afp-Partial_Function_MR-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Partial_Function_MR-2019-06-11.tar.gz">
afp-Partial_Function_MR-2019-06-11.tar.gz
</a>
</li>
<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,200 +1,205 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>artial
<font class="first">O</font>rder
<font class="first">R</font>eduction
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Partial_Order_Reduction-2020-04-20.tar.gz">
+ afp-Partial_Order_Reduction-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Partial_Order_Reduction-2019-06-11.tar.gz">
afp-Partial_Order_Reduction-2019-06-11.tar.gz
</a>
</li>
<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,233 +1,238 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Password_Authentication_Protocol-2020-04-20.tar.gz">
+ afp-Password_Authentication_Protocol-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Password_Authentication_Protocol-2019-06-11.tar.gz">
afp-Password_Authentication_Protocol-2019-06-11.tar.gz
</a>
</li>
<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,225 +1,230 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>ell's
<font class="first">E</font>quation
</h1>
<p>&nbsp;</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 mathjax_process">
<p> This article gives the basic theory of Pell's equation
<em>x</em><sup>2</sup> = 1 +
<em>D</em>&thinsp;<em>y</em><sup>2</sup>,
where
<em>D</em>&thinsp;&isin;&thinsp;&#8469; 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>&thinsp;&isin;&thinsp;&#8469;
such that |<em>x</em>| +
|<em>y</em>|&thinsp;&radic;<span
style="text-decoration:
overline"><em>D</em></span> =
(<em>x</em><sub>0</sub> +
<em>y</em><sub>0</sub>&thinsp;&radic;<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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Mersenne_Primes.html">Mersenne_Primes</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Pell-2020-04-20.tar.gz">
+ afp-Pell-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Pell-2019-06-11.tar.gz">
afp-Pell-2019-06-11.tar.gz
</a>
</li>
<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,262 +1,267 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>erfect
<font class="first">N</font>umber
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Perfect-Number-Thm-2020-04-20.tar.gz">
+ afp-Perfect-Number-Thm-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Perfect-Number-Thm-2019-06-11.tar.gz">
afp-Perfect-Number-Thm-2019-06-11.tar.gz
</a>
</li>
<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,252 +1,257 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://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
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</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 mathjax_process">
<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&ndash;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&ndash;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{https://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="Smith_Normal_Form.html">Smith_Normal_Form</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Perron_Frobenius-2020-04-20.tar.gz">
+ afp-Perron_Frobenius-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Perron_Frobenius-2019-06-11.tar.gz">
afp-Perron_Frobenius-2019-06-11.tar.gz
</a>
</li>
<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/Physical_Quantities.html b/web/entries/Physical_Quantities.html
--- a/web/entries/Physical_Quantities.html
+++ b/web/entries/Physical_Quantities.html
@@ -1,209 +1,215 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Sound Type System for Physical Quantities, Units, and Measurements - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">S</font>ound
<font class="first">T</font>ype
<font class="first">S</font>ystem
for
<font class="first">P</font>hysical
<font class="first">Q</font>uantities,
<font class="first">U</font>nits,
and
<font class="first">M</font>easurements
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Sound Type System for Physical Quantities, Units, and Measurements</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="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-10-20</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
The present Isabelle theory builds a formal model for both the
International System of Quantities (ISQ) and the International System
of Units (SI), which are both fundamental for physics and engineering.
Both the ISQ and the SI are deeply integrated into Isabelle's
type system. Quantities are parameterised by dimension types, which
correspond to base vectors, and thus only quantities of the same
dimension can be equated. Since the underlying "algebra of
quantities" induces congruences on quantity and SI types,
specific tactic support is developed to capture these. Our
construction is validated by a test-set of known equivalences between
both quantities and SI units. Moreover, the presented theory can be
used for type-safe conversions between the SI system and others, like
the British Imperial System (BIS).</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Physical_Quantities-AFP,
author = {Simon Foster and Burkhart Wolff},
title = {A Sound Type System for Physical Quantities, Units, and Measurements},
journal = {Archive of Formal Proofs},
month = oct,
year = 2020,
note = {\url{https://isa-afp.org/entries/Physical_Quantities.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Physical_Quantities/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Physical_Quantities/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Physical_Quantities/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Physical_Quantities-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Physical_Quantities-2020-10-28.tar.gz">
+ afp-Physical_Quantities-2020-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/Pi_Calculus.html b/web/entries/Pi_Calculus.html
--- a/web/entries/Pi_Calculus.html
+++ b/web/entries/Pi_Calculus.html
@@ -1,245 +1,250 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
pi-calculus
in
nominal
logic
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Pi_Calculus-2020-04-20.tar.gz">
+ afp-Pi_Calculus-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Pi_Calculus-2019-06-11.tar.gz">
afp-Pi_Calculus-2019-06-11.tar.gz
</a>
</li>
<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,202 +1,207 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">T</font>ranscendence
of
π
</h1>
<p>&nbsp;</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 mathjax_process">
<p>This entry shows the transcendence of &pi; 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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Pi_Transcendental-2020-04-20.tar.gz">
+ afp-Pi_Transcendental-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Pi_Transcendental-2019-06-11.tar.gz">
afp-Pi_Transcendental-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>lanarity
<font class="first">C</font>ertificates
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Planarity_Certificates-2020-04-20.tar.gz">
+ afp-Planarity_Certificates-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Planarity_Certificates-2019-06-11.tar.gz">
afp-Planarity_Certificates-2019-06-11.tar.gz
</a>
</li>
<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/Poincare_Bendixson.html b/web/entries/Poincare_Bendixson.html
--- a/web/entries/Poincare_Bendixson.html
+++ b/web/entries/Poincare_Bendixson.html
@@ -1,199 +1,204 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>The Poincaré-Bendixson 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">P</font>oincaré-Bendixson
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">The Poincaré-Bendixson Theorem</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://www.cs.cmu.edu/~yongkiat/">Yong Kiam Tan</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-12-18</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
The Poincaré-Bendixson theorem is a classical result in the study of
(continuous) dynamical systems. Colloquially, it restricts the
possible behaviors of planar dynamical systems: such systems cannot be
chaotic. In practice, it is a useful tool for proving the existence of
(limiting) periodic behavior in planar systems. The theorem is an
interesting and challenging benchmark for formalized mathematics
because proofs in the literature rely on geometric sketches and only
hint at symmetric cases. It also requires a substantial background of
mathematical theories, e.g., the Jordan curve theorem, real analysis,
ordinary differential equations, and limiting (long-term) behavior of
dynamical systems.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Poincare_Bendixson-AFP,
author = {Fabian Immler and Yong Kiam Tan},
title = {The Poincaré-Bendixson Theorem},
journal = {Archive of Formal Proofs},
month = dec,
year = 2019,
note = {\url{https://isa-afp.org/entries/Poincare_Bendixson.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Poincare_Bendixson/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Poincare_Bendixson/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Poincare_Bendixson/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Poincare_Bendixson-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Poincare_Bendixson-2020-04-20.tar.gz">
+ afp-Poincare_Bendixson-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Poincare_Bendixson-2019-12-18.tar.gz">
afp-Poincare_Bendixson-2019-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/Poincare_Disc.html b/web/entries/Poincare_Disc.html
--- a/web/entries/Poincare_Disc.html
+++ b/web/entries/Poincare_Disc.html
@@ -1,201 +1,206 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Poincaré Disc 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>oincaré
<font class="first">D</font>isc
<font class="first">M</font>odel
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Poincaré Disc Model</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://poincare.matf.bg.ac.rs/~danijela">Danijela Simić</a>,
Filip Marić (filip /at/ matf /dot/ bg /dot/ ac /dot/ rs) and
Pierre Boutry (boutry /at/ unistra /dot/ fr)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-12-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We describe formalization of the Poincaré disc model of hyperbolic
geometry within the Isabelle/HOL proof assistant. The model is defined
within the extended complex plane (one dimensional complex projectives
space &#8450;P1), formalized in the AFP entry “Complex Geometry”.
Points, lines, congruence of pairs of points, betweenness of triples
of points, circles, and isometries are defined within the model. It is
shown that the model satisfies all Tarski's axioms except the
Euclid's axiom. It is shown that it satisfies its negation and
the limiting parallels axiom (which proves it to be a model of
hyperbolic geometry).</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Poincare_Disc-AFP,
author = {Danijela Simić and Filip Marić and Pierre Boutry},
title = {Poincaré Disc Model},
journal = {Archive of Formal Proofs},
month = dec,
year = 2019,
note = {\url{https://isa-afp.org/entries/Poincare_Disc.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Complex_Geometry.html">Complex_Geometry</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Poincare_Disc/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Poincare_Disc/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Poincare_Disc/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Poincare_Disc-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Poincare_Disc-2020-04-20.tar.gz">
+ afp-Poincare_Disc-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Poincare_Disc-2020-01-17.tar.gz">
afp-Poincare_Disc-2020-01-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/Polynomial_Factorization.html b/web/entries/Polynomial_Factorization.html
--- a/web/entries/Polynomial_Factorization.html
+++ b/web/entries/Polynomial_Factorization.html
@@ -1,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>olynomial
<font class="first">F</font>actorization
</h1>
<p>&nbsp;</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
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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 mathjax_process">
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{https://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="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> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Amicable_Numbers.html">Amicable_Numbers</a>, <a href="Dirichlet_Series.html">Dirichlet_Series</a>, <a href="Functional_Ordered_Resolution_Prover.html">Functional_Ordered_Resolution_Prover</a>, <a href="Gaussian_Integers.html">Gaussian_Integers</a>, <a href="Jordan_Normal_Form.html">Jordan_Normal_Form</a>, <a href="Knuth_Bendix_Order.html">Knuth_Bendix_Order</a>, <a href="Linear_Recurrences.html">Linear_Recurrences</a>, <a href="Perron_Frobenius.html">Perron_Frobenius</a>, <a href="Power_Sum_Polynomials.html">Power_Sum_Polynomials</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Polynomial_Factorization-2020-04-20.tar.gz">
+ afp-Polynomial_Factorization-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Polynomial_Factorization-2019-06-11.tar.gz">
afp-Polynomial_Factorization-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>olynomial
<font class="first">I</font>nterpolation
</h1>
<p>&nbsp;</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
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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 mathjax_process">
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{https://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="Deep_Learning.html">Deep_Learning</a>, <a href="Gauss_Sums.html">Gauss_Sums</a>, <a href="Polynomial_Factorization.html">Polynomial_Factorization</a> </td></tr>
+ <td class="data"><a href="Deep_Learning.html">Deep_Learning</a>, <a href="Formal_Puiseux_Series.html">Formal_Puiseux_Series</a>, <a href="Gauss_Sums.html">Gauss_Sums</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Polynomial_Interpolation-2020-04-20.tar.gz">
+ afp-Polynomial_Interpolation-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Polynomial_Interpolation-2019-06-11.tar.gz">
afp-Polynomial_Interpolation-2019-06-11.tar.gz
</a>
</li>
<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,296 +1,301 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">E</font>xecutable
<font class="first">M</font>ultivariate
<font class="first">P</font>olynomials
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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="PAC_Checker.html">PAC_Checker</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Polynomials-2020-04-20.tar.gz">
+ afp-Polynomials-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Polynomials-2020-01-14.tar.gz">
afp-Polynomials-2020-01-14.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Polynomials-2019-06-11.tar.gz">
afp-Polynomials-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>op-Refinement
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Pop_Refinement-2020-04-20.tar.gz">
+ afp-Pop_Refinement-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Pop_Refinement-2019-06-11.tar.gz">
afp-Pop_Refinement-2019-06-11.tar.gz
</a>
</li>
<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,230 +1,235 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Posix-Lexing-2020-04-20.tar.gz">
+ afp-Posix-Lexing-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Posix-Lexing-2019-06-11.tar.gz">
afp-Posix-Lexing-2019-06-11.tar.gz
</a>
</li>
<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,244 +1,249 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>ossibilistic
<font class="first">N</font>oninterference
</h1>
<p>&nbsp;</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">
<a href="https://www.andreipopescu.uk">Andrei Popescu</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-09-10</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Possibilistic_Noninterference-2020-04-20.tar.gz">
+ afp-Possibilistic_Noninterference-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Possibilistic_Noninterference-2019-06-11.tar.gz">
afp-Possibilistic_Noninterference-2019-06-11.tar.gz
</a>
</li>
<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/Power_Sum_Polynomials.html b/web/entries/Power_Sum_Polynomials.html
--- a/web/entries/Power_Sum_Polynomials.html
+++ b/web/entries/Power_Sum_Polynomials.html
@@ -1,222 +1,228 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Power Sum 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>ower
<font class="first">S</font>um
<font class="first">P</font>olynomials
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Power Sum 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">2020-04-24</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>This article provides a formalisation of the symmetric
multivariate polynomials known as <em>power sum
polynomials</em>. These are of the form
p<sub>n</sub>(<em>X</em><sub>1</sub>,&hellip;,
<em>X</em><sub><em>k</em></sub>) =
<em>X</em><sub>1</sub><sup>n</sup>
+ &hellip; +
X<sub><em>k</em></sub><sup>n</sup>.
A formal proof of the Girard–Newton Theorem is also given. This
theorem relates the power sum polynomials to the elementary symmetric
polynomials s<sub><em>k</em></sub> in the form
of a recurrence relation
(-1)<sup><em>k</em></sup>
<em>k</em> s<sub><em>k</em></sub>
=
&sum;<sub>i&isinv;[0,<em>k</em>)</sub>
(-1)<sup>i</sup> s<sub>i</sub>
p<sub><em>k</em>-<em>i</em></sub>&thinsp;.</p>
<p>As an application, this is then used to solve a generalised
form of a puzzle given as an exercise in Dummit and Foote's
<em>Abstract Algebra</em>: For <em>k</em>
complex unknowns <em>x</em><sub>1</sub>,
&hellip;,
<em>x</em><sub><em>k</em></sub>,
define p<sub><em>j</em></sub> :=
<em>x</em><sub>1</sub><sup><em>j</em></sup>
+ &hellip; +
<em>x</em><sub><em>k</em></sub><sup><em>j</em></sup>.
Then for each vector <em>a</em> &isinv;
&#x2102;<sup><em>k</em></sup>, show that
there is exactly one solution to the system p<sub>1</sub>
= a<sub>1</sub>, &hellip;,
p<sub><em>k</em></sub> =
a<sub><em>k</em></sub> up to permutation of
the
<em>x</em><sub><em>i</em></sub>
and determine the value of
p<sub><em>i</em></sub> for
i&gt;k.</p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Power_Sum_Polynomials-AFP,
author = {Manuel Eberl},
title = {Power Sum Polynomials},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/Power_Sum_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="Polynomial_Factorization.html">Polynomial_Factorization</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/Power_Sum_Polynomials/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Power_Sum_Polynomials/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Power_Sum_Polynomials/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Power_Sum_Polynomials-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Power_Sum_Polynomials-2020-04-30.tar.gz">
+ afp-Power_Sum_Polynomials-2020-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/Pratt_Certificate.html b/web/entries/Pratt_Certificate.html
--- a/web/entries/Pratt_Certificate.html
+++ b/web/entries/Pratt_Certificate.html
@@ -1,237 +1,242 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>ratt's
<font class="first">P</font>rimality
<font class="first">C</font>ertificates
</h1>
<p>&nbsp;</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://home.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 mathjax_process">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{https://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="Amicable_Numbers.html">Amicable_Numbers</a>, <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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Pratt_Certificate-2020-04-20.tar.gz">
+ afp-Pratt_Certificate-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Pratt_Certificate-2019-06-11.tar.gz">
afp-Pratt_Certificate-2019-06-11.tar.gz
</a>
</li>
<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,265 +1,270 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalizing
the
<font class="first">L</font>ogic-Automaton
<font class="first">C</font>onnection
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Presburger-Automata-2020-04-20.tar.gz">
+ afp-Presburger-Automata-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Presburger-Automata-2019-06-11.tar.gz">
afp-Presburger-Automata-2019-06-11.tar.gz
</a>
</li>
<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/Prim_Dijkstra_Simple.html b/web/entries/Prim_Dijkstra_Simple.html
--- a/web/entries/Prim_Dijkstra_Simple.html
+++ b/web/entries/Prim_Dijkstra_Simple.html
@@ -1,210 +1,215 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Purely Functional, Simple, and Efficient Implementation of Prim and Dijkstra - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>urely
<font class="first">F</font>unctional,
<font class="first">S</font>imple,
and
<font class="first">E</font>fficient
<font class="first">I</font>mplementation
of
<font class="first">P</font>rim
and
<font class="first">D</font>ijkstra
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Purely Functional, Simple, and Efficient Implementation of Prim and Dijkstra</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Peter Lammich and
<a href="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-06-25</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We verify purely functional, simple and efficient implementations of
Prim's and Dijkstra's algorithms. This constitutes the first
verification of an executable and even efficient version of
Prim's algorithm. This entry formalizes the second part of our
ITP-2019 proof pearl <em>Purely Functional, Simple and Efficient
Priority Search Trees and Applications to Prim and Dijkstra</em>.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Prim_Dijkstra_Simple-AFP,
author = {Peter Lammich and Tobias Nipkow},
title = {Purely Functional, Simple, and Efficient Implementation of Prim and Dijkstra},
journal = {Archive of Formal Proofs},
month = jun,
year = 2019,
note = {\url{https://isa-afp.org/entries/Prim_Dijkstra_Simple.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Priority_Search_Trees.html">Priority_Search_Trees</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Prim_Dijkstra_Simple/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Prim_Dijkstra_Simple/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Prim_Dijkstra_Simple/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Prim_Dijkstra_Simple-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Prim_Dijkstra_Simple-2020-04-20.tar.gz">
+ afp-Prim_Dijkstra_Simple-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Prim_Dijkstra_Simple-2019-06-29.tar.gz">
afp-Prim_Dijkstra_Simple-2019-06-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/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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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></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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="IMO2019.html">IMO2019</a>, <a href="Irrational_Series_Erdos_Straus.html">Irrational_Series_Erdos_Straus</a>, <a href="Zeta_3_Irrational.html">Zeta_3_Irrational</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Prime_Distribution_Elementary-2020-04-20.tar.gz">
+ afp-Prime_Distribution_Elementary-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Prime_Distribution_Elementary-2019-06-11.tar.gz">
afp-Prime_Distribution_Elementary-2019-06-11.tar.gz
</a>
</li>
<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,233 +1,238 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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&thinsp;prime]&thinsp;·&thinsp;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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Prime_Harmonic_Series-2020-04-20.tar.gz">
+ afp-Prime_Harmonic_Series-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Prime_Harmonic_Series-2019-06-11.tar.gz">
afp-Prime_Harmonic_Series-2019-06-11.tar.gz
</a>
</li>
<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,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<p>This article provides a short proof of the Prime Number
Theorem in several equivalent forms, most notably
&pi;(<em>x</em>) ~ <em>x</em>/ln
<em>x</em> where &pi;(<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 &psi; and the
&ldquo;<em>n</em>-th prime number&rdquo; 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.&thinsp;e.
&sum;<sub><em>p</em>&le;<em>x</em></sub>
ln <em>p</em>/<em>p</em> = ln
<em>x</em> + <em>O</em>(1) and
&sum;<sub><em>p</em>&le;<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
&sum;<sub><em>p</em>&le;<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{https://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="Irrational_Series_Erdos_Straus.html">Irrational_Series_Erdos_Straus</a>, <a href="Prime_Distribution_Elementary.html">Prime_Distribution_Elementary</a>, <a href="Transcendence_Series_Hancl_Rucki.html">Transcendence_Series_Hancl_Rucki</a>, <a href="Zeta_3_Irrational.html">Zeta_3_Irrational</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Prime_Number_Theorem-2020-04-20.tar.gz">
+ afp-Prime_Number_Theorem-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Prime_Number_Theorem-2019-06-11.tar.gz">
afp-Prime_Number_Theorem-2019-06-11.tar.gz
</a>
</li>
<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,230 +1,235 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.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 mathjax_process">
This entry verifies priority queues based on Braun trees. Insertion
and deletion take logarithmic time and preserve the balanced nature
of Braun trees. Two implementations of deletion are provided.</td>
</tr>
<tr>
<td class="datahead" valign="top">Change history:</td>
<td class="abstract">[2019-12-16]: Added theory Priority_Queue_Braun2 with second version of del_min</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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Priority_Queue_Braun-2020-04-20.tar.gz">
+ afp-Priority_Queue_Braun-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Priority_Queue_Braun-2019-06-11.tar.gz">
afp-Priority_Queue_Braun-2019-06-11.tar.gz
</a>
</li>
<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/Priority_Search_Trees.html b/web/entries/Priority_Search_Trees.html
--- a/web/entries/Priority_Search_Trees.html
+++ b/web/entries/Priority_Search_Trees.html
@@ -1,200 +1,205 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Priority 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>riority
<font class="first">S</font>earch
<font class="first">T</font>rees
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Priority Search Trees</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Peter Lammich and
<a href="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-06-25</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We present a new, purely functional, simple and efficient data
structure combining a search tree and a priority queue, which we call
a <em>priority search tree</em>. The salient feature of priority search
trees is that they offer a decrease-key operation, something that is
missing from other simple, purely functional priority queue
implementations. Priority search trees can be implemented on top of
any search tree. This entry does the implementation for red-black
trees. This entry formalizes the first part of our ITP-2019 proof
pearl <em>Purely Functional, Simple and Efficient Priority
Search Trees and Applications to Prim and Dijkstra</em>.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Priority_Search_Trees-AFP,
author = {Peter Lammich and Tobias Nipkow},
title = {Priority Search Trees},
journal = {Archive of Formal Proofs},
month = jun,
year = 2019,
note = {\url{https://isa-afp.org/entries/Priority_Search_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="Prim_Dijkstra_Simple.html">Prim_Dijkstra_Simple</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Priority_Search_Trees/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Priority_Search_Trees/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Priority_Search_Trees/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Priority_Search_Trees-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Priority_Search_Trees-2020-04-20.tar.gz">
+ afp-Priority_Search_Trees-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Priority_Search_Trees-2019-06-29.tar.gz">
afp-Priority_Search_Trees-2019-06-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/Probabilistic_Noninterference.html b/web/entries/Probabilistic_Noninterference.html
--- a/web/entries/Probabilistic_Noninterference.html
+++ b/web/entries/Probabilistic_Noninterference.html
@@ -1,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>robabilistic
<font class="first">N</font>oninterference
</h1>
<p>&nbsp;</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">
<a href="https://www.andreipopescu.uk">Andrei Popescu</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">2014-03-11</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Probabilistic_Noninterference-2020-04-20.tar.gz">
+ afp-Probabilistic_Noninterference-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Probabilistic_Noninterference-2019-06-11.tar.gz">
afp-Probabilistic_Noninterference-2019-06-11.tar.gz
</a>
</li>
<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,206 +1,211 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>robabilistic
<font class="first">P</font>rimality
<font class="first">T</font>esting
</h1>
<p>&nbsp;</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 mathjax_process">
<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></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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Mersenne_Primes.html">Mersenne_Primes</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Probabilistic_Prime_Tests-2020-04-20.tar.gz">
+ afp-Probabilistic_Prime_Tests-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Probabilistic_Prime_Tests-2019-06-11.tar.gz">
afp-Probabilistic_Prime_Tests-2019-06-11.tar.gz
</a>
</li>
<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,226 +1,231 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://traytel.bitbucket.io">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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Probabilistic_System_Zoo-2020-04-20.tar.gz">
+ afp-Probabilistic_System_Zoo-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Probabilistic_System_Zoo-2019-06-11.tar.gz">
afp-Probabilistic_System_Zoo-2019-06-11.tar.gz
</a>
</li>
<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,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>robabilistic
<font class="first">T</font>imed
<font class="first">A</font>utomata
</h1>
<p>&nbsp;</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://home.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Probabilistic_Timed_Automata-2020-04-20.tar.gz">
+ afp-Probabilistic_Timed_Automata-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Probabilistic_Timed_Automata-2019-06-11.tar.gz">
afp-Probabilistic_Timed_Automata-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>robabilistic
while
loop
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Probabilistic_While-2020-04-20.tar.gz">
+ afp-Probabilistic_While-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Probabilistic_While-2019-06-11.tar.gz">
afp-Probabilistic_While-2019-06-11.tar.gz
</a>
</li>
<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,298 +1,303 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Peter Lammich 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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Program-Conflict-Analysis-2020-04-20.tar.gz">
+ afp-Program-Conflict-Analysis-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Program-Conflict-Analysis-2019-06-11.tar.gz">
afp-Program-Conflict-Analysis-2019-06-11.tar.gz
</a>
</li>
<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,203 +1,208 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>rojective
<font class="first">G</font>eometry
</h1>
<p>&nbsp;</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">
Anthony Bordg (apdb3 /at/ cam /dot/ ac /dot/ uk)
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Projective_Geometry-2020-04-20.tar.gz">
+ afp-Projective_Geometry-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Projective_Geometry-2019-06-11.tar.gz">
afp-Projective_Geometry-2019-06-11.tar.gz
</a>
</li>
<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,232 +1,237 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>romela
<font class="first">F</font>ormalization
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Promela-2020-04-20.tar.gz">
+ afp-Promela-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Promela-2019-06-11.tar.gz">
afp-Promela-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>roof
<font class="first">S</font>trategy
<font class="first">L</font>anguage
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Proof_Strategy_Language-2020-04-20.tar.gz">
+ afp-Proof_Strategy_Language-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Proof_Strategy_Language-2019-06-11.tar.gz">
afp-Proof_Strategy_Language-2019-06-11.tar.gz
</a>
</li>
<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,240 +1,245 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-PropResPI-2020-04-20.tar.gz">
+ afp-PropResPI-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-PropResPI-2019-06-11.tar.gz">
afp-PropResPI-2019-06-11.tar.gz
</a>
</li>
<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,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>ropositional
<font class="first">P</font>roof
<font class="first">S</font>ystems
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="AI_Planning_Languages_Semantics.html">AI_Planning_Languages_Semantics</a>, <a href="Verified_SAT_Based_AI_Planning.html">Verified_SAT_Based_AI_Planning</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Propositional_Proof_Systems-2020-04-20.tar.gz">
+ afp-Propositional_Proof_Systems-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Propositional_Proof_Systems-2019-06-11.tar.gz">
afp-Propositional_Proof_Systems-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalizing
<font class="first">P</font>ush-Relabel
<font class="first">A</font>lgorithms
</h1>
<p>&nbsp;</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">
Peter Lammich 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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Prpu_Maxflow-2020-04-20.tar.gz">
+ afp-Prpu_Maxflow-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Prpu_Maxflow-2020-01-14.tar.gz">
afp-Prpu_Maxflow-2020-01-14.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Prpu_Maxflow-2019-06-11.tar.gz">
afp-Prpu_Maxflow-2019-06-11.tar.gz
</a>
</li>
<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,249 +1,254 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>seudo
<font class="first">H</font>oops
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-PseudoHoops-2020-04-20.tar.gz">
+ afp-PseudoHoops-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-PseudoHoops-2019-06-11.tar.gz">
afp-PseudoHoops-2019-06-11.tar.gz
</a>
</li>
<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,243 +1,248 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>si-calculi
in
<font class="first">I</font>sabelle
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Psi_Calculi-2020-04-20.tar.gz">
+ afp-Psi_Calculi-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Psi_Calculi-2019-06-11.tar.gz">
afp-Psi_Calculi-2019-06-11.tar.gz
</a>
</li>
<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,210 +1,215 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">P</font>tolemy's
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Ptolemys_Theorem-2020-04-20.tar.gz">
+ afp-Ptolemys_Theorem-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Ptolemys_Theorem-2019-06-11.tar.gz">
afp-Ptolemys_Theorem-2019-06-11.tar.gz
</a>
</li>
<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,207 +1,212 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">Q</font>uantum
<font class="first">H</font>oare
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-QHLProver-2020-04-20.tar.gz">
+ afp-QHLProver-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-QHLProver-2019-06-11.tar.gz">
afp-QHLProver-2019-06-11.tar.gz
</a>
</li>
<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,222 +1,227 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">Q</font>R
<font class="first">D</font>ecomposition
</h1>
<p>&nbsp;</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="https://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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-QR_Decomposition-2020-04-20.tar.gz">
+ afp-QR_Decomposition-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-QR_Decomposition-2019-06-11.tar.gz">
afp-QR_Decomposition-2019-06-11.tar.gz
</a>
</li>
<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,195 +1,200 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">Q</font>uantales
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Quantales-2020-04-20.tar.gz">
+ afp-Quantales-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Quantales-2019-06-11.tar.gz">
afp-Quantales-2019-06-11.tar.gz
</a>
</li>
<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,197 +1,202 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">Q</font>uaternions
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Quaternions-2020-04-20.tar.gz">
+ afp-Quaternions-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Quaternions-2019-06-11.tar.gz">
afp-Quaternions-2019-06-11.tar.gz
</a>
</li>
<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,221 +1,226 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
number
of
comparisons
in
<font class="first">Q</font>uickSort
</h1>
<p>&nbsp;</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 mathjax_process">
<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.&thinsp;e.&nbsp;QuickSort with random pivot choice) is
<em>2&thinsp;(n+1)&thinsp;H<sub>n</sub> -
4&thinsp;n</em>, which is asymptotically equivalent to
<em>2&thinsp;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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Quick_Sort_Cost-2020-04-20.tar.gz">
+ afp-Quick_Sort_Cost-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Quick_Sort_Cost-2019-06-11.tar.gz">
afp-Quick_Sort_Cost-2019-06-11.tar.gz
</a>
</li>
<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,252 +1,257 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>IPEMD-160
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-RIPEMD-160-SPARK-2020-04-20.tar.gz">
+ afp-RIPEMD-160-SPARK-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-RIPEMD-160-SPARK-2019-06-11.tar.gz">
afp-RIPEMD-160-SPARK-2019-06-11.tar.gz
</a>
</li>
<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,227 +1,232 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Maximilian Haslbeck</a>,
Peter Lammich 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 mathjax_process">
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{https://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> </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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-ROBDD-2020-04-20.tar.gz">
+ afp-ROBDD-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-ROBDD-2019-06-11.tar.gz">
afp-ROBDD-2019-06-11.tar.gz
</a>
</li>
<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,287 +1,292 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>HA1,
<font class="first">R</font>SA,
<font class="first">P</font>SS
and
more
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-RSAPSS-2020-04-20.tar.gz">
+ afp-RSAPSS-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-RSAPSS-2019-06-11.tar.gz">
afp-RSAPSS-2019-06-11.tar.gz
</a>
</li>
<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,289 +1,294 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>amsey's
theorem,
infinitary
version
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Ramsey-Infinite-2020-04-20.tar.gz">
+ afp-Ramsey-Infinite-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Ramsey-Infinite-2019-06-11.tar.gz">
afp-Ramsey-Infinite-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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.&thinsp;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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Random_BSTs-2020-04-20.tar.gz">
+ afp-Random_BSTs-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Random_BSTs-2019-06-11.tar.gz">
afp-Random_BSTs-2019-06-11.tar.gz
</a>
</li>
<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,232 +1,237 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Random_Graph_Subgraph_Threshold-2020-04-20.tar.gz">
+ afp-Random_Graph_Subgraph_Threshold-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Random_Graph_Subgraph_Threshold-2019-06-11.tar.gz">
afp-Random_Graph_Subgraph_Threshold-2019-06-11.tar.gz
</a>
</li>
<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,203 +1,208 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Randomised_BSTs-2020-04-20.tar.gz">
+ afp-Randomised_BSTs-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Randomised_BSTs-2019-06-11.tar.gz">
afp-Randomised_BSTs-2019-06-11.tar.gz
</a>
</li>
<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,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Randomised_Social_Choice-2020-04-20.tar.gz">
+ afp-Randomised_Social_Choice-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Randomised_Social_Choice-2019-06-11.tar.gz">
afp-Randomised_Social_Choice-2019-06-11.tar.gz
</a>
</li>
<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,248 +1,253 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="https://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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Rank_Nullity_Theorem-2020-04-20.tar.gz">
+ afp-Rank_Nullity_Theorem-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Rank_Nullity_Theorem-2019-06-11.tar.gz">
afp-Rank_Nullity_Theorem-2019-06-11.tar.gz
</a>
</li>
<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,247 +1,252 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>mplementing
field
extensions
of
the
form
<font class="first">Q</font>[sqrt(b)]
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Real_Impl-2020-04-20.tar.gz">
+ afp-Real_Impl-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Real_Impl-2019-06-11.tar.gz">
afp-Real_Impl-2019-06-11.tar.gz
</a>
</li>
<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-Addition.html b/web/entries/Recursion-Addition.html
--- a/web/entries/Recursion-Addition.html
+++ b/web/entries/Recursion-Addition.html
@@ -1,189 +1,195 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Recursion Theorem in ZF - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>ecursion
<font class="first">T</font>heorem
in
<font class="first">Z</font>F
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Recursion Theorem in ZF</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Georgy Dunaev (georgedunaev /at/ gmail /dot/ com)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-05-11</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This document contains a proof of the recursion theorem. This is a
mechanization of the proof of the recursion theorem from the text <i>Introduction to
Set Theory</i>, by Karel Hrbacek and Thomas Jech. This
implementation may be used as the basis for a model of Peano arithmetic in
ZF. While recursion and the natural numbers are already available in Isabelle/ZF, this clean development
is much easier to follow.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Recursion-Addition-AFP,
author = {Georgy Dunaev},
title = {Recursion Theorem in ZF},
journal = {Archive of Formal Proofs},
month = may,
year = 2020,
note = {\url{https://isa-afp.org/entries/Recursion-Addition.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Recursion-Addition/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Recursion-Addition/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Recursion-Addition/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Recursion-Addition-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Recursion-Addition-2020-05-13.tar.gz">
+ afp-Recursion-Addition-2020-05-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/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,274 +1,279 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>ecursion
<font class="first">T</font>heory
<font class="first">I</font>
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Recursion-Theory-I-2020-04-20.tar.gz">
+ afp-Recursion-Theory-I-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Recursion-Theory-I-2019-06-11.tar.gz">
afp-Recursion-Theory-I-2019-06-11.tar.gz
</a>
</li>
<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,234 +1,239 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Peter Lammich
</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 mathjax_process">
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{https://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="DFS_Framework.html">DFS_Framework</a>, <a href="Dijkstra_Shortest_Path.html">Dijkstra_Shortest_Path</a>, <a href="List-Index.html">List-Index</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="Kruskal.html">Kruskal</a> </td></tr>
+ <td class="data"><a href="BTree.html">BTree</a>, <a href="Flow_Networks.html">Flow_Networks</a>, <a href="Floyd_Warshall.html">Floyd_Warshall</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_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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Refine_Imperative_HOL-2020-04-20.tar.gz">
+ afp-Refine_Imperative_HOL-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Refine_Imperative_HOL-2019-06-11.tar.gz">
afp-Refine_Imperative_HOL-2019-06-11.tar.gz
</a>
</li>
<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,280 +1,285 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>efinement
for
<font class="first">M</font>onadic
<font class="first">P</font>rograms
</h1>
<p>&nbsp;</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">
Peter Lammich
</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Refine_Monadic-2020-04-20.tar.gz">
+ afp-Refine_Monadic-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Refine_Monadic-2019-06-11.tar.gz">
afp-Refine_Monadic-2019-06-11.tar.gz
</a>
</li>
<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,240 +1,245 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-RefinementReactive-2020-04-20.tar.gz">
+ afp-RefinementReactive-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-RefinementReactive-2019-06-11.tar.gz">
afp-RefinementReactive-2019-06-11.tar.gz
</a>
</li>
<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,249 +1,254 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a> and
<a href="https://traytel.bitbucket.io">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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Regex_Equivalence-2020-04-20.tar.gz">
+ afp-Regex_Equivalence-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Regex_Equivalence-2019-06-11.tar.gz">
afp-Regex_Equivalence-2019-06-11.tar.gz
</a>
</li>
<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,276 +1,281 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>egular
<font class="first">S</font>ets
and
<font class="first">E</font>xpressions
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Regular-Sets-2020-04-20.tar.gz">
+ afp-Regular-Sets-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Regular-Sets-2019-06-11.tar.gz">
afp-Regular-Sets-2019-06-11.tar.gz
</a>
</li>
<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,231 +1,236 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>egular
<font class="first">A</font>lgebras
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Regular_Algebras-2020-04-20.tar.gz">
+ afp-Regular_Algebras-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Regular_Algebras-2019-06-11.tar.gz">
afp-Regular_Algebras-2019-06-11.tar.gz
</a>
</li>
<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,238 +1,243 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>elation
<font class="first">A</font>lgebra
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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="Relational_Paths.html">Relational_Paths</a>, <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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Relation_Algebra-2020-04-20.tar.gz">
+ afp-Relation_Algebra-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Relation_Algebra-2019-06-11.tar.gz">
afp-Relation_Algebra-2019-06-11.tar.gz
</a>
</li>
<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/Relational-Incorrectness-Logic.html b/web/entries/Relational-Incorrectness-Logic.html
--- a/web/entries/Relational-Incorrectness-Logic.html
+++ b/web/entries/Relational-Incorrectness-Logic.html
@@ -1,201 +1,206 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>An Under-Approximate Relational 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>n
<font class="first">U</font>nder-Approximate
<font class="first">R</font>elational
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">An Under-Approximate Relational Logic</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
<a href="https://people.eng.unimelb.edu.au/tobym/">Toby Murray</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-03-12</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Recently, authors have proposed under-approximate logics for reasoning
about programs. So far, all such logics have been confined to
reasoning about individual program behaviours. Yet there exist many
over-approximate relational logics for reasoning about pairs of
programs and relating their behaviours. We present the first
under-approximate relational logic, for the simple imperative language
IMP. We prove our logic is both sound and complete. Additionally, we
show how reasoning in this logic can be decomposed into non-relational
reasoning in an under-approximate Hoare logic, mirroring Beringer’s
result for over-approximate relational logics. We illustrate the
application of our logic on some small examples in which we provably
demonstrate the presence of insecurity.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Relational-Incorrectness-Logic-AFP,
author = {Toby Murray},
title = {An Under-Approximate Relational Logic},
journal = {Archive of Formal Proofs},
month = mar,
year = 2020,
note = {\url{https://isa-afp.org/entries/Relational-Incorrectness-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/Relational-Incorrectness-Logic/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Relational-Incorrectness-Logic/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Relational-Incorrectness-Logic/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Relational-Incorrectness-Logic-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Relational-Incorrectness-Logic-2020-04-20.tar.gz">
+ afp-Relational-Incorrectness-Logic-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Relational-Incorrectness-Logic-2020-03-26.tar.gz">
afp-Relational-Incorrectness-Logic-2020-03-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/Relational_Disjoint_Set_Forests.html b/web/entries/Relational_Disjoint_Set_Forests.html
--- a/web/entries/Relational_Disjoint_Set_Forests.html
+++ b/web/entries/Relational_Disjoint_Set_Forests.html
@@ -1,191 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Relational Disjoint-Set Forests - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>elational
<font class="first">D</font>isjoint-Set
<font class="first">F</font>orests
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Relational Disjoint-Set Forests</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">2020-08-26</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We give a simple relation-algebraic semantics of read and write
operations on associative arrays. The array operations seamlessly
integrate with assignments in the Hoare-logic library. Using relation
algebras and Kleene algebras we verify the correctness of an
array-based implementation of disjoint-set forests with a naive union
operation and a find operation with path compression.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Relational_Disjoint_Set_Forests-AFP,
author = {Walter Guttmann},
title = {Relational Disjoint-Set Forests},
journal = {Archive of Formal Proofs},
month = aug,
year = 2020,
note = {\url{https://isa-afp.org/entries/Relational_Disjoint_Set_Forests.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Relational_Minimum_Spanning_Trees.html">Relational_Minimum_Spanning_Trees</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Relational_Disjoint_Set_Forests/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Relational_Disjoint_Set_Forests/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Relational_Disjoint_Set_Forests/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Relational_Disjoint_Set_Forests-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Relational_Disjoint_Set_Forests-2020-08-26.tar.gz">
+ afp-Relational_Disjoint_Set_Forests-2020-08-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/Relational_Method.html b/web/entries/Relational_Method.html
--- a/web/entries/Relational_Method.html
+++ b/web/entries/Relational_Method.html
@@ -1,211 +1,222 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>The Relational Method with Message Anonymity for the Verification of Cryptographic Protocols - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">R</font>elational
<font class="first">M</font>ethod
with
<font class="first">M</font>essage
<font class="first">A</font>nonymity
for
the
<font class="first">V</font>erification
of
<font class="first">C</font>ryptographic
<font class="first">P</font>rotocols
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">The Relational Method with Message Anonymity for the Verification of Cryptographic Protocols</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">2020-12-05</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This paper introduces a new method for the formal verification of
cryptographic protocols, the relational method, derived from
Paulson's inductive method by means of some enhancements aimed at
streamlining formal definitions and proofs, specially for protocols
using public key cryptography. Moreover, this paper proposes a method
to formalize a further security property, message anonymity, in
addition to message confidentiality and authenticity. The relational
method, including message anonymity, is then applied to the
verification of a sample authentication protocol, comprising Password
Authenticated Connection Establishment (PACE) with Chip Authentication
Mapping followed by the explicit verification of an additional
password over the PACE secure channel.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Relational_Method-AFP,
author = {Pasquale Noce},
title = {The Relational Method with Message Anonymity for the Verification of Cryptographic Protocols},
journal = {Archive of Formal Proofs},
month = dec,
year = 2020,
note = {\url{https://isa-afp.org/entries/Relational_Method.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Relational_Method/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Relational_Method/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Relational_Method/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Relational_Method-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Relational_Method-2020-12-08.tar.gz">
+ afp-Relational_Method-2020-12-08.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Relational_Method-2020-12-07.tar.gz">
+ afp-Relational_Method-2020-12-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/Relational_Minimum_Spanning_Trees.html b/web/entries/Relational_Minimum_Spanning_Trees.html
--- a/web/entries/Relational_Minimum_Spanning_Trees.html
+++ b/web/entries/Relational_Minimum_Spanning_Trees.html
@@ -1,191 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Relational Minimum Spanning Tree 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>elational
<font class="first">M</font>inimum
<font class="first">S</font>panning
<font class="first">T</font>ree
<font class="first">A</font>lgorithms
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Relational Minimum Spanning Tree Algorithms</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a> and
Nicolas Robinson-O'Brien
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-12-08</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We verify the correctness of Prim's, Kruskal's and
Borůvka's minimum spanning tree algorithms based on algebras for
aggregation and minimisation.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Relational_Minimum_Spanning_Trees-AFP,
author = {Walter Guttmann and Nicolas Robinson-O'Brien},
title = {Relational Minimum Spanning Tree Algorithms},
journal = {Archive of Formal Proofs},
month = dec,
year = 2020,
note = {\url{https://isa-afp.org/entries/Relational_Minimum_Spanning_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">Depends on:</td>
<td class="data"><a href="Aggregation_Algebras.html">Aggregation_Algebras</a>, <a href="Relational_Disjoint_Set_Forests.html">Relational_Disjoint_Set_Forests</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Relational_Minimum_Spanning_Trees/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Relational_Minimum_Spanning_Trees/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Relational_Minimum_Spanning_Trees/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Relational_Minimum_Spanning_Trees-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Relational_Minimum_Spanning_Trees-2020-12-08.tar.gz">
+ afp-Relational_Minimum_Spanning_Trees-2020-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/Relational_Paths.html b/web/entries/Relational_Paths.html
--- a/web/entries/Relational_Paths.html
+++ b/web/entries/Relational_Paths.html
@@ -1,199 +1,205 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Relational Characterisations 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>elational
<font class="first">C</font>haracterisations
of
<font class="first">P</font>aths
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Relational Characterisations of Paths</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</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">2020-07-13</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Binary relations are one of the standard ways to encode, characterise
and reason about graphs. Relation algebras provide equational axioms
for a large fragment of the calculus of binary relations. Although
relations are standard tools in many areas of mathematics and
computing, researchers usually fall back to point-wise reasoning when
it comes to arguments about paths in a graph. We present a purely
algebraic way to specify different kinds of paths in Kleene relation
algebras, which are relation algebras equipped with an operation for
reflexive transitive closure. We study the relationship between paths
with a designated root vertex and paths without such a vertex. Since
we stay in first-order logic this development helps with mechanising
proofs. To demonstrate the applicability of the algebraic framework we
verify the correctness of three basic graph algorithms.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Relational_Paths-AFP,
author = {Walter Guttmann and Peter Höfner},
title = {Relational Characterisations of Paths},
journal = {Archive of Formal Proofs},
month = jul,
year = 2020,
note = {\url{https://isa-afp.org/entries/Relational_Paths.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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/Relational_Paths/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Relational_Paths/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Relational_Paths/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Relational_Paths-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Relational_Paths-2020-07-28.tar.gz">
+ afp-Relational_Paths-2020-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/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,214 +1,219 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>epresentations
of
<font class="first">F</font>inite
<font class="first">G</font>roups
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Rep_Fin_Groups-2020-04-20.tar.gz">
+ afp-Rep_Fin_Groups-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Rep_Fin_Groups-2019-06-11.tar.gz">
afp-Rep_Fin_Groups-2019-06-11.tar.gz
</a>
</li>
<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,230 +1,235 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>esiduated
<font class="first">L</font>attices
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Residuated_Lattices-2020-04-20.tar.gz">
+ afp-Residuated_Lattices-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Residuated_Lattices-2019-06-28.tar.gz">
afp-Residuated_Lattices-2019-06-28.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Residuated_Lattices-2019-06-11.tar.gz">
afp-Residuated_Lattices-2019-06-11.tar.gz
</a>
</li>
<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,254 +1,259 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Resolution_FOL-2020-04-20.tar.gz">
+ afp-Resolution_FOL-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Resolution_FOL-2019-06-11.tar.gz">
afp-Resolution_FOL-2019-06-11.tar.gz
</a>
</li>
<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,217 +1,222 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">Z</font>
<font class="first">P</font>roperty
</h1>
<p>&nbsp;</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 (int-e /at/ gmx /dot/ de),
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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Rewriting_Z-2020-04-20.tar.gz">
+ afp-Rewriting_Z-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Rewriting_Z-2019-06-11.tar.gz">
afp-Rewriting_Z-2019-06-11.tar.gz
</a>
</li>
<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,235 +1,240 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>ibbon
<font class="first">P</font>roofs
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Ribbon_Proofs-2020-04-20.tar.gz">
+ afp-Ribbon_Proofs-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Ribbon_Proofs-2019-06-11.tar.gz">
afp-Ribbon_Proofs-2019-06-11.tar.gz
</a>
</li>
<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,265 +1,270 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Robbins-Conjecture-2020-04-20.tar.gz">
+ afp-Robbins-Conjecture-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Robbins-Conjecture-2019-06-11.tar.gz">
afp-Robbins-Conjecture-2019-06-11.tar.gz
</a>
</li>
<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/Robinson_Arithmetic.html b/web/entries/Robinson_Arithmetic.html
--- a/web/entries/Robinson_Arithmetic.html
+++ b/web/entries/Robinson_Arithmetic.html
@@ -1,191 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Robinson 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>obinson
<font class="first">A</font>rithmetic
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Robinson Arithmetic</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://www.andreipopescu.uk">Andrei Popescu</a> and
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-09-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We instantiate our syntax-independent logic infrastructure developed
in <a
href="https://www.isa-afp.org/entries/Syntax_Independent_Logic.html">a
separate AFP entry</a> to the FOL theory of Robinson arithmetic
(also known as Q). The latter was formalised using Nominal Isabelle by
adapting <a
href="https://www.isa-afp.org/entries/Incompleteness.html">Larry
Paulson’s formalization of the Hereditarily Finite Set
theory</a>.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Robinson_Arithmetic-AFP,
author = {Andrei Popescu and Dmitriy Traytel},
title = {Robinson Arithmetic},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/Robinson_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="Nominal2.html">Nominal2</a>, <a href="Syntax_Independent_Logic.html">Syntax_Independent_Logic</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Robinson_Arithmetic/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Robinson_Arithmetic/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Robinson_Arithmetic/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Robinson_Arithmetic-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Robinson_Arithmetic-2020-09-18.tar.gz">
+ afp-Robinson_Arithmetic-2020-09-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/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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>oot-Balanced
<font class="first">T</font>ree
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
<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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="CakeML_Codegen.html">CakeML_Codegen</a>, <a href="Closest_Pair_Points.html">Closest_Pair_Points</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Root_Balanced_Tree-2020-04-20.tar.gz">
+ afp-Root_Balanced_Tree-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Root_Balanced_Tree-2019-06-11.tar.gz">
afp-Root_Balanced_Tree-2019-06-11.tar.gz
</a>
</li>
<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,216 +1,221 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">R</font>outing
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Routing-2020-04-20.tar.gz">
+ afp-Routing-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Routing-2019-06-11.tar.gz">
afp-Routing-2019-06-11.tar.gz
</a>
</li>
<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,235 +1,240 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>ransitive
closure
according
to
<font class="first">R</font>oy-Floyd-Warshall
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Roy_Floyd_Warshall-2020-04-20.tar.gz">
+ afp-Roy_Floyd_Warshall-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Roy_Floyd_Warshall-2020-01-14.tar.gz">
afp-Roy_Floyd_Warshall-2020-01-14.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Roy_Floyd_Warshall-2019-06-11.tar.gz">
afp-Roy_Floyd_Warshall-2019-06-11.tar.gz
</a>
</li>
<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,278 +1,283 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Filip Marić (filip /at/ matf /dot/ bg /dot/ ac /dot/ rs)
</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 mathjax_process">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 Marić},
title = {Formal Verification of Modern SAT Solvers},
journal = {Archive of Formal Proofs},
month = jul,
year = 2008,
note = {\url{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-SATSolverVerification-2020-04-20.tar.gz">
+ afp-SATSolverVerification-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-SATSolverVerification-2019-06-11.tar.gz">
afp-SATSolverVerification-2019-06-11.tar.gz
</a>
</li>
<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/SC_DOM_Components.html b/web/entries/SC_DOM_Components.html
--- a/web/entries/SC_DOM_Components.html
+++ b/web/entries/SC_DOM_Components.html
@@ -1,208 +1,214 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Formalization of Safely Composable Web 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">F</font>ormalization
of
<font class="first">S</font>afely
<font class="first">C</font>omposable
<font class="first">W</font>eb
<font class="first">C</font>omponents
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Formalization of Safely Composable Web Components</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">2020-09-28</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
While the (safely composable) DOM with shadow trees provide the
technical basis for defining web components, it does neither defines
the concept of web components nor specifies the safety properties that
web components should guarantee. Consequently, the standard also does
not discuss how or even if the methods for modifying the DOM respect
component boundaries. In AFP entry, we present a formally verified
model of safely composable web components and define safety properties
which ensure that different web components can only interact with each
other using well-defined interfaces. Moreover, our verification of the
application programming interface (API) of the DOM revealed numerous
invariants that implementations of the DOM API need to preserve to
ensure the integrity of components. In comparison to the strict
standard compliance formalization of Web Components in the AFP entry
"DOM_Components", the notion of components in this entry
(based on "SC_DOM" and "Shadow_SC_DOM") provides
much stronger safety guarantees.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{SC_DOM_Components-AFP,
author = {Achim D. Brucker and Michael Herzberg},
title = {A Formalization of Safely Composable Web Components},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/SC_DOM_Components.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Shadow_SC_DOM.html">Shadow_SC_DOM</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/SC_DOM_Components/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/SC_DOM_Components/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/SC_DOM_Components/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-SC_DOM_Components-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-SC_DOM_Components-2020-11-27.tar.gz">
+ afp-SC_DOM_Components-2020-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/SDS_Impossibility.html b/web/entries/SDS_Impossibility.html
--- a/web/entries/SDS_Impossibility.html
+++ b/web/entries/SDS_Impossibility.html
@@ -1,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-SDS_Impossibility-2020-04-20.tar.gz">
+ afp-SDS_Impossibility-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-SDS_Impossibility-2019-06-11.tar.gz">
afp-SDS_Impossibility-2019-06-11.tar.gz
</a>
</li>
<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,274 +1,279 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>ecure
information
flow
and
program
logics
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-SIFPL-2020-04-20.tar.gz">
+ afp-SIFPL-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-SIFPL-2019-06-11.tar.gz">
afp-SIFPL-2019-06-11.tar.gz
</a>
</li>
<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,256 +1,261 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-SIFUM_Type_Systems-2020-04-20.tar.gz">
+ afp-SIFUM_Type_Systems-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-SIFUM_Type_Systems-2019-06-11.tar.gz">
afp-SIFUM_Type_Systems-2019-06-11.tar.gz
</a>
</li>
<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,247 +1,252 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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>
<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/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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-SPARCv8-2020-04-20.tar.gz">
+ afp-SPARCv8-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-SPARCv8-2019-06-11.tar.gz">
afp-SPARCv8-2019-06-11.tar.gz
</a>
</li>
<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_Distance.html b/web/entries/Safe_Distance.html
--- a/web/entries/Safe_Distance.html
+++ b/web/entries/Safe_Distance.html
@@ -1,213 +1,219 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Formally Verified Checker of the Safe Distance Traffic Rules for Autonomous Vehicles - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">F</font>ormally
<font class="first">V</font>erified
<font class="first">C</font>hecker
of
the
<font class="first">S</font>afe
<font class="first">D</font>istance
<font class="first">T</font>raffic
<font class="first">R</font>ules
for
<font class="first">A</font>utonomous
<font class="first">V</font>ehicles
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Formally Verified Checker of the Safe Distance Traffic Rules for Autonomous Vehicles</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Albert Rizaldi (albert /dot/ rizaldi /at/ ntu /dot/ edu /dot/ sg) and
<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-06-01</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
The Vienna Convention on Road Traffic defines the safe distance
traffic rules informally. This could make autonomous vehicle liable
for safe-distance-related accidents because there is no clear
definition of how large a safe distance is. We provide a formally
proven prescriptive definition of a safe distance, and checkers which
can decide whether an autonomous vehicle is obeying the safe distance
rule. Not only does our work apply to the domain of law, but it also
serves as a specification for autonomous vehicle manufacturers and for
online verification of path planners.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Safe_Distance-AFP,
author = {Albert Rizaldi and Fabian Immler},
title = {A Formally Verified Checker of the Safe Distance Traffic Rules for Autonomous Vehicles},
journal = {Archive of Formal Proofs},
month = jun,
year = 2020,
note = {\url{https://isa-afp.org/entries/Safe_Distance.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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/Safe_Distance/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Safe_Distance/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Safe_Distance/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Safe_Distance-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Safe_Distance-2020-06-03.tar.gz">
+ afp-Safe_Distance-2020-06-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/Safe_OCL.html b/web/entries/Safe_OCL.html
--- a/web/entries/Safe_OCL.html
+++ b/web/entries/Safe_OCL.html
@@ -1,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>afe
<font class="first">O</font>CL
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Safe_OCL-2020-04-20.tar.gz">
+ afp-Safe_OCL-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Safe_OCL-2019-06-11.tar.gz">
afp-Safe_OCL-2019-06-11.tar.gz
</a>
</li>
<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/Saturation_Framework.html b/web/entries/Saturation_Framework.html
--- a/web/entries/Saturation_Framework.html
+++ b/web/entries/Saturation_Framework.html
@@ -1,215 +1,220 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Comprehensive Framework for Saturation Theorem Proving - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">C</font>omprehensive
<font class="first">F</font>ramework
for
<font class="first">S</font>aturation
<font class="first">T</font>heorem
<font class="first">P</font>roving
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Comprehensive Framework for Saturation Theorem Proving</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
<a href="https://www.mpi-inf.mpg.de/departments/automation-of-logic/people/sophie-tourret">Sophie Tourret</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-04-09</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This Isabelle/HOL formalization is the companion of the technical
report “A comprehensive framework for saturation theorem proving”,
itself companion of the eponym IJCAR 2020 paper, written by Uwe
Waldmann, Sophie Tourret, Simon Robillard and Jasmin Blanchette. It
verifies a framework for formal refutational completeness proofs of
abstract provers that implement saturation calculi, such as ordered
resolution or superposition, and allows to model entire prover
architectures in such a way that the static refutational completeness
of a calculus immediately implies the dynamic refutational
completeness of a prover implementing the calculus using a variant of
the given clause loop. The technical report “A comprehensive
framework for saturation theorem proving” is available <a
href="http://matryoshka.gforge.inria.fr/pubs/satur_report.pdf">on
the Matryoshka website</a>. The names of the Isabelle lemmas and
theorems corresponding to the results in the report are indicated in
the margin of the report.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Saturation_Framework-AFP,
author = {Sophie Tourret},
title = {A Comprehensive Framework for Saturation Theorem Proving},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/Saturation_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="Lambda_Free_RPOs.html">Lambda_Free_RPOs</a>, <a href="Ordered_Resolution_Prover.html">Ordered_Resolution_Prover</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="Saturation_Framework_Extensions.html">Saturation_Framework_Extensions</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Saturation_Framework/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Saturation_Framework/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Saturation_Framework/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Saturation_Framework-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Saturation_Framework-2020-04-20.tar.gz">
+ afp-Saturation_Framework-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Saturation_Framework-2020-04-10.tar.gz">
afp-Saturation_Framework-2020-04-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/Secondary_Sylow.html b/web/entries/Secondary_Sylow.html
--- a/web/entries/Secondary_Sylow.html
+++ b/web/entries/Secondary_Sylow.html
@@ -1,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>econdary
<font class="first">S</font>ylow
<font class="first">T</font>heorems
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Secondary_Sylow-2020-04-20.tar.gz">
+ afp-Secondary_Sylow-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Secondary_Sylow-2019-06-11.tar.gz">
afp-Secondary_Sylow-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Security_Protocol_Refinement-2020-04-20.tar.gz">
+ afp-Security_Protocol_Refinement-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Security_Protocol_Refinement-2019-06-11.tar.gz">
afp-Security_Protocol_Refinement-2019-06-11.tar.gz
</a>
</li>
<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,249 +1,254 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Selection_Heap_Sort-2020-04-20.tar.gz">
+ afp-Selection_Heap_Sort-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Selection_Heap_Sort-2019-06-11.tar.gz">
afp-Selection_Heap_Sort-2019-06-11.tar.gz
</a>
</li>
<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,280 +1,285 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-SenSocialChoice-2020-04-20.tar.gz">
+ afp-SenSocialChoice-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-SenSocialChoice-2019-06-11.tar.gz">
afp-SenSocialChoice-2019-06-11.tar.gz
</a>
</li>
<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,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Separata-2020-04-20.tar.gz">
+ afp-Separata-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Separata-2019-06-11.tar.gz">
afp-Separata-2019-06-11.tar.gz
</a>
</li>
<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,244 +1,249 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>eparation
<font class="first">A</font>lgebra
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Separation_Algebra-2020-04-20.tar.gz">
+ afp-Separation_Algebra-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Separation_Algebra-2019-06-11.tar.gz">
afp-Separation_Algebra-2019-06-11.tar.gz
</a>
</li>
<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,267 +1,272 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Peter Lammich 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 mathjax_process">
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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Separation_Logic_Imperative_HOL-2020-04-20.tar.gz">
+ afp-Separation_Logic_Imperative_HOL-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Separation_Logic_Imperative_HOL-2019-06-11.tar.gz">
afp-Separation_Logic_Imperative_HOL-2019-06-11.tar.gz
</a>
</li>
<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,264 +1,269 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">I</font>nvertibility
in
<font class="first">S</font>equent
<font class="first">C</font>alculi
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-SequentInvertibility-2020-04-20.tar.gz">
+ afp-SequentInvertibility-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-SequentInvertibility-2019-06-11.tar.gz">
afp-SequentInvertibility-2019-06-11.tar.gz
</a>
</li>
<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/Shadow_SC_DOM.html b/web/entries/Shadow_SC_DOM.html
--- a/web/entries/Shadow_SC_DOM.html
+++ b/web/entries/Shadow_SC_DOM.html
@@ -1,223 +1,229 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Formal Model of the Safely Composable Document Object Model with Shadow 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">F</font>ormal
<font class="first">M</font>odel
of
the
<font class="first">S</font>afely
<font class="first">C</font>omposable
<font class="first">D</font>ocument
<font class="first">O</font>bject
<font class="first">M</font>odel
with
<font class="first">S</font>hadow
<font class="first">R</font>oots
</h1>
<p>&nbsp;</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 Safely Composable Document Object Model with Shadow Roots</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">2020-09-28</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
In this AFP entry, we extend our formalization of the safely
composable DOM with Shadow Roots. This is a proposal for Shadow Roots
with stricter safety guarantess than the standard compliant
formalization (see "Shadow DOM"). Shadow Roots are a recent
proposal of the web community to support a component-based development
approach for client-side web applications. Shadow roots are a
significant extension to the DOM standard and, as web standards are
condemned to be backward compatible, such extensions often result in
complex specification that may contain unwanted subtleties that can be
detected by a formalization. Our Isabelle/HOL formalization is, in
the sense of object-orientation, an extension of our formalization of
the core DOM and enjoys the same basic properties, i.e., it is
extensible, i.e., can be extended without the need of re-proving
already proven properties and executable, i.e., we can generate
executable code from our specification. We exploit the executability
to show that our formalization complies to the official standard of
the W3C, respectively, the WHATWG.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Shadow_SC_DOM-AFP,
author = {Achim D. Brucker and Michael Herzberg},
title = {A Formal Model of the Safely Composable Document Object Model with Shadow Roots},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/Shadow_SC_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>
<tr><td class="datahead">Depends on:</td>
<td class="data"><a href="Core_SC_DOM.html">Core_SC_DOM</a> </td></tr>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="SC_DOM_Components.html">SC_DOM_Components</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Shadow_SC_DOM/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Shadow_SC_DOM/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Shadow_SC_DOM/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Shadow_SC_DOM-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Shadow_SC_DOM-2020-11-26.tar.gz">
+ afp-Shadow_SC_DOM-2020-11-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/Shivers-CFA.html b/web/entries/Shivers-CFA.html
--- a/web/entries/Shivers-CFA.html
+++ b/web/entries/Shivers-CFA.html
@@ -1,264 +1,269 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Shivers-CFA-2020-04-20.tar.gz">
+ afp-Shivers-CFA-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Shivers-CFA-2019-06-11.tar.gz">
afp-Shivers-CFA-2019-06-11.tar.gz
</a>
</li>
<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,246 +1,251 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-ShortestPath-2020-04-20.tar.gz">
+ afp-ShortestPath-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-ShortestPath-2019-06-11.tar.gz">
afp-ShortestPath-2019-06-11.tar.gz
</a>
</li>
<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,242 +1,247 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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="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="AI_Planning_Languages_Semantics.html">AI_Planning_Languages_Semantics</a>, <a href="CakeML.html">CakeML</a>, <a href="CakeML_Codegen.html">CakeML_Codegen</a>, <a href="Certification_Monads.html">Certification_Monads</a>, <a href="Dict_Construction.html">Dict_Construction</a>, <a href="Monad_Memo_DP.html">Monad_Memo_DP</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Show-2020-04-20.tar.gz">
+ afp-Show-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Show-2019-06-11.tar.gz">
afp-Show-2019-06-11.tar.gz
</a>
</li>
<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/Sigma_Commit_Crypto.html b/web/entries/Sigma_Commit_Crypto.html
--- a/web/entries/Sigma_Commit_Crypto.html
+++ b/web/entries/Sigma_Commit_Crypto.html
@@ -1,208 +1,213 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Sigma Protocols and Commitment Schemes - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>igma
<font class="first">P</font>rotocols
and
<font class="first">C</font>ommitment
<font class="first">S</font>chemes
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Sigma Protocols and Commitment Schemes</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://www.turing.ac.uk/people/doctoral-students/david-butler">David Butler</a> and
<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-10-07</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We use CryptHOL to formalise commitment schemes and Sigma-protocols.
Both are widely used fundamental two party cryptographic primitives.
Security for commitment schemes is considered using game-based
definitions whereas the security of Sigma-protocols is considered
using both the game-based and simulation-based security paradigms. In
this work, we first define security for both primitives and then prove
secure multiple case studies: the Schnorr, Chaum-Pedersen and
Okamoto Sigma-protocols as well as a construction that allows for
compound (AND and OR statements) Sigma-protocols and the Pedersen and
Rivest commitment schemes. We also prove that commitment schemes can
be constructed from Sigma-protocols. We formalise this proof at an
abstract level, only assuming the existence of a Sigma-protocol;
consequently, the instantiations of this result for the concrete
Sigma-protocols we consider come for free.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Sigma_Commit_Crypto-AFP,
author = {David Butler and Andreas Lochbihler},
title = {Sigma Protocols and Commitment Schemes},
journal = {Archive of Formal Proofs},
month = oct,
year = 2019,
note = {\url{https://isa-afp.org/entries/Sigma_Commit_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>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Sigma_Commit_Crypto/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Sigma_Commit_Crypto/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Sigma_Commit_Crypto/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Sigma_Commit_Crypto-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Sigma_Commit_Crypto-2020-04-20.tar.gz">
+ afp-Sigma_Commit_Crypto-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Sigma_Commit_Crypto-2019-10-08.tar.gz">
afp-Sigma_Commit_Crypto-2019-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/Signature_Groebner.html b/web/entries/Signature_Groebner.html
--- a/web/entries/Signature_Groebner.html
+++ b/web/entries/Signature_Groebner.html
@@ -1,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<p>This article formalizes signature-based algorithms for computing
Gr&ouml;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&ouml;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&egrave;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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Signature_Groebner-2020-04-20.tar.gz">
+ afp-Signature_Groebner-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Signature_Groebner-2019-06-11.tar.gz">
afp-Signature_Groebner-2019-06-11.tar.gz
</a>
</li>
<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,297 +1,302 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Simpl-2020-04-20.tar.gz">
+ afp-Simpl-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Simpl-2019-06-11.tar.gz">
afp-Simpl-2019-06-11.tar.gz
</a>
</li>
<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,226 +1,231 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>imple
<font class="first">F</font>irewall
</h1>
<p>&nbsp;</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="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Simple_Firewall-2020-04-20.tar.gz">
+ afp-Simple_Firewall-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Simple_Firewall-2019-06-11.tar.gz">
afp-Simple_Firewall-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Simplex-2020-04-20.tar.gz">
+ afp-Simplex-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Simplex-2020-01-14.tar.gz">
afp-Simplex-2020-01-14.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Simplex-2019-06-11.tar.gz">
afp-Simplex-2019-06-11.tar.gz
</a>
</li>
<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,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>kew
<font class="first">H</font>eap
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Skew_Heap-2020-04-20.tar.gz">
+ afp-Skew_Heap-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Skew_Heap-2019-06-11.tar.gz">
afp-Skew_Heap-2019-06-11.tar.gz
</a>
</li>
<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/Skip_Lists.html b/web/entries/Skip_Lists.html
--- a/web/entries/Skip_Lists.html
+++ b/web/entries/Skip_Lists.html
@@ -1,197 +1,202 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Skip 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>kip
<font class="first">L</font>ists
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Skip Lists</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Max W. Haslbeck</a> and
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-01-09</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p> Skip lists are sorted linked lists enhanced with shortcuts
and are an alternative to binary search trees. A skip lists consists
of multiple levels of sorted linked lists where a list on level n is a
subsequence of the list on level n − 1. In the ideal case, elements
are skipped in such a way that a lookup in a skip lists takes O(log n)
time. In a randomised skip list the skipped elements are choosen
randomly. </p> <p> This entry contains formalized proofs
of the textbook results about the expected height and the expected
length of a search path in a randomised skip list. </p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Skip_Lists-AFP,
author = {Max W. Haslbeck and Manuel Eberl},
title = {Skip Lists},
journal = {Archive of Formal Proofs},
month = jan,
year = 2020,
note = {\url{https://isa-afp.org/entries/Skip_Lists.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Skip_Lists/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Skip_Lists/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Skip_Lists/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Skip_Lists-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Skip_Lists-2020-04-20.tar.gz">
+ afp-Skip_Lists-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Skip_Lists-2020-01-10.tar.gz">
afp-Skip_Lists-2020-01-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/Slicing.html b/web/entries/Slicing.html
--- a/web/entries/Slicing.html
+++ b/web/entries/Slicing.html
@@ -1,276 +1,281 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>owards
<font class="first">C</font>ertified
<font class="first">S</font>licing
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Slicing-2020-04-20.tar.gz">
+ afp-Slicing-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Slicing-2019-06-11.tar.gz">
afp-Slicing-2019-06-11.tar.gz
</a>
</li>
<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/Sliding_Window_Algorithm.html b/web/entries/Sliding_Window_Algorithm.html
--- a/web/entries/Sliding_Window_Algorithm.html
+++ b/web/entries/Sliding_Window_Algorithm.html
@@ -1,216 +1,221 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Formalization of an Algorithm for Greedily Computing Associative Aggregations on Sliding Windows - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">F</font>ormalization
of
an
<font class="first">A</font>lgorithm
for
<font class="first">G</font>reedily
<font class="first">C</font>omputing
<font class="first">A</font>ssociative
<font class="first">A</font>ggregations
on
<font class="first">S</font>liding
<font class="first">W</font>indows
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Formalization of an Algorithm for Greedily Computing Associative Aggregations on Sliding Windows</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Lukas Heimes,
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a> and
Joshua Schneider
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-04-10</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Basin et al.'s <a
href="https://doi.org/10.1016/j.ipl.2014.09.009">sliding
window algorithm (SWA)</a> is an algorithm for combining the
elements of subsequences of a sequence with an associative operator.
It is greedy and minimizes the number of operator applications. We
formalize the algorithm and verify its functional correctness. We
extend the algorithm with additional operations and provide an
alternative interface to the slide operation that does not require the
entire input sequence.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Sliding_Window_Algorithm-AFP,
author = {Lukas Heimes and Dmitriy Traytel and Joshua Schneider},
title = {Formalization of an Algorithm for Greedily Computing Associative Aggregations on Sliding Windows},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/Sliding_Window_Algorithm.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Sliding_Window_Algorithm/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Sliding_Window_Algorithm/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Sliding_Window_Algorithm/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Sliding_Window_Algorithm-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Sliding_Window_Algorithm-2020-04-20.tar.gz">
+ afp-Sliding_Window_Algorithm-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Sliding_Window_Algorithm-2020-04-12.tar.gz">
afp-Sliding_Window_Algorithm-2020-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/Smith_Normal_Form.html b/web/entries/Smith_Normal_Form.html
--- a/web/entries/Smith_Normal_Form.html
+++ b/web/entries/Smith_Normal_Form.html
@@ -1,214 +1,220 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A verified algorithm for computing the Smith normal form of a matrix - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
verified
algorithm
for
computing
the
<font class="first">S</font>mith
normal
form
of
a
matrix
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A verified algorithm for computing the Smith normal form of a matrix</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
<a href="https://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-05-23</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This work presents a formal proof in Isabelle/HOL of an algorithm to
transform a matrix into its Smith normal form, a canonical matrix
form, in a general setting: the algorithm is parameterized by
operations to prove its existence over elementary divisor rings, while
execution is guaranteed over Euclidean domains. We also provide a
formal proof on some results about the generality of this algorithm as
well as the uniqueness of the Smith normal form. Since Isabelle/HOL
does not feature dependent types, the development is carried out
switching conveniently between two different existing libraries: the
Hermite normal form (based on HOL Analysis) and the Jordan normal form
AFP entries. This permits to reuse results from both developments and
it is done by means of the lifting and transfer package together with
the use of local type definitions.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Smith_Normal_Form-AFP,
author = {Jose Divasón},
title = {A verified algorithm for computing the Smith normal form of a matrix},
journal = {Archive of Formal Proofs},
month = may,
year = 2020,
note = {\url{https://isa-afp.org/entries/Smith_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="Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a>, <a href="Hermite.html">Hermite</a>, <a href="List-Index.html">List-Index</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/Smith_Normal_Form/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Smith_Normal_Form/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Smith_Normal_Form/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Smith_Normal_Form-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Smith_Normal_Form-2020-05-25.tar.gz">
+ afp-Smith_Normal_Form-2020-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/Smooth_Manifolds.html b/web/entries/Smooth_Manifolds.html
--- a/web/entries/Smooth_Manifolds.html
+++ b/web/entries/Smooth_Manifolds.html
@@ -1,198 +1,203 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>mooth
<font class="first">M</font>anifolds
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Smooth_Manifolds-2020-04-20.tar.gz">
+ afp-Smooth_Manifolds-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Smooth_Manifolds-2019-06-11.tar.gz">
afp-Smooth_Manifolds-2019-06-11.tar.gz
</a>
</li>
<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,261 +1,266 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Sort_Encodings-2020-04-20.tar.gz">
+ afp-Sort_Encodings-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Sort_Encodings-2019-06-11.tar.gz">
afp-Sort_Encodings-2019-06-11.tar.gz
</a>
</li>
<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,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>ource
<font class="first">C</font>oding
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Source_Coding_Theorem-2020-04-20.tar.gz">
+ afp-Source_Coding_Theorem-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Source_Coding_Theorem-2019-06-11.tar.gz">
afp-Source_Coding_Theorem-2019-06-11.tar.gz
</a>
</li>
<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,232 +1,237 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Special_Function_Bounds-2020-04-20.tar.gz">
+ afp-Special_Function_Bounds-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Special_Function_Bounds-2019-06-11.tar.gz">
afp-Special_Function_Bounds-2019-06-11.tar.gz
</a>
</li>
<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,227 +1,232 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>play
<font class="first">T</font>ree
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Splay_Tree-2020-04-20.tar.gz">
+ afp-Splay_Tree-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Splay_Tree-2019-06-11.tar.gz">
afp-Splay_Tree-2019-06-11.tar.gz
</a>
</li>
<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,258 +1,263 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Sqrt_Babylonian-2020-04-20.tar.gz">
+ afp-Sqrt_Babylonian-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Sqrt_Babylonian-2019-06-11.tar.gz">
afp-Sqrt_Babylonian-2019-06-11.tar.gz
</a>
</li>
<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,210 +1,215 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>table
<font class="first">M</font>atching
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stable_Matching-2020-04-20.tar.gz">
+ afp-Stable_Matching-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stable_Matching-2019-06-11.tar.gz">
afp-Stable_Matching-2019-06-11.tar.gz
</a>
</li>
<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,268 +1,273 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Statecharts-2020-04-20.tar.gz">
+ afp-Statecharts-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Statecharts-2019-06-11.tar.gz">
afp-Statecharts-2019-06-11.tar.gz
</a>
</li>
<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/Stateful_Protocol_Composition_and_Typing.html b/web/entries/Stateful_Protocol_Composition_and_Typing.html
--- a/web/entries/Stateful_Protocol_Composition_and_Typing.html
+++ b/web/entries/Stateful_Protocol_Composition_and_Typing.html
@@ -1,205 +1,211 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Stateful Protocol Composition and Typing - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>tateful
<font class="first">P</font>rotocol
<font class="first">C</font>omposition
and
<font class="first">T</font>yping
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Stateful Protocol Composition and Typing</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Andreas V. Hess (avhe /at/ dtu /dot/ dk),
<a href="https://people.compute.dtu.dk/samo/">Sebastian Mödersheim</a> and
<a href="https://www.brucker.ch">Achim D. Brucker</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-04-08</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We provide in this AFP entry several relative soundness results for
security protocols. In particular, we prove typing and
compositionality results for stateful protocols (i.e., protocols with
mutable state that may span several sessions), and that focuses on
reachability properties. Such results are useful to simplify protocol
verification by reducing it to a simpler problem: Typing results give
conditions under which it is safe to verify a protocol in a typed
model where only "well-typed" attacks can occur whereas
compositionality results allow us to verify a composed protocol by
only verifying the component protocols in isolation. The conditions on
the protocols under which the results hold are furthermore syntactic
in nature allowing for full automation. The foundation presented here
is used in another entry to provide fully automated and formalized
security proofs of stateful protocols.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Stateful_Protocol_Composition_and_Typing-AFP,
author = {Andreas V. Hess and Sebastian Mödersheim and Achim D. Brucker},
title = {Stateful Protocol Composition and Typing},
journal = {Archive of Formal Proofs},
month = apr,
year = 2020,
note = {\url{https://isa-afp.org/entries/Stateful_Protocol_Composition_and_Typing.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Automated_Stateful_Protocol_Verification.html">Automated_Stateful_Protocol_Verification</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Stateful_Protocol_Composition_and_Typing/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Stateful_Protocol_Composition_and_Typing/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Stateful_Protocol_Composition_and_Typing/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Stateful_Protocol_Composition_and_Typing-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stateful_Protocol_Composition_and_Typing-2020-05-20.tar.gz">
+ afp-Stateful_Protocol_Composition_and_Typing-2020-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/Stellar_Quorums.html b/web/entries/Stellar_Quorums.html
--- a/web/entries/Stellar_Quorums.html
+++ b/web/entries/Stellar_Quorums.html
@@ -1,190 +1,195 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Stellar Quorum 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>tellar
<font class="first">Q</font>uorum
<font class="first">S</font>ystems
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Stellar Quorum Systems</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Giuliano Losa (giuliano /at/ galois /dot/ com)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-08-01</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We formalize the static properties of personal Byzantine quorum
systems (PBQSs) and Stellar quorum systems, as described in the paper
``Stellar Consensus by Reduction'' (to appear at DISC 2019).</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Stellar_Quorums-AFP,
author = {Giuliano Losa},
title = {Stellar Quorum Systems},
journal = {Archive of Formal Proofs},
month = aug,
year = 2019,
note = {\url{https://isa-afp.org/entries/Stellar_Quorums.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Stellar_Quorums/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Stellar_Quorums/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Stellar_Quorums/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Stellar_Quorums-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stellar_Quorums-2020-04-20.tar.gz">
+ afp-Stellar_Quorums-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stellar_Quorums-2019-08-03.tar.gz">
afp-Stellar_Quorums-2019-08-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/Stern_Brocot.html b/web/entries/Stern_Brocot.html
--- a/web/entries/Stern_Brocot.html
+++ b/web/entries/Stern_Brocot.html
@@ -1,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">S</font>tern-Brocot
<font class="first">T</font>ree
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stern_Brocot-2020-04-20.tar.gz">
+ afp-Stern_Brocot-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stern_Brocot-2019-06-11.tar.gz">
afp-Stern_Brocot-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stewart_Apollonius-2020-04-20.tar.gz">
+ afp-Stewart_Apollonius-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stewart_Apollonius-2019-06-11.tar.gz">
afp-Stewart_Apollonius-2019-06-11.tar.gz
</a>
</li>
<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,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>tirling's
formula
</h1>
<p>&nbsp;</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 mathjax_process">
<p>This work contains a proof of Stirling's formula both for the factorial $n! \sim \sqrt{2\pi n} (n/e)^n$ on natural numbers and the real
Gamma function $\Gamma(x)\sim \sqrt{2\pi/x} (x/e)^x$. The proof is based on work by <a
href="http://www.maths.lancs.ac.uk/~jameson/stirlgamma.pdf">Graham Jameson</a>.</p>
<p>This is then extended to the full asymptotic expansion
$$\log\Gamma(z) = \big(z - \tfrac{1}{2}\big)\log z - z + \tfrac{1}{2}\log(2\pi) + \sum_{k=1}^{n-1} \frac{B_{k+1}}{k(k+1)} z^{-k}\\
{} - \frac{1}{n} \int_0^\infty B_n([t])(t + z)^{-n}\,\text{d}t$$
uniformly for all complex $z\neq 0$ in the cone $\text{arg}(z)\leq \alpha$ for any $\alpha\in(0,\pi)$, with which the above asymptotic
relation for &Gamma; is also extended to complex arguments.</p></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{https://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="Lambert_W.html">Lambert_W</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stirling_Formula-2020-04-20.tar.gz">
+ afp-Stirling_Formula-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stirling_Formula-2019-06-11.tar.gz">
afp-Stirling_Formula-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
Stochastic matrices are a convenient way to model discrete-time and
finite state Markov chains. The Perron&ndash;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&ndash;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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stochastic_Matrices-2020-04-20.tar.gz">
+ afp-Stochastic_Matrices-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stochastic_Matrices-2019-06-11.tar.gz">
afp-Stochastic_Matrices-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>tone
<font class="first">A</font>lgebras
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>, <a href="Subset_Boolean_Algebras.html">Subset_Boolean_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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stone_Algebras-2020-04-20.tar.gz">
+ afp-Stone_Algebras-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stone_Algebras-2019-06-28.tar.gz">
afp-Stone_Algebras-2019-06-28.tar.gz
</a>
</li>
<li>Isabelle 2019:
<a href="../release/afp-Stone_Algebras-2019-06-11.tar.gz">
afp-Stone_Algebras-2019-06-11.tar.gz
</a>
</li>
<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,210 +1,215 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>tone-Kleene
<font class="first">R</font>elation
<font class="first">A</font>lgebras
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>, <a href="Relational_Disjoint_Set_Forests.html">Relational_Disjoint_Set_Forests</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stone_Kleene_Relation_Algebras-2020-04-20.tar.gz">
+ afp-Stone_Kleene_Relation_Algebras-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stone_Kleene_Relation_Algebras-2019-06-11.tar.gz">
afp-Stone_Kleene_Relation_Algebras-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>tone
<font class="first">R</font>elation
<font class="first">A</font>lgebras
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stone_Relation_Algebras-2020-04-20.tar.gz">
+ afp-Stone_Relation_Algebras-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stone_Relation_Algebras-2019-06-11.tar.gz">
afp-Stone_Relation_Algebras-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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.</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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Store_Buffer_Reduction-2020-04-20.tar.gz">
+ afp-Store_Buffer_Reduction-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Store_Buffer_Reduction-2019-06-11.tar.gz">
afp-Store_Buffer_Reduction-2019-06-11.tar.gz
</a>
</li>
<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,265 +1,270 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>tream
<font class="first">F</font>usion
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stream-Fusion-2020-04-20.tar.gz">
+ afp-Stream-Fusion-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stream-Fusion-2019-06-11.tar.gz">
afp-Stream-Fusion-2019-06-11.tar.gz
</a>
</li>
<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,233 +1,238 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stream_Fusion_Code-2020-04-20.tar.gz">
+ afp-Stream_Fusion_Code-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stream_Fusion_Code-2019-06-11.tar.gz">
afp-Stream_Fusion_Code-2019-06-11.tar.gz
</a>
</li>
<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,250 +1,255 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Strong_Security-2020-04-20.tar.gz">
+ afp-Strong_Security-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Strong_Security-2019-06-11.tar.gz">
afp-Strong_Security-2019-06-11.tar.gz
</a>
</li>
<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,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>turm's
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">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
&#8712; &#8477;”.</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{https://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="Safe_Distance.html">Safe_Distance</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Sturm_Sequences-2020-04-20.tar.gz">
+ afp-Sturm_Sequences-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Sturm_Sequences-2019-06-11.tar.gz">
afp-Sturm_Sequences-2019-06-11.tar.gz
</a>
</li>
<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,224 +1,229 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">S</font>turm-Tarski
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Sturm_Tarski-2020-04-20.tar.gz">
+ afp-Sturm_Tarski-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Sturm_Tarski-2019-06-11.tar.gz">
afp-Sturm_Tarski-2019-06-11.tar.gz
</a>
</li>
<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,253 +1,258 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>tuttering
<font class="first">E</font>quivalence
</h1>
<p>&nbsp;</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 mathjax_process"><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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Stuttering_Equivalence-2020-04-20.tar.gz">
+ afp-Stuttering_Equivalence-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Stuttering_Equivalence-2019-06-11.tar.gz">
afp-Stuttering_Equivalence-2019-06-11.tar.gz
</a>
</li>
<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,206 +1,211 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>ubresultants
</h1>
<p>&nbsp;</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
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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 mathjax_process">
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{https://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>
</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Subresultants-2020-04-20.tar.gz">
+ afp-Subresultants-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Subresultants-2019-06-11.tar.gz">
afp-Subresultants-2019-06-11.tar.gz
</a>
</li>
<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/Subset_Boolean_Algebras.html b/web/entries/Subset_Boolean_Algebras.html
--- a/web/entries/Subset_Boolean_Algebras.html
+++ b/web/entries/Subset_Boolean_Algebras.html
@@ -1,205 +1,210 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Hierarchy of Algebras for Boolean Subsets - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">H</font>ierarchy
of
<font class="first">A</font>lgebras
for
<font class="first">B</font>oolean
<font class="first">S</font>ubsets
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Hierarchy of Algebras for Boolean Subsets</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a> and
<a href="https://www.informatik.uni-augsburg.de/en/chairs/dbis/pmi/staff/moeller/">Bernhard Möller</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-01-31</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We present a collection of axiom systems for the construction of
Boolean subalgebras of larger overall algebras. The subalgebras are
defined as the range of a complement-like operation on a semilattice.
This technique has been used, for example, with the antidomain
operation, dynamic negation and Stone algebras. We present a common
ground for these constructions based on a new equational
axiomatisation of Boolean algebras.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Subset_Boolean_Algebras-AFP,
author = {Walter Guttmann and Bernhard Möller},
title = {A Hierarchy of Algebras for Boolean Subsets},
journal = {Archive of Formal Proofs},
month = jan,
year = 2020,
note = {\url{https://isa-afp.org/entries/Subset_Boolean_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>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Subset_Boolean_Algebras/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Subset_Boolean_Algebras/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Subset_Boolean_Algebras/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Subset_Boolean_Algebras-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Subset_Boolean_Algebras-2020-04-20.tar.gz">
+ afp-Subset_Boolean_Algebras-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Subset_Boolean_Algebras-2020-01-31.tar.gz">
afp-Subset_Boolean_Algebras-2020-01-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/SumSquares.html b/web/entries/SumSquares.html
--- a/web/entries/SumSquares.html
+++ b/web/entries/SumSquares.html
@@ -1,278 +1,283 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-SumSquares-2020-04-20.tar.gz">
+ afp-SumSquares-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-SumSquares-2019-06-11.tar.gz">
afp-SumSquares-2019-06-11.tar.gz
</a>
</li>
<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,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-SuperCalc-2020-04-20.tar.gz">
+ afp-SuperCalc-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-SuperCalc-2019-06-11.tar.gz">
afp-SuperCalc-2019-06-11.tar.gz
</a>
</li>
<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,212 +1,217 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>urprise
<font class="first">P</font>aradox
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Surprise_Paradox-2020-04-20.tar.gz">
+ afp-Surprise_Paradox-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Surprise_Paradox-2019-06-11.tar.gz">
afp-Surprise_Paradox-2019-06-11.tar.gz
</a>
</li>
<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,219 +1,224 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>ymmetric
<font class="first">P</font>olynomials
</h1>
<p>&nbsp;</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 mathjax_process">
<p>A symmetric polynomial is a polynomial in variables
<em>X</em><sub>1</sub>,&hellip;,<em>X</em><sub>n</sub>
that does not discriminate between its variables, i.&thinsp;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>,&hellip;,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>,&hellip;,<em>x</em><sub>n</sub>,
namely
<em>c</em><sub><em>k</em></sub> = (-1)<sup><em>n</em>-<em>k</em></sup>&thinsp;e<sub><em>n</em>-<em>k</em></sub>(<em>x</em><sub>1</sub>,&hellip;,<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{https://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>, <a href="Power_Sum_Polynomials.html">Power_Sum_Polynomials</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Symmetric_Polynomials-2020-04-20.tar.gz">
+ afp-Symmetric_Polynomials-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Symmetric_Polynomials-2019-06-11.tar.gz">
afp-Symmetric_Polynomials-2019-06-11.tar.gz
</a>
</li>
<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/Syntax_Independent_Logic.html b/web/entries/Syntax_Independent_Logic.html
--- a/web/entries/Syntax_Independent_Logic.html
+++ b/web/entries/Syntax_Independent_Logic.html
@@ -1,207 +1,213 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Syntax-Independent Logic Infrastructure - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>yntax-Independent
<font class="first">L</font>ogic
<font class="first">I</font>nfrastructure
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Syntax-Independent Logic Infrastructure</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://www.andreipopescu.uk">Andrei Popescu</a> and
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-09-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We formalize a notion of logic whose terms and formulas are kept
abstract. In particular, logical connectives, substitution, free
variables, and provability are not defined, but characterized by their
general properties as locale assumptions. Based on this abstract
characterization, we develop further reusable reasoning
infrastructure. For example, we define parallel substitution (along
with proving its characterizing theorems) from single-point
substitution. Similarly, we develop a natural deduction style proof
system starting from the abstract Hilbert-style one. These one-time
efforts benefit different concrete logics satisfying our locales'
assumptions. We instantiate the syntax-independent logic
infrastructure to Robinson arithmetic (also known as Q) in the AFP
entry <a
href="https://www.isa-afp.org/entries/Robinson_Arithmetic.html">Robinson_Arithmetic</a>
and to hereditarily finite set theory in the AFP entries <a
href="https://www.isa-afp.org/entries/Goedel_HFSet_Semantic.html">Goedel_HFSet_Semantic</a>
and <a
href="https://www.isa-afp.org/entries/Goedel_HFSet_Semanticless.html">Goedel_HFSet_Semanticless</a>,
which are part of our formalization of G&ouml;del's
Incompleteness Theorems described in our CADE-27 paper <a
href="https://dx.doi.org/10.1007/978-3-030-29436-6_26">A
Formally Verified Abstract Account of Gödel's Incompleteness
Theorems</a>.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Syntax_Independent_Logic-AFP,
author = {Andrei Popescu and Dmitriy Traytel},
title = {Syntax-Independent Logic Infrastructure},
journal = {Archive of Formal Proofs},
month = sep,
year = 2020,
note = {\url{https://isa-afp.org/entries/Syntax_Independent_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">Used by:</td>
<td class="data"><a href="Goedel_Incompleteness.html">Goedel_Incompleteness</a>, <a href="Robinson_Arithmetic.html">Robinson_Arithmetic</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Syntax_Independent_Logic/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Syntax_Independent_Logic/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Syntax_Independent_Logic/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Syntax_Independent_Logic-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Syntax_Independent_Logic-2020-09-18.tar.gz">
+ afp-Syntax_Independent_Logic-2020-09-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/Szpilrajn.html b/web/entries/Szpilrajn.html
--- a/web/entries/Szpilrajn.html
+++ b/web/entries/Szpilrajn.html
@@ -1,190 +1,195 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Szpilrajn Extension 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>zpilrajn
<font class="first">E</font>xtension
<font class="first">T</font>heorem
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Szpilrajn Extension Theorem</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
Peter Zeller (p_zeller /at/ cs /dot/ uni-kl /dot/ de)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-07-27</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We formalize the Szpilrajn extension theorem, also known as
order-extension principal: Every strict partial order can be extended
to a strict linear order.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Szpilrajn-AFP,
author = {Peter Zeller},
title = {Szpilrajn Extension Theorem},
journal = {Archive of Formal Proofs},
month = jul,
year = 2019,
note = {\url{https://isa-afp.org/entries/Szpilrajn.html},
Formal proof development},
ISSN = {2150-914x},
}</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/Szpilrajn/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Szpilrajn/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Szpilrajn/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Szpilrajn-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Szpilrajn-2020-04-20.tar.gz">
+ afp-Szpilrajn-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Szpilrajn-2019-07-28.tar.gz">
afp-Szpilrajn-2019-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/TESL_Language.html b/web/entries/TESL_Language.html
--- a/web/entries/TESL_Language.html
+++ b/web/entries/TESL_Language.html
@@ -1,229 +1,234 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Formal Development of a Polychronous Polytimed Coordination 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">F</font>ormal
<font class="first">D</font>evelopment
of
a
<font class="first">P</font>olychronous
<font class="first">P</font>olytimed
<font class="first">C</font>oordination
<font class="first">L</font>anguage
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Formal Development of a Polychronous Polytimed Coordination Language</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Hai Nguyen Van (hai /dot/ nguyenvan /dot/ phie /at/ gmail /dot/ com),
Frédéric Boulanger (frederic /dot/ boulanger /at/ centralesupelec /dot/ fr) and
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-07-30</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
The design of complex systems involves different formalisms for
modeling their different parts or aspects. The global model of a
system may therefore consist of a coordination of concurrent
sub-models that use different paradigms. We develop here a theory for
a language used to specify the timed coordination of such
heterogeneous subsystems by addressing the following issues:
<ul><li>the
behavior of the sub-systems is observed only at a series of discrete
instants,</li><li>events may occur in different sub-systems at unrelated
times, leading to polychronous systems, which do not necessarily have
a common base clock,</li><li>coordination between subsystems involves
causality, so the occurrence of an event may enforce the occurrence of
other events, possibly after a certain duration has elapsed or an
event has occurred a given number of times,</li><li>the domain of time
(discrete, rational, continuous...) may be different in the
subsystems, leading to polytimed systems,</li><li>the time frames of
different sub-systems may be related (for instance, time in a GPS
satellite and in a GPS receiver on Earth are related although they are
not the same).</li></ul>
Firstly, a denotational semantics of the language is
defined. Then, in order to be able to incrementally check the behavior
of systems, an operational semantics is given, with proofs of
progress, soundness and completeness with regard to the denotational
semantics. These proofs are made according to a setup that can scale
up when new operators are added to the language. In order for
specifications to be composed in a clean way, the language should be
invariant by stuttering (i.e., adding observation instants at which
nothing happens). The proof of this invariance is also given.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{TESL_Language-AFP,
author = {Hai Nguyen Van and Frédéric Boulanger and Burkhart Wolff},
title = {A Formal Development of a Polychronous Polytimed Coordination Language},
journal = {Archive of Formal Proofs},
month = jul,
year = 2019,
note = {\url{https://isa-afp.org/entries/TESL_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/TESL_Language/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/TESL_Language/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/TESL_Language/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-TESL_Language-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-TESL_Language-2020-04-20.tar.gz">
+ afp-TESL_Language-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-TESL_Language-2019-07-31.tar.gz">
afp-TESL_Language-2019-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/TLA.html b/web/entries/TLA.html
--- a/web/entries/TLA.html
+++ b/web/entries/TLA.html
@@ -1,274 +1,279 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-TLA-2020-04-20.tar.gz">
+ afp-TLA-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-TLA-2019-06-11.tar.gz">
afp-TLA-2019-06-11.tar.gz
</a>
</li>
<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,257 +1,262 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Tail_Recursive_Functions-2020-04-20.tar.gz">
+ afp-Tail_Recursive_Functions-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Tail_Recursive_Functions-2019-06-11.tar.gz">
afp-Tail_Recursive_Functions-2019-06-11.tar.gz
</a>
</li>
<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,260 +1,265 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Tarskis_Geometry-2020-04-20.tar.gz">
+ afp-Tarskis_Geometry-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Tarskis_Geometry-2019-06-11.tar.gz">
afp-Tarskis_Geometry-2019-06-11.tar.gz
</a>
</li>
<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,207 +1,212 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>aylor
<font class="first">M</font>odels
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Taylor_Models-2020-04-20.tar.gz">
+ afp-Taylor_Models-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Taylor_Models-2019-06-11.tar.gz">
afp-Taylor_Models-2019-06-11.tar.gz
</a>
</li>
<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,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>imed
<font class="first">A</font>utomata
</h1>
<p>&nbsp;</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://home.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Timed_Automata-2020-04-20.tar.gz">
+ afp-Timed_Automata-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Timed_Automata-2019-06-11.tar.gz">
afp-Timed_Automata-2019-06-11.tar.gz
</a>
</li>
<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/Topological_Semantics.html b/web/entries/Topological_Semantics.html
--- a/web/entries/Topological_Semantics.html
+++ b/web/entries/Topological_Semantics.html
@@ -1,199 +1,205 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Topological semantics for paraconsistent and paracomplete 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>opological
semantics
for
paraconsistent
and
paracomplete
logics
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Topological semantics for paraconsistent and paracomplete logics</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
David Fuenmayor (davfuenmayor /at/ gmail /dot/ com)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-12-17</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We introduce a generalized topological semantics for paraconsistent
and paracomplete logics by drawing upon early works on topological
Boolean algebras (cf. works by Kuratowski, Zarycki, McKinsey &
Tarski, etc.). In particular, this work exemplarily illustrates the
shallow semantical embeddings approach (<a
href="http://dx.doi.org/10.1007/s11787-012-0052-y">SSE</a>)
employing the proof assistant Isabelle/HOL. By means of the SSE
technique we can effectively harness theorem provers, model finders
and 'hammers' for reasoning with quantified non-classical
logics.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Topological_Semantics-AFP,
author = {David Fuenmayor},
title = {Topological semantics for paraconsistent and paracomplete logics},
journal = {Archive of Formal Proofs},
month = dec,
year = 2020,
note = {\url{https://isa-afp.org/entries/Topological_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>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Topological_Semantics/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Topological_Semantics/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Topological_Semantics/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Topological_Semantics-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Topological_Semantics-2020-12-22.tar.gz">
+ afp-Topological_Semantics-2020-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/Topology.html b/web/entries/Topology.html
--- a/web/entries/Topology.html
+++ b/web/entries/Topology.html
@@ -1,290 +1,295 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>opology
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Topology-2020-04-20.tar.gz">
+ afp-Topology-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Topology-2019-06-11.tar.gz">
afp-Topology-2019-06-11.tar.gz
</a>
</li>
<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,211 +1,216 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-TortoiseHare-2020-04-20.tar.gz">
+ afp-TortoiseHare-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-TortoiseHare-2019-06-11.tar.gz">
afp-TortoiseHare-2019-06-11.tar.gz
</a>
</li>
<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,207 +1,212 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Transcendence_Series_Hancl_Rucki-2020-04-20.tar.gz">
+ afp-Transcendence_Series_Hancl_Rucki-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Transcendence_Series_Hancl_Rucki-2019-06-11.tar.gz">
afp-Transcendence_Series_Hancl_Rucki-2019-06-11.tar.gz
</a>
</li>
<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,204 +1,209 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>ransformer
<font class="first">S</font>emantics
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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>
<tr><td class="datahead">Used by:</td>
<td class="data"><a href="Hybrid_Systems_VCs.html">Hybrid_Systems_VCs</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Transformer_Semantics-2020-04-20.tar.gz">
+ afp-Transformer_Semantics-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Transformer_Semantics-2019-06-11.tar.gz">
afp-Transformer_Semantics-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>ransition
<font class="first">S</font>ystems
and
<font class="first">A</font>utomata
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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="Adaptive_State_Counting.html">Adaptive_State_Counting</a>, <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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Transition_Systems_and_Automata-2020-04-20.tar.gz">
+ afp-Transition_Systems_and_Automata-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Transition_Systems_and_Automata-2019-06-11.tar.gz">
afp-Transition_Systems_and_Automata-2019-06-11.tar.gz
</a>
</li>
<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,263 +1,268 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">E</font>xecutable
<font class="first">T</font>ransitive
<font class="first">C</font>losures
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Transitive-Closure-II-2020-04-20.tar.gz">
+ afp-Transitive-Closure-II-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Transitive-Closure-II-2019-06-11.tar.gz">
afp-Transitive-Closure-II-2019-06-11.tar.gz
</a>
</li>
<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,267 +1,272 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Transitive-Closure-2020-04-20.tar.gz">
+ afp-Transitive-Closure-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Transitive-Closure-2019-06-11.tar.gz">
afp-Transitive-Closure-2019-06-11.tar.gz
</a>
</li>
<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,218 +1,223 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>reaps
</h1>
<p>&nbsp;</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="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Maximilian Haslbeck</a>,
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a> and
<a href="http://www21.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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Treaps-2020-04-20.tar.gz">
+ afp-Treaps-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Treaps-2019-06-11.tar.gz">
afp-Treaps-2019-06-11.tar.gz
</a>
</li>
<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,282 +1,287 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>ree
<font class="first">A</font>utomata
</h1>
<p>&nbsp;</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">
Peter Lammich
</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Tree-Automata-2020-04-20.tar.gz">
+ afp-Tree-Automata-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Tree-Automata-2019-06-11.tar.gz">
afp-Tree-Automata-2019-06-11.tar.gz
</a>
</li>
<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,215 +1,220 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>ree
<font class="first">D</font>ecomposition
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Tree_Decomposition-2020-04-20.tar.gz">
+ afp-Tree_Decomposition-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Tree_Decomposition-2019-06-11.tar.gz">
afp-Tree_Decomposition-2019-06-11.tar.gz
</a>
</li>
<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,229 +1,234 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Triangle-2020-04-20.tar.gz">
+ afp-Triangle-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Triangle-2019-06-11.tar.gz">
afp-Triangle-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>rie
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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="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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Trie-2020-04-20.tar.gz">
+ afp-Trie-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Trie-2019-06-11.tar.gz">
afp-Trie-2019-06-11.tar.gz
</a>
</li>
<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,213 +1,218 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">T</font>welvefold
<font class="first">W</font>ay
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Twelvefold_Way-2020-04-20.tar.gz">
+ afp-Twelvefold_Way-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Twelvefold_Way-2019-06-11.tar.gz">
afp-Twelvefold_Way-2019-06-11.tar.gz
</a>
</li>
<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,255 +1,260 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Tycon-2020-04-20.tar.gz">
+ afp-Tycon-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Tycon-2019-06-11.tar.gz">
afp-Tycon-2019-06-11.tar.gz
</a>
</li>
<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,222 +1,227 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Types_Tableaus_and_Goedels_God-2020-04-20.tar.gz">
+ afp-Types_Tableaus_and_Goedels_God-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Types_Tableaus_and_Goedels_God-2019-06-11.tar.gz">
afp-Types_Tableaus_and_Goedels_God-2019-06-11.tar.gz
</a>
</li>
<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,241 +1,246 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-UPF-2020-04-20.tar.gz">
+ afp-UPF-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-UPF-2019-06-11.tar.gz">
afp-UPF-2019-06-11.tar.gz
</a>
</li>
<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,225 +1,230 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-UPF_Firewall-2020-04-20.tar.gz">
+ afp-UPF_Firewall-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-UPF_Firewall-2019-06-11.tar.gz">
afp-UPF_Firewall-2019-06-11.tar.gz
</a>
</li>
<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,220 +1,225 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</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 mathjax_process">
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{https://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>
</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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-UTP-2020-04-20.tar.gz">
+ afp-UTP-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-UTP-2019-06-11.tar.gz">
afp-UTP-2019-06-11.tar.gz
</a>
</li>
<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,200 +1,205 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">U</font>niversal
<font class="first">T</font>uring
<font class="first">M</font>achine
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Universal_Turing_Machine-2020-04-20.tar.gz">
+ afp-Universal_Turing_Machine-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Universal_Turing_Machine-2019-06-11.tar.gz">
afp-Universal_Turing_Machine-2019-06-11.tar.gz
</a>
</li>
<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,235 +1,240 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">V</font>erification
of
the
<font class="first">U</font>pDown
<font class="first">S</font>cheme
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-UpDown_Scheme-2020-04-20.tar.gz">
+ afp-UpDown_Scheme-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-UpDown_Scheme-2019-06-11.tar.gz">
afp-UpDown_Scheme-2019-06-11.tar.gz
</a>
</li>
<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,294 +1,299 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Valuation-2020-04-20.tar.gz">
+ afp-Valuation-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Valuation-2019-06-11.tar.gz">
afp-Valuation-2019-06-11.tar.gz
</a>
</li>
<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,227 +1,232 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">V</font>ector
<font class="first">S</font>paces
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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="Isabelle_Marries_Dirac.html">Isabelle_Marries_Dirac</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-VectorSpace-2020-04-20.tar.gz">
+ afp-VectorSpace-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-VectorSpace-2019-06-11.tar.gz">
afp-VectorSpace-2019-06-11.tar.gz
</a>
</li>
<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/VeriComp.html b/web/entries/VeriComp.html
--- a/web/entries/VeriComp.html
+++ b/web/entries/VeriComp.html
@@ -1,202 +1,207 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>A Generic Framework for Verified Compilers - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">A</font>
<font class="first">G</font>eneric
<font class="first">F</font>ramework
for
<font class="first">V</font>erified
<font class="first">C</font>ompilers
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">A Generic Framework for Verified Compilers</td>
</tr>
<tr>
<td class="datahead">
Author:
</td>
<td class="data">
<a href="https://martin.desharnais.me">Martin Desharnais</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-02-10</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
This is a generic framework for formalizing compiler transformations.
It leverages Isabelle/HOL’s locales to abstract over concrete
languages and transformations. It states common definitions for
language semantics, program behaviours, forward and backward
simulations, and compilers. We provide generic operations, such as
simulation and compiler composition, and prove general (partial)
correctness theorems, resulting in reusable proof components.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{VeriComp-AFP,
author = {Martin Desharnais},
title = {A Generic Framework for Verified Compilers},
journal = {Archive of Formal Proofs},
month = feb,
year = 2020,
note = {\url{https://isa-afp.org/entries/VeriComp.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Interpreter_Optimizations.html">Interpreter_Optimizations</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/VeriComp/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/VeriComp/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/VeriComp/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-VeriComp-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-VeriComp-2020-04-20.tar.gz">
+ afp-VeriComp-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-VeriComp-2020-02-25.tar.gz">
afp-VeriComp-2020-02-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/Verified-Prover.html b/web/entries/Verified-Prover.html
--- a/web/entries/Verified-Prover.html
+++ b/web/entries/Verified-Prover.html
@@ -1,307 +1,312 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Verified-Prover-2020-04-20.tar.gz">
+ afp-Verified-Prover-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Verified-Prover-2019-06-11.tar.gz">
afp-Verified-Prover-2019-06-11.tar.gz
</a>
</li>
<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/Verified_SAT_Based_AI_Planning.html b/web/entries/Verified_SAT_Based_AI_Planning.html
--- a/web/entries/Verified_SAT_Based_AI_Planning.html
+++ b/web/entries/Verified_SAT_Based_AI_Planning.html
@@ -1,194 +1,205 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Verified SAT-Based AI Planning - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">V</font>erified
<font class="first">S</font>AT-Based
<font class="first">A</font>I
<font class="first">P</font>lanning
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Verified SAT-Based AI Planning</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="http://home.in.tum.de/~mansour/">Mohammad Abdulaziz</a> and
Friedrich Kurz
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-10-29</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
We present an executable formally verified SAT encoding of classical
AI planning that is based on the encodings by Kautz and Selman and the
one by Rintanen et al. The encoding was experimentally tested and
shown to be usable for reasonably sized standard AI planning
benchmarks. We also use it as a reference to test a state-of-the-art
SAT-based planner, showing that it sometimes falsely claims that
problems have no solutions of certain lengths. The formalisation in
this submission was described in an independent publication.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Verified_SAT_Based_AI_Planning-AFP,
author = {Mohammad Abdulaziz and Friedrich Kurz},
title = {Verified SAT-Based AI Planning},
journal = {Archive of Formal Proofs},
month = oct,
year = 2020,
note = {\url{https://isa-afp.org/entries/Verified_SAT_Based_AI_Planning.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="AI_Planning_Languages_Semantics.html">AI_Planning_Languages_Semantics</a>, <a href="List-Index.html">List-Index</a>, <a href="Propositional_Proof_Systems.html">Propositional_Proof_Systems</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Verified_SAT_Based_AI_Planning/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Verified_SAT_Based_AI_Planning/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Verified_SAT_Based_AI_Planning/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Verified_SAT_Based_AI_Planning-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
- None
+ <ul>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Verified_SAT_Based_AI_Planning-2020-11-13.tar.gz">
+ afp-Verified_SAT_Based_AI_Planning-2020-11-13.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2020:
+ <a href="../release/afp-Verified_SAT_Based_AI_Planning-2020-11-03.tar.gz">
+ afp-Verified_SAT_Based_AI_Planning-2020-11-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/VerifyThis2018.html b/web/entries/VerifyThis2018.html
--- a/web/entries/VerifyThis2018.html
+++ b/web/entries/VerifyThis2018.html
@@ -1,210 +1,215 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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">
Peter Lammich and
<a href="http://home.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 mathjax_process">
<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{https://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>
</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-VerifyThis2018-2020-04-20.tar.gz">
+ afp-VerifyThis2018-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-VerifyThis2018-2019-06-11.tar.gz">
afp-VerifyThis2018-2019-06-11.tar.gz
</a>
</li>
<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/VerifyThis2019.html b/web/entries/VerifyThis2019.html
--- a/web/entries/VerifyThis2019.html
+++ b/web/entries/VerifyThis2019.html
@@ -1,199 +1,204 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>VerifyThis 2019 -- 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">V</font>erifyThis
<font class="first">2</font>019
<font class="first">-</font>-
<font class="first">P</font>olished
<font class="first">I</font>sabelle
<font class="first">S</font>olutions
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">VerifyThis 2019 -- Polished Isabelle Solutions</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
Peter Lammich and
<a href="http://home.in.tum.de/~wimmers/">Simon Wimmer</a>
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2019-10-16</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
VerifyThis 2019 (http://www.pm.inf.ethz.ch/research/verifythis.html)
was a program verification competition associated with ETAPS 2019. It
was the 8th 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{VerifyThis2019-AFP,
author = {Peter Lammich and Simon Wimmer},
title = {VerifyThis 2019 -- Polished Isabelle Solutions},
journal = {Archive of Formal Proofs},
month = oct,
year = 2019,
note = {\url{https://isa-afp.org/entries/VerifyThis2019.html},
Formal proof development},
ISSN = {2150-914x},
}</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/VerifyThis2019/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/VerifyThis2019/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/VerifyThis2019/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-VerifyThis2019-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-VerifyThis2019-2020-04-20.tar.gz">
+ afp-VerifyThis2019-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-VerifyThis2019-2019-10-25.tar.gz">
afp-VerifyThis2019-2019-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/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,240 +1,245 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Vickrey_Clarke_Groves-2020-04-20.tar.gz">
+ afp-Vickrey_Clarke_Groves-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Vickrey_Clarke_Groves-2019-06-11.tar.gz">
afp-Vickrey_Clarke_Groves-2019-06-11.tar.gz
</a>
</li>
<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,280 +1,285 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-VolpanoSmith-2020-04-20.tar.gz">
+ afp-VolpanoSmith-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-VolpanoSmith-2019-06-11.tar.gz">
afp-VolpanoSmith-2019-06-11.tar.gz
</a>
</li>
<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,259 +1,264 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-WHATandWHERE_Security-2020-04-20.tar.gz">
+ afp-WHATandWHERE_Security-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-WHATandWHERE_Security-2019-06-11.tar.gz">
afp-WHATandWHERE_Security-2019-06-11.tar.gz
</a>
</li>
<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/WOOT_Strong_Eventual_Consistency.html b/web/entries/WOOT_Strong_Eventual_Consistency.html
--- a/web/entries/WOOT_Strong_Eventual_Consistency.html
+++ b/web/entries/WOOT_Strong_Eventual_Consistency.html
@@ -1,209 +1,214 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Strong Eventual Consistency of the Collaborative Editing Framework WOOT - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">S</font>trong
<font class="first">E</font>ventual
<font class="first">C</font>onsistency
of
the
<font class="first">C</font>ollaborative
<font class="first">E</font>diting
<font class="first">F</font>ramework
<font class="first">W</font>OOT
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Strong Eventual Consistency of the Collaborative Editing Framework WOOT</td>
</tr>
<tr>
<td class="datahead">
Authors:
</td>
<td class="data">
<a href="https://orcid.org/0000-0003-3290-5034">Emin Karayel</a> and
Edgar Gonzàlez (edgargip /at/ google /dot/ com)
</td>
</tr>
<tr>
<td class="datahead">Submission date:</td>
<td class="data">2020-03-25</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
Commutative Replicated Data Types (CRDTs) are a promising new class of
data structures for large-scale shared mutable content in applications
that only require eventual consistency. The WithOut Operational
Transforms (WOOT) framework is a CRDT for collaborative text editing
introduced by Oster et al. (CSCW 2006) for which the eventual
consistency property was verified only for a bounded model to date. We
contribute a formal proof for WOOTs strong eventual consistency.</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{WOOT_Strong_Eventual_Consistency-AFP,
author = {Emin Karayel and Edgar Gonzàlez},
title = {Strong Eventual Consistency of the Collaborative Editing Framework WOOT},
journal = {Archive of Formal Proofs},
month = mar,
year = 2020,
note = {\url{https://isa-afp.org/entries/WOOT_Strong_Eventual_Consistency.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="Datatype_Order_Generator.html">Datatype_Order_Generator</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/WOOT_Strong_Eventual_Consistency/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/WOOT_Strong_Eventual_Consistency/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/WOOT_Strong_Eventual_Consistency/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-WOOT_Strong_Eventual_Consistency-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-WOOT_Strong_Eventual_Consistency-2020-04-20.tar.gz">
+ afp-WOOT_Strong_Eventual_Consistency-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-WOOT_Strong_Eventual_Consistency-2020-03-26.tar.gz">
afp-WOOT_Strong_Eventual_Consistency-2020-03-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/WebAssembly.html b/web/entries/WebAssembly.html
--- a/web/entries/WebAssembly.html
+++ b/web/entries/WebAssembly.html
@@ -1,206 +1,211 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">W</font>ebAssembly
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-WebAssembly-2020-04-20.tar.gz">
+ afp-WebAssembly-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-WebAssembly-2019-06-11.tar.gz">
afp-WebAssembly-2019-06-11.tar.gz
</a>
</li>
<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,204 +1,209 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">W</font>eight-Balanced
<font class="first">T</font>rees
</h1>
<p>&nbsp;</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="http://www21.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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Weight_Balanced_Trees-2020-04-20.tar.gz">
+ afp-Weight_Balanced_Trees-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Weight_Balanced_Trees-2019-06-11.tar.gz">
afp-Weight_Balanced_Trees-2019-06-11.tar.gz
</a>
</li>
<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,264 +1,269 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">W</font>ell-Quasi-Orders
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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>, <a href="Saturation_Framework.html">Saturation_Framework</a>, <a href="Saturation_Framework_Extensions.html">Saturation_Framework_Extensions</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Well_Quasi_Orders-2020-04-20.tar.gz">
+ afp-Well_Quasi_Orders-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Well_Quasi_Orders-2019-06-11.tar.gz">
afp-Well_Quasi_Orders-2019-06-11.tar.gz
</a>
</li>
<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,214 +1,219 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Winding_Number_Eval-2020-04-20.tar.gz">
+ afp-Winding_Number_Eval-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Winding_Number_Eval-2019-06-11.tar.gz">
afp-Winding_Number_Eval-2019-06-11.tar.gz
</a>
</li>
<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,226 +1,231 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
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{https://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="Interval_Arithmetic_Word32.html">Interval_Arithmetic_Word32</a>, <a href="IP_Addresses.html">IP_Addresses</a>, <a href="Native_Word.html">Native_Word</a>, <a href="SPARCv8.html">SPARCv8</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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Word_Lib-2020-04-20.tar.gz">
+ afp-Word_Lib-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Word_Lib-2019-06-11.tar.gz">
afp-Word_Lib-2019-06-11.tar.gz
</a>
</li>
<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,267 +1,272 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">W</font>orker/Wrapper
<font class="first">T</font>ransformation
</h1>
<p>&nbsp;</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 mathjax_process">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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-WorkerWrapper-2020-04-20.tar.gz">
+ afp-WorkerWrapper-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-WorkerWrapper-2019-06-11.tar.gz">
afp-WorkerWrapper-2019-06-11.tar.gz
</a>
</li>
<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,223 +1,228 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">X</font>ML
</h1>
<p>&nbsp;</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 mathjax_process">
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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-XML-2020-04-20.tar.gz">
+ afp-XML-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-XML-2019-06-11.tar.gz">
afp-XML-2019-06-11.tar.gz
</a>
</li>
<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/ZFC_in_HOL.html b/web/entries/ZFC_in_HOL.html
--- a/web/entries/ZFC_in_HOL.html
+++ b/web/entries/ZFC_in_HOL.html
@@ -1,223 +1,228 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Zermelo Fraenkel Set Theory 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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">Z</font>ermelo
<font class="first">F</font>raenkel
<font class="first">S</font>et
<font class="first">T</font>heory
in
<font class="first">H</font>igher-Order
<font class="first">L</font>ogic
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">Zermelo Fraenkel Set Theory in Higher-Order Logic</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">2019-10-24</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>This entry is a new formalisation of ZFC set theory in Isabelle/HOL. It is
logically equivalent to Obua's HOLZF; the point is to have the closest
possible integration with the rest of Isabelle/HOL, minimising the amount of
new notations and exploiting type classes.</p>
<p>There is a type <em>V</em> of sets and a function <em>elts :: V =&gt; V
set</em> mapping a set to its elements. Classes simply have type <em>V
set</em>, and a predicate identifies the small classes: those that correspond
to actual sets. Type classes connected with orders and lattices are used to
minimise the amount of new notation for concepts such as the subset relation,
union and intersection. Basic concepts — Cartesian products, disjoint sums,
natural numbers, functions, etc. — are formalised.</p>
<p>More advanced set-theoretic concepts, such as transfinite induction,
ordinals, cardinals and the transitive closure of a set, are also provided.
The definition of addition and multiplication for general sets (not just
ordinals) follows Kirby.</p>
<p>The theory provides two type classes with the aim of facilitating
developments that combine <em>V</em> with other Isabelle/HOL types:
<em>embeddable</em>, the class of types that can be injected into <em>V</em>
(including <em>V</em> itself as well as <em>V*V</em>, etc.), and
<em>small</em>, the class of types that correspond to some ZF set.</p>
extra-history =
Change history:
[2020-01-28]: Generalisation of the "small" predicate and order types to arbitrary sets;
ordinal exponentiation;
introduction of the coercion ord_of_nat :: "nat => V";
numerous new lemmas. (revision 6081d5be8d08)</td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{ZFC_in_HOL-AFP,
author = {Lawrence C. Paulson},
title = {Zermelo Fraenkel Set Theory in Higher-Order Logic},
journal = {Archive of Formal Proofs},
month = oct,
year = 2019,
note = {\url{https://isa-afp.org/entries/ZFC_in_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="Ordinal_Partitions.html">Ordinal_Partitions</a> </td></tr>
</tbody>
</table>
<p></p>
<table class="links">
<tbody>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/ZFC_in_HOL/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/ZFC_in_HOL/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/ZFC_in_HOL/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-ZFC_in_HOL-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-ZFC_in_HOL-2020-04-20.tar.gz">
+ afp-ZFC_in_HOL-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-ZFC_in_HOL-2019-11-04.tar.gz">
afp-ZFC_in_HOL-2019-11-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/Zeta_3_Irrational.html b/web/entries/Zeta_3_Irrational.html
--- a/web/entries/Zeta_3_Irrational.html
+++ b/web/entries/Zeta_3_Irrational.html
@@ -1,198 +1,203 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>The Irrationality of ζ(3) - Archive of Formal Proofs
</title>
<link rel="stylesheet" type="text/css" href="../front.css">
<link rel="icon" href="../images/favicon.ico" type="image/icon">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> <font class="first">T</font>he
<font class="first">I</font>rrationality
of
ζ(3)
</h1>
<p>&nbsp;</p>
<table width="80%" class="data">
<tbody>
<tr>
<td class="datahead" width="20%">Title:</td>
<td class="data" width="80%">The Irrationality of ζ(3)</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-12-27</td>
</tr>
<tr>
<td class="datahead" valign="top">Abstract:</td>
<td class="abstract mathjax_process">
<p>This article provides a formalisation of Beukers's
straightforward analytic proof that ζ(3) is irrational. This was first
proven by Apéry (which is why this result is also often called
‘Apéry's Theorem’) using a more algebraic approach. This
formalisation follows <a
href="http://people.math.sc.edu/filaseta/gradcourses/Math785/Math785Notes4.pdf">Filaseta's
presentation</a> of Beukers's proof.</p></td>
</tr>
<tr>
<td class="datahead" valign="top">BibTeX:</td>
<td class="formatted">
<pre>@article{Zeta_3_Irrational-AFP,
author = {Manuel Eberl},
title = {The Irrationality of ζ(3)},
journal = {Archive of Formal Proofs},
month = dec,
year = 2019,
note = {\url{https://isa-afp.org/entries/Zeta_3_Irrational.html},
Formal proof development},
ISSN = {2150-914x},
}</pre>
</td>
</tr>
<tr><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="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_3_Irrational/outline.pdf">Proof outline</a><br>
<a href="../browser_info/current/AFP/Zeta_3_Irrational/document.pdf">Proof document</a>
</td>
</tr>
<tr>
<td class="links">
<a href="../browser_info/current/AFP/Zeta_3_Irrational/index.html">Browse theories</a>
</td></tr>
<tr>
<td class="links">
<a href="../release/afp-Zeta_3_Irrational-current.tar.gz">Download this entry</a>
</td>
</tr>
<tr><td class="links">Older releases:
<ul>
- <li>Isabelle 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Zeta_3_Irrational-2020-04-20.tar.gz">
+ afp-Zeta_3_Irrational-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Zeta_3_Irrational-2019-12-28.tar.gz">
afp-Zeta_3_Irrational-2019-12-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/Zeta_Function.html b/web/entries/Zeta_Function.html
--- a/web/entries/Zeta_Function.html
+++ b/web/entries/Zeta_Function.html
@@ -1,228 +1,233 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</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>&nbsp;</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 mathjax_process">
<p>This entry builds upon the results about formal and analytic Dirichlet
series to define the Hurwitz &zeta; function &zeta;(<em>a</em>,<em>s</em>) and,
based on that, the Riemann &zeta; function &zeta;(<em>s</em>).
This is done by first defining them for &real;(<em>z</em>) > 1
and then successively extending the domain to the left using the
Euler&ndash;MacLaurin formula.</p>
<p>Apart from the most basic facts such as analyticity, the following
results are provided:</p>
<ul>
<li>the Stieltjes constants and the Laurent expansion of
&zeta;(<em>s</em>) at <em>s</em> = 1</li>
<li>the non-vanishing of &zeta;(<em>s</em>)
for &real;(<em>z</em>) &ge; 1</li>
<li>the relationship between &zeta;(<em>a</em>,<em>s</em>) and &Gamma;</li>
<li>the special values at negative integers and positive even integers</li>
<li>Hurwitz's formula and the reflection formula for &zeta;(<em>s</em>)</li>
<li>the <a href="https://arxiv.org/abs/math/0405478">
Hadjicostas&ndash;Chapman formula</a></li>
</ul>
<p>The entry also contains Euler's analytic proof of the infinitude of primes,
based on the fact that &zeta;(<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-Zeta_Function-2020-04-20.tar.gz">
+ afp-Zeta_Function-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-Zeta_Function-2019-06-11.tar.gz">
afp-Zeta_Function-2019-06-11.tar.gz
</a>
</li>
<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,230 +1,235 @@
<!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">
<!-- MathJax for LaTeX support in abstracts -->
<script>
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
processEscapes: true,
svg: {
fontCache: 'global'
}
};
</script>
<script id="MathJax-script" async src="../components/mathjax/es5/tex-mml-chtml.js"></script>
</head>
<body class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="../images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="../index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="../about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="../submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="../updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="../search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="../statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="../topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="../download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1> pGCL
for
<font class="first">I</font>sabelle
</h1>
<p>&nbsp;</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 mathjax_process">
<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{https://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 2019:
+ <li>Isabelle 2020:
+ <a href="../release/afp-pGCL-2020-04-20.tar.gz">
+ afp-pGCL-2020-04-20.tar.gz
+ </a>
+ </li>
+ <li>Isabelle 2019:
<a href="../release/afp-pGCL-2019-06-11.tar.gz">
afp-pGCL-2019-06-11.tar.gz
</a>
</li>
<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,5340 +1,5356 @@
<!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 class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1><font class="first">A</font>rchive of
<font class="first">F</font>ormal
<font class="first">P</font>roofs</h1>
</h1>
<p>&nbsp;</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>&nbsp;</p>
<p>&nbsp;</p>
<table width="80%" class="entries">
<tbody>
<tr>
<td class="head">2021</td>
</tr>
<tr>
<td class="entry">
+ 2021-02-24: <a href="entries/BTree.html">A Verified Imperative Implementation of B-Trees</a>
+ <br>
+ Author:
+ Niels Mündler
+ </td>
+ </tr>
+ <tr>
+ <td class="entry">
+ 2021-02-17: <a href="entries/Formal_Puiseux_Series.html">Formal Puiseux Series</a>
+ <br>
+ Author:
+ <a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
+ </td>
+ </tr>
+ <tr>
+ <td class="entry">
2021-02-10: <a href="entries/Laws_of_Large_Numbers.html">The Laws of Large Numbers</a>
<br>
Author:
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2021-01-31: <a href="entries/IsaGeoCoq.html">Tarski's Parallel Postulate implies the 5th Postulate of Euclid, the Postulate of Playfair and the original Parallel Postulate of Euclid</a>
<br>
Author:
Roland Coghetto
</td>
</tr>
<tr>
<td class="entry">
2021-01-30: <a href="entries/Blue_Eyes.html">Solution to the xkcd Blue Eyes puzzle</a>
<br>
Author:
Jakub Kądziołka
</td>
</tr>
<tr>
<td class="entry">
2021-01-18: <a href="entries/Hood_Melville_Queue.html">Hood-Melville Queue</a>
<br>
Author:
Alejandro Gómez-Londoño
</td>
</tr>
<tr>
<td class="entry">
2021-01-11: <a href="entries/JinjaDCI.html">JinjaDCI: a Java semantics with dynamic class initialization</a>
<br>
Author:
Susannah Mansky
</td>
</tr>
</tbody>
</table>
<p>&nbsp;</p>
<table width="80%" class="entries">
<tbody>
<tr>
<td class="head">2020</td>
</tr>
<tr>
<td class="entry">
2020-12-27: <a href="entries/Delta_System_Lemma.html">Cofinality and the Delta System Lemma</a>
<br>
Author:
<a href="https://cs.famaf.unc.edu.ar/~pedro/home_en.html">Pedro Sánchez Terraf</a>
</td>
</tr>
<tr>
<td class="entry">
2020-12-17: <a href="entries/Topological_Semantics.html">Topological semantics for paraconsistent and paracomplete logics</a>
<br>
Author:
David Fuenmayor
</td>
</tr>
<tr>
<td class="entry">
2020-12-08: <a href="entries/Relational_Minimum_Spanning_Trees.html">Relational Minimum Spanning Tree Algorithms</a>
<br>
Authors:
<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
and Nicolas Robinson-O'Brien
</td>
</tr>
<tr>
<td class="entry">
2020-12-07: <a href="entries/Interpreter_Optimizations.html">Inline Caching and Unboxing Optimization for Interpreters</a>
<br>
Author:
<a href="https://martin.desharnais.me">Martin Desharnais</a>
</td>
</tr>
<tr>
<td class="entry">
2020-12-05: <a href="entries/Relational_Method.html">The Relational Method with Message Anonymity for the Verification of Cryptographic Protocols</a>
<br>
Author:
Pasquale Noce
</td>
</tr>
<tr>
<td class="entry">
2020-11-22: <a href="entries/Isabelle_Marries_Dirac.html">Isabelle Marries Dirac: a Library for Quantum Computation and Quantum Information</a>
<br>
Authors:
Anthony Bordg,
Hanna Lachnitt
and Yijun He
</td>
</tr>
<tr>
<td class="entry">
2020-11-19: <a href="entries/CSP_RefTK.html">The HOL-CSP Refinement Toolkit</a>
<br>
Authors:
Safouan Taha,
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
and Lina Ye
</td>
</tr>
<tr>
<td class="entry">
2020-10-29: <a href="entries/Verified_SAT_Based_AI_Planning.html">Verified SAT-Based AI Planning</a>
<br>
Authors:
<a href="http://home.in.tum.de/~mansour/">Mohammad Abdulaziz</a>
and Friedrich Kurz
</td>
</tr>
<tr>
<td class="entry">
2020-10-29: <a href="entries/AI_Planning_Languages_Semantics.html">AI Planning Languages Semantics</a>
<br>
Authors:
<a href="http://home.in.tum.de/~mansour/">Mohammad Abdulaziz</a>
and Peter Lammich
</td>
</tr>
<tr>
<td class="entry">
2020-10-20: <a href="entries/Physical_Quantities.html">A Sound Type System for Physical Quantities, Units, and Measurements</a>
<br>
Authors:
<a href="https://www-users.cs.york.ac.uk/~simonf/">Simon Foster</a>
and <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</td>
</tr>
<tr>
<td class="entry">
2020-10-12: <a href="entries/Finite-Map-Extras.html">Finite Map Extras</a>
<br>
Author:
Javier Díaz
</td>
</tr>
<tr>
<td class="entry">
2020-09-28: <a href="entries/Shadow_SC_DOM.html">A Formal Model of the Safely Composable Document Object Model with Shadow Roots</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">
2020-09-28: <a href="entries/Shadow_DOM.html">A Formal Model of the Document Object Model with Shadow Roots</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">
2020-09-28: <a href="entries/SC_DOM_Components.html">A Formalization of Safely Composable Web Components</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">
2020-09-28: <a href="entries/DOM_Components.html">A Formalization of Web Components</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">
2020-09-28: <a href="entries/Core_SC_DOM.html">The Safely Composable DOM</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">
2020-09-16: <a href="entries/Syntax_Independent_Logic.html">Syntax-Independent Logic Infrastructure</a>
<br>
Authors:
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
and <a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="entry">
2020-09-16: <a href="entries/Robinson_Arithmetic.html">Robinson Arithmetic</a>
<br>
Authors:
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
and <a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="entry">
2020-09-16: <a href="entries/Goedel_Incompleteness.html">An Abstract Formalization of G&ouml;del's Incompleteness Theorems</a>
<br>
Authors:
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
and <a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="entry">
2020-09-16: <a href="entries/Goedel_HFSet_Semanticless.html">From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part II</a>
<br>
Authors:
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
and <a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="entry">
2020-09-16: <a href="entries/Goedel_HFSet_Semantic.html">From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part I</a>
<br>
Authors:
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
and <a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="entry">
2020-09-07: <a href="entries/Extended_Finite_State_Machines.html">A Formal Model of Extended Finite State Machines</a>
<br>
Authors:
Michael Foster,
<a href="https://www.brucker.ch">Achim D. Brucker</a>,
Ramsay G. Taylor
and John Derrick
</td>
</tr>
<tr>
<td class="entry">
2020-09-07: <a href="entries/Extended_Finite_State_Machine_Inference.html">Inference of Extended Finite State Machines</a>
<br>
Authors:
Michael Foster,
<a href="https://www.brucker.ch">Achim D. Brucker</a>,
Ramsay G. Taylor
and John Derrick
</td>
</tr>
<tr>
<td class="entry">
2020-08-31: <a href="entries/PAC_Checker.html">Practical Algebraic Calculus Checker</a>
<br>
Authors:
<a href="http://fmv.jku.at/fleury">Mathias Fleury</a>
and <a href="http://fmv.jku.at/kaufmann">Daniela Kaufmann</a>
</td>
</tr>
<tr>
<td class="entry">
2020-08-31: <a href="entries/Inductive_Inference.html">Some classical results in inductive inference of recursive functions</a>
<br>
Author:
Frank J. Balbach
</td>
</tr>
<tr>
<td class="entry">
2020-08-26: <a href="entries/Relational_Disjoint_Set_Forests.html">Relational Disjoint-Set Forests</a>
<br>
Author:
<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
</td>
</tr>
<tr>
<td class="entry">
2020-08-25: <a href="entries/Saturation_Framework_Extensions.html">Extensions to the Comprehensive Framework for Saturation Theorem Proving</a>
<br>
Authors:
<a href="https://www.cs.vu.nl/~jbe248/">Jasmin Blanchette</a>
and <a href="https://www.mpi-inf.mpg.de/departments/automation-of-logic/people/sophie-tourret">Sophie Tourret</a>
</td>
</tr>
<tr>
<td class="entry">
2020-08-25: <a href="entries/BirdKMP.html">Putting the `K' into Bird's derivation of Knuth-Morris-Pratt string matching</a>
<br>
Author:
<a href="http://peteg.org">Peter Gammie</a>
</td>
</tr>
<tr>
<td class="entry">
2020-08-04: <a href="entries/Amicable_Numbers.html">Amicable Numbers</a>
<br>
Author:
<a href="https://www.cl.cam.ac.uk/~ak2110/">Angeliki Koutsoukou-Argyraki</a>
</td>
</tr>
<tr>
<td class="entry">
2020-08-03: <a href="entries/Ordinal_Partitions.html">Ordinal Partitions</a>
<br>
Author:
<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
</td>
</tr>
<tr>
<td class="entry">
2020-07-21: <a href="entries/Chandy_Lamport.html">A Formal Proof of The Chandy--Lamport Distributed Snapshot Algorithm</a>
<br>
Authors:
Ben Fiedler
and <a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="entry">
2020-07-13: <a href="entries/Relational_Paths.html">Relational Characterisations of Paths</a>
<br>
Authors:
<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
and <a href="http://www.hoefner-online.de/">Peter Höfner</a>
</td>
</tr>
<tr>
<td class="entry">
2020-06-01: <a href="entries/Safe_Distance.html">A Formally Verified Checker of the Safe Distance Traffic Rules for Autonomous Vehicles</a>
<br>
Authors:
Albert Rizaldi
and <a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
</td>
</tr>
<tr>
<td class="entry">
2020-05-23: <a href="entries/Smith_Normal_Form.html">A verified algorithm for computing the Smith normal form of a matrix</a>
<br>
Author:
<a href="https://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>
</td>
</tr>
<tr>
<td class="entry">
2020-05-16: <a href="entries/Nash_Williams.html">The Nash-Williams Partition Theorem</a>
<br>
Author:
<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
</td>
</tr>
<tr>
<td class="entry">
2020-05-13: <a href="entries/Knuth_Bendix_Order.html">A Formalization of Knuth–Bendix Orders</a>
<br>
Authors:
Christian Sternagel
and <a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
</td>
</tr>
<tr>
<td class="entry">
2020-05-12: <a href="entries/Irrational_Series_Erdos_Straus.html">Irrationality Criteria for Series by Erdős and Straus</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">
2020-05-11: <a href="entries/Recursion-Addition.html">Recursion Theorem in ZF</a>
<br>
Author:
Georgy Dunaev
</td>
</tr>
<tr>
<td class="entry">
2020-05-08: <a href="entries/LTL_Normal_Form.html">An Efficient Normalisation Procedure for Linear Temporal Logic: Isabelle/HOL Formalisation</a>
<br>
Author:
Salomon Sickert
</td>
</tr>
<tr>
<td class="entry">
2020-05-06: <a href="entries/Forcing.html">Formalization of Forcing in Isabelle/ZF</a>
<br>
Authors:
Emmanuel Gunther,
<a href="https://cs.famaf.unc.edu.ar/~mpagano/">Miguel Pagano</a>
and <a href="https://cs.famaf.unc.edu.ar/~pedro/home_en.html">Pedro Sánchez Terraf</a>
</td>
</tr>
<tr>
<td class="entry">
2020-05-02: <a href="entries/Banach_Steinhaus.html">Banach-Steinhaus Theorem</a>
<br>
Authors:
<a href="http://kodu.ut.ee/~unruh/">Dominique Unruh</a>
and <a href="https://josephcmac.github.io/">Jose Manuel Rodriguez Caballero</a>
</td>
</tr>
<tr>
<td class="entry">
2020-04-27: <a href="entries/Attack_Trees.html">Attack Trees in Isabelle for GDPR compliance of IoT healthcare systems</a>
<br>
Author:
<a href="http://www.cs.mdx.ac.uk/people/florian-kammueller/">Florian Kammueller</a>
</td>
</tr>
<tr>
<td class="entry">
2020-04-24: <a href="entries/Power_Sum_Polynomials.html">Power Sum Polynomials</a>
<br>
Author:
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2020-04-24: <a href="entries/Lambert_W.html">The Lambert W Function on the Reals</a>
<br>
Author:
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2020-04-24: <a href="entries/Gaussian_Integers.html">Gaussian Integers</a>
<br>
Author:
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2020-04-19: <a href="entries/Matrices_for_ODEs.html">Matrices for ODEs</a>
<br>
Author:
Jonathan Julian Huerta y Munive
</td>
</tr>
<tr>
<td class="entry">
2020-04-16: <a href="entries/ADS_Functor.html">Authenticated Data Structures As Functors</a>
<br>
Authors:
<a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
and Ognjen Marić
</td>
</tr>
<tr>
<td class="entry">
2020-04-10: <a href="entries/Sliding_Window_Algorithm.html">Formalization of an Algorithm for Greedily Computing Associative Aggregations on Sliding Windows</a>
<br>
Authors:
Lukas Heimes,
<a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
and Joshua Schneider
</td>
</tr>
<tr>
<td class="entry">
2020-04-09: <a href="entries/Saturation_Framework.html">A Comprehensive Framework for Saturation Theorem Proving</a>
<br>
Author:
<a href="https://www.mpi-inf.mpg.de/departments/automation-of-logic/people/sophie-tourret">Sophie Tourret</a>
</td>
</tr>
<tr>
<td class="entry">
2020-04-09: <a href="entries/MFODL_Monitor_Optimized.html">Formalization of an Optimized Monitoring Algorithm for Metric First-Order Dynamic Logic with Aggregations</a>
<br>
Authors:
Thibault Dardinier,
Lukas Heimes,
Martin Raszyk,
Joshua Schneider
and <a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="entry">
2020-04-08: <a href="entries/Stateful_Protocol_Composition_and_Typing.html">Stateful Protocol Composition and Typing</a>
<br>
Authors:
Andreas V. Hess,
<a href="https://people.compute.dtu.dk/samo/">Sebastian Mödersheim</a>
and <a href="https://www.brucker.ch">Achim D. Brucker</a>
</td>
</tr>
<tr>
<td class="entry">
2020-04-08: <a href="entries/Automated_Stateful_Protocol_Verification.html">Automated Stateful Protocol Verification</a>
<br>
Authors:
Andreas V. Hess,
<a href="https://people.compute.dtu.dk/samo/">Sebastian Mödersheim</a>,
<a href="https://www.brucker.ch">Achim D. Brucker</a>
and <a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>
</td>
</tr>
<tr>
<td class="entry">
2020-04-07: <a href="entries/Lucas_Theorem.html">Lucas's Theorem</a>
<br>
Author:
Chelsea Edmonds
</td>
</tr>
<tr>
<td class="entry">
2020-03-25: <a href="entries/WOOT_Strong_Eventual_Consistency.html">Strong Eventual Consistency of the Collaborative Editing Framework WOOT</a>
<br>
Authors:
<a href="https://orcid.org/0000-0003-3290-5034">Emin Karayel</a>
and Edgar Gonzàlez
</td>
</tr>
<tr>
<td class="entry">
2020-03-22: <a href="entries/Furstenberg_Topology.html">Furstenberg's topology and his proof of the infinitude of primes</a>
<br>
Author:
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2020-03-12: <a href="entries/Relational-Incorrectness-Logic.html">An Under-Approximate Relational Logic</a>
<br>
Author:
<a href="https://people.eng.unimelb.edu.au/tobym/">Toby Murray</a>
</td>
</tr>
<tr>
<td class="entry">
2020-03-07: <a href="entries/Hello_World.html">Hello World</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">
2020-02-21: <a href="entries/Goodstein_Lambda.html">Implementing the Goodstein Function in &lambda;-Calculus</a>
<br>
Author:
Bertram Felgenhauer
</td>
</tr>
<tr>
<td class="entry">
2020-02-10: <a href="entries/VeriComp.html">A Generic Framework for Verified Compilers</a>
<br>
Author:
<a href="https://martin.desharnais.me">Martin Desharnais</a>
</td>
</tr>
<tr>
<td class="entry">
2020-02-01: <a href="entries/Arith_Prog_Rel_Primes.html">Arithmetic progressions and relative primes</a>
<br>
Author:
<a href="https://josephcmac.github.io/">José Manuel Rodríguez Caballero</a>
</td>
</tr>
<tr>
<td class="entry">
2020-01-31: <a href="entries/Subset_Boolean_Algebras.html">A Hierarchy of Algebras for Boolean Subsets</a>
<br>
Authors:
<a href="http://www.cosc.canterbury.ac.nz/walter.guttmann/">Walter Guttmann</a>
and <a href="https://www.informatik.uni-augsburg.de/en/chairs/dbis/pmi/staff/moeller/">Bernhard Möller</a>
</td>
</tr>
<tr>
<td class="entry">
2020-01-17: <a href="entries/Mersenne_Primes.html">Mersenne primes and the Lucas–Lehmer test</a>
<br>
Author:
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2020-01-16: <a href="entries/Approximation_Algorithms.html">Verified Approximation Algorithms</a>
<br>
Authors:
Robin Eßmann,
<a href="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
and <a href="https://simon-robillard.net/">Simon Robillard</a>
</td>
</tr>
<tr>
<td class="entry">
2020-01-13: <a href="entries/Closest_Pair_Points.html">Closest Pair of Points Algorithms</a>
<br>
Authors:
Martin Rau
and <a href="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
</td>
</tr>
<tr>
<td class="entry">
2020-01-09: <a href="entries/Skip_Lists.html">Skip Lists</a>
<br>
Authors:
<a href="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Max W. Haslbeck</a>
and <a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2020-01-06: <a href="entries/Bicategory.html">Bicategories</a>
<br>
Author:
Eugene W. Stark
</td>
</tr>
</tbody>
</table>
<p>&nbsp;</p>
<table width="80%" class="entries">
<tbody>
<tr>
<td class="head">2019</td>
</tr>
<tr>
<td class="entry">
2019-12-27: <a href="entries/Zeta_3_Irrational.html">The Irrationality of ζ(3)</a>
<br>
Author:
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2019-12-20: <a href="entries/Hybrid_Logic.html">Formalizing a Seligman-Style Tableau System for Hybrid Logic</a>
<br>
Author:
<a href="https://people.compute.dtu.dk/ahfrom/">Asta Halkjær From</a>
</td>
</tr>
<tr>
<td class="entry">
2019-12-18: <a href="entries/Poincare_Bendixson.html">The Poincaré-Bendixson Theorem</a>
<br>
Authors:
<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
and <a href="https://www.cs.cmu.edu/~yongkiat/">Yong Kiam Tan</a>
</td>
</tr>
<tr>
<td class="entry">
2019-12-16: <a href="entries/Poincare_Disc.html">Poincaré Disc Model</a>
<br>
Authors:
<a href="http://poincare.matf.bg.ac.rs/~danijela">Danijela Simić</a>,
Filip Marić
and Pierre Boutry
</td>
</tr>
<tr>
<td class="entry">
2019-12-16: <a href="entries/Complex_Geometry.html">Complex Geometry</a>
<br>
Authors:
Filip Marić
and <a href="http://poincare.matf.bg.ac.rs/~danijela">Danijela Simić</a>
</td>
</tr>
<tr>
<td class="entry">
2019-12-10: <a href="entries/Gauss_Sums.html">Gauss Sums and the Pólya–Vinogradov Inequality</a>
<br>
Authors:
<a href="https://people.epfl.ch/rodrigo.raya">Rodrigo Raya</a>
and <a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2019-12-04: <a href="entries/Generalized_Counting_Sort.html">An Efficient Generalization of Counting Sort for Large, possibly Infinite Key Ranges</a>
<br>
Author:
Pasquale Noce
</td>
</tr>
<tr>
<td class="entry">
2019-11-27: <a href="entries/Interval_Arithmetic_Word32.html">Interval Arithmetic on 32-bit Words</a>
<br>
Author:
Brandon Bohrer
</td>
</tr>
<tr>
<td class="entry">
2019-10-24: <a href="entries/ZFC_in_HOL.html">Zermelo Fraenkel Set Theory in Higher-Order Logic</a>
<br>
Author:
<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C. Paulson</a>
</td>
</tr>
<tr>
<td class="entry">
2019-10-22: <a href="entries/Isabelle_C.html">Isabelle/C</a>
<br>
Authors:
<a href="https://www.lri.fr/~ftuong/">Frédéric Tuong</a>
and <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</td>
</tr>
<tr>
<td class="entry">
2019-10-16: <a href="entries/VerifyThis2019.html">VerifyThis 2019 -- Polished Isabelle Solutions</a>
<br>
Authors:
Peter Lammich
and <a href="http://home.in.tum.de/~wimmers/">Simon Wimmer</a>
</td>
</tr>
<tr>
<td class="entry">
2019-10-08: <a href="entries/Aristotles_Assertoric_Syllogistic.html">Aristotle's Assertoric Syllogistic</a>
<br>
Author:
<a href="https://www.cl.cam.ac.uk/~ak2110/">Angeliki Koutsoukou-Argyraki</a>
</td>
</tr>
<tr>
<td class="entry">
2019-10-07: <a href="entries/Sigma_Commit_Crypto.html">Sigma Protocols and Commitment Schemes</a>
<br>
Authors:
<a href="https://www.turing.ac.uk/people/doctoral-students/david-butler">David Butler</a>
and <a href="http://www.andreas-lochbihler.de">Andreas Lochbihler</a>
</td>
</tr>
<tr>
<td class="entry">
2019-10-04: <a href="entries/Clean.html">Clean - An Abstract Imperative Programming Language and its Theory</a>
<br>
Authors:
<a href="https://www.lri.fr/~ftuong/">Frédéric Tuong</a>
and <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</td>
</tr>
<tr>
<td class="entry">
2019-09-16: <a href="entries/Generic_Join.html">Formalization of Multiway-Join Algorithms</a>
<br>
Author:
Thibault Dardinier
</td>
</tr>
<tr>
<td class="entry">
2019-09-10: <a href="entries/Hybrid_Systems_VCs.html">Verification Components for Hybrid Systems</a>
<br>
Author:
Jonathan Julian Huerta y Munive
</td>
</tr>
<tr>
<td class="entry">
2019-09-06: <a href="entries/Fourier.html">Fourier Series</a>
<br>
Author:
<a href="https://www.cl.cam.ac.uk/~lp15/">Lawrence C Paulson</a>
</td>
</tr>
<tr>
<td class="entry">
2019-08-30: <a href="entries/Jacobson_Basic_Algebra.html">A Case Study in Basic Algebra</a>
<br>
Author:
<a href="http://www21.in.tum.de/~ballarin/">Clemens Ballarin</a>
</td>
</tr>
<tr>
<td class="entry">
2019-08-16: <a href="entries/Adaptive_State_Counting.html">Formalisation of an Adaptive State Counting Algorithm</a>
<br>
Author:
Robert Sachtleben
</td>
</tr>
<tr>
<td class="entry">
2019-08-14: <a href="entries/Laplace_Transform.html">Laplace Transform</a>
<br>
Author:
<a href="http://home.in.tum.de/~immler/">Fabian Immler</a>
</td>
</tr>
<tr>
<td class="entry">
2019-08-06: <a href="entries/Linear_Programming.html">Linear Programming</a>
<br>
Authors:
<a href="http://www.parsert.com/">Julian Parsert</a>
and <a href="http://cl-informatik.uibk.ac.at/cek/">Cezary Kaliszyk</a>
</td>
</tr>
<tr>
<td class="entry">
2019-08-06: <a href="entries/C2KA_DistributedSystems.html">Communicating Concurrent Kleene Algebra for Distributed Systems Specification</a>
<br>
Authors:
Maxime Buyse
and <a href="https://carleton.ca/jaskolka/">Jason Jaskolka</a>
</td>
</tr>
<tr>
<td class="entry">
2019-08-05: <a href="entries/IMO2019.html">Selected Problems from the International Mathematical Olympiad 2019</a>
<br>
Author:
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
</td>
</tr>
<tr>
<td class="entry">
2019-08-01: <a href="entries/Stellar_Quorums.html">Stellar Quorum Systems</a>
<br>
Author:
Giuliano Losa
</td>
</tr>
<tr>
<td class="entry">
2019-07-30: <a href="entries/TESL_Language.html">A Formal Development of a Polychronous Polytimed Coordination Language</a>
<br>
Authors:
Hai Nguyen Van,
Frédéric Boulanger
and <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</td>
</tr>
<tr>
<td class="entry">
2019-07-27: <a href="entries/Szpilrajn.html">Szpilrajn Extension Theorem</a>
<br>
Author:
Peter Zeller
</td>
</tr>
<tr>
<td class="entry">
2019-07-18: <a href="entries/FOL_Seq_Calc1.html">A Sequent Calculus for First-Order Logic</a>
<br>
Author:
<a href="https://people.compute.dtu.dk/ahfrom/">Asta Halkjær From</a>
</td>
</tr>
<tr>
<td class="entry">
2019-07-08: <a href="entries/CakeML_Codegen.html">A Verified Code Generator from Isabelle/HOL to CakeML</a>
<br>
Author:
<a href="https://www21.in.tum.de/~hupel/">Lars Hupel</a>
</td>
</tr>
<tr>
<td class="entry">
2019-07-04: <a href="entries/MFOTL_Monitor.html">Formalization of a Monitoring Algorithm for Metric First-Order Temporal Logic</a>
<br>
Authors:
Joshua Schneider
and <a href="https://traytel.bitbucket.io">Dmitriy Traytel</a>
</td>
</tr>
<tr>
<td class="entry">
2019-06-27: <a href="entries/Complete_Non_Orders.html">Complete Non-Orders and Fixed Points</a>
<br>
Authors:
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
and <a href="http://group-mmm.org/~dubut/">Jérémy Dubut</a>
</td>
</tr>
<tr>
<td class="entry">
2019-06-25: <a href="entries/Priority_Search_Trees.html">Priority Search Trees</a>
<br>
Authors:
Peter Lammich
and <a href="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
</td>
</tr>
<tr>
<td class="entry">
2019-06-25: <a href="entries/Prim_Dijkstra_Simple.html">Purely Functional, Simple, and Efficient Implementation of Prim and Dijkstra</a>
<br>
Authors:
Peter Lammich
and <a href="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
</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-06-03: <a href="entries/Differential_Game_Logic.html">Differential Game Logic</a>
<br>
Author:
<a href="http://www.cs.cmu.edu/~aplatzer/">André Platzer</a>
</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="https://traytel.bitbucket.io">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 <a href="https://www.turing.ac.uk/people/doctoral-students/david-butler">David Butler</a>
</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 <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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 <a href="https://www.andreipopescu.uk">Andrei Popescu</a>
</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>,
Peter Lammich
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 <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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:
Peter Lammich
and <a href="http://home.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>&nbsp;</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:
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>,
Jasmin Christian Blanchette
and <a href="https://traytel.bitbucket.io">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="https://people.compute.dtu.dk/ahfrom/">Asta 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:
<a href="http://www.parsert.com/">Julian Parsert</a>
and <a href="http://cl-informatik.uibk.ac.at/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:
Anthony Bordg
</td>
</tr>
<tr>
<td class="entry">
2018-06-14: <a href="entries/Localization_Ring.html">The Localization of a Commutative Ring</a>
<br>
Author:
Anthony Bordg
</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="http://www21.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://home.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://home.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://home.in.tum.de/~wimmers/">Simon Wimmer</a>,
Shuwei Hu
and <a href="http://www21.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:
Peter Lammich
and <a href="http://home.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="http://www21.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="http://www21.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="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Maximilian Haslbeck</a>,
<a href="https://www21.in.tum.de/~eberlm">Manuel Eberl</a>
and <a href="http://www21.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="https://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 <a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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="https://www.unirioja.es/cu/jodivaso/">Jose Divasón</a>,
<a href="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Maximilian Haslbeck</a>,
<a href="http://sjcjoosten.nl/">Sebastiaan Joosten</a>,
<a href="http://cl-informatik.uibk.ac.at/~thiemann/">René Thiemann</a>
and <a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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:
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>,
Jasmin Christian Blanchette,
<a href="https://traytel.bitbucket.io">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>&nbsp;</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,
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
and <a href="https://traytel.bitbucket.io">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 Peter Lammich
</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,
<a href="http://www.parsert.com/">Julian Parsert</a>,
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:
<a href="http://www.parsert.com/">Julian Parsert</a>
and <a href="http://cl-informatik.uibk.ac.at/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="http://www21.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="http://www21.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:
Peter Lammich
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:
Peter Lammich
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://home.in.tum.de/~wimmers/">Simon Wimmer</a>
and Peter Lammich
</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 <a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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,
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
and <a href="https://traytel.bitbucket.io">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 <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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>,
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>
and <a href="https://people.compute.dtu.dk/jovi/">Jørgen Villadsen</a>
</td>
</tr>
</tbody>
</table>
<p>&nbsp;</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:
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>
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="http://www21.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,
<a href="http://fmv.jku.at/fleury">Mathias Fleury</a>
and <a href="https://traytel.bitbucket.io">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="https://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 <a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">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 <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</td>
</tr>
<tr>
<td class="entry">
2016-08-12: <a href="entries/EdmondsKarp_Maxflow.html">Formalizing the Edmonds-Karp Algorithm</a>
<br>
Authors:
Peter Lammich
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:
Peter Lammich
</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="http://www21.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:
Peter Lammich
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:
<a href="https://people.compute.dtu.dk/andschl/">Anders Schlichtkrull</a>
</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="https://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="https://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="https://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 <a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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="http://cl-informatik.uibk.ac.at/users/mhaslbeck/">Maximilian Haslbeck</a>,
Peter Lammich
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://home.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="http://www21.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 <a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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 <a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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>&nbsp;</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>,
<a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
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:
<a href="https://www.lri.fr/~ftuong/">Frédéric Tuong</a>
and <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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 <a href="http://group-mmm.org/~ayamada/">Akihisa Yamada</a>
</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="https://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="http://www21.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="https://traytel.bitbucket.io">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="https://traytel.bitbucket.io">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="http://www21.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="https://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="https://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>&nbsp;</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 <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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="http://www21.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="http://www21.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="https://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="http://www21.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="http://www21.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,
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
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="http://www21.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="https://traytel.bitbucket.io">Dmitriy Traytel</a>
and <a href="http://www21.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="http://www21.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 Peter Lammich
</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:
Peter Lammich
</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>,
Peter Lammich,
René Neumann,
<a href="http://www21.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:
Peter Lammich
</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:
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
and Peter Lammich
</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>,
Peter Lammich
and <a href="https://www.andreipopescu.uk">Andrei Popescu</a>
</td>
</tr>
<tr>
<td class="entry">
2014-04-16: <a href="entries/Abstract_Completeness.html">Abstract Completeness</a>
<br>
Authors:
Jasmin Christian Blanchette,
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
and <a href="https://traytel.bitbucket.io">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:
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
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="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
and <a href="https://traytel.bitbucket.io">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>,
<a href="https://www.lri.fr/~ftuong/">Frédéric Tuong</a>
and <a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
</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>&nbsp;</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="https://traytel.bitbucket.io">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:
Peter Lammich
</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://home.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://home.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 <a href="https://www.andreipopescu.uk">Andrei Popescu</a>
</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/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="https://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>&nbsp;</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:
Peter Lammich
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:
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
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,
<a href="https://www.lri.fr/~wolff/">Burkhart Wolff</a>
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:
Peter Lammich
</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 Peter Lammich
</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="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
</td>
</tr>
</tbody>
</table>
<p>&nbsp;</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="http://www21.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>&nbsp;</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="http://www21.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 Peter Lammich
</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 Peter Lammich
</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="http://www21.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="http://www21.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>&nbsp;</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:
Peter Lammich
</td>
</tr>
<tr>
<td class="entry">
2009-11-25: <a href="entries/Collections.html">Collections Framework</a>
<br>
Author:
Peter Lammich
</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:
<a href="https://www.andreipopescu.uk">Andrei Popescu</a>
</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>&nbsp;</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="http://www21.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="http://www21.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="http://www21.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:
Filip Marić
</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="http://www21.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="http://www21.in.tum.de/~nipkow">Tobias Nipkow</a>
</td>
</tr>
</tbody>
</table>
<p>&nbsp;</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:
Peter Lammich
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>&nbsp;</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="http://www21.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="http://www21.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="http://www21.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>&nbsp;</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="http://www21.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>&nbsp;</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="http://www21.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="http://www21.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="http://www21.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="http://www21.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,632 +1,614 @@
<?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>10 Feb 2021 00:00:00 +0000</pubDate>
+ <pubDate>24 Feb 2021 00:00:00 +0000</pubDate>
+ <item>
+ <title>A Verified Imperative Implementation of B-Trees</title>
+ <link>https://www.isa-afp.org/entries/BTree.html</link>
+ <guid>https://www.isa-afp.org/entries/BTree.html</guid>
+ <dc:creator> Niels Mündler </dc:creator>
+ <pubDate>24 Feb 2021 00:00:00 +0000</pubDate>
+ <description>
+In this work, we use the interactive theorem prover Isabelle/HOL to
+verify an imperative implementation of the classical B-tree data
+structure invented by Bayer and McCreight [ACM 1970]. The
+implementation supports set membership and insertion queries with
+efficient binary search for intra-node navigation. This is
+accomplished by first specifying the structure abstractly in the
+functional modeling language HOL and proving functional correctness.
+Using manual refinement, we derive an imperative implementation in
+Imperative/HOL. We show the validity of this refinement using the
+separation logic utilities from the &lt;a
+href=&#34;https://www.isa-afp.org/entries/Refine_Imperative_HOL.html&#34;&gt;
+Isabelle Refinement Framework &lt;/a&gt; . The code can be exported to
+the programming languages SML and Scala. We examine the runtime of all
+operations indirectly by reproducing results of the logarithmic
+relationship between height and the number of nodes. The results are
+discussed in greater detail in the corresponding &lt;a
+href=&#34;https://mediatum.ub.tum.de/1596550&#34;&gt;Bachelor&#39;s
+Thesis&lt;/a&gt;.</description>
+ </item>
+ <item>
+ <title>Formal Puiseux Series</title>
+ <link>https://www.isa-afp.org/entries/Formal_Puiseux_Series.html</link>
+ <guid>https://www.isa-afp.org/entries/Formal_Puiseux_Series.html</guid>
+ <dc:creator> Manuel Eberl </dc:creator>
+ <pubDate>17 Feb 2021 00:00:00 +0000</pubDate>
+ <description>
+&lt;p&gt;Formal Puiseux series are generalisations of formal power
+series and formal Laurent series that also allow for fractional
+exponents. They have the following general form: \[\sum_{i=N}^\infty
+a_{i/d} X^{i/d}\] where &lt;em&gt;N&lt;/em&gt; is an integer and
+&lt;em&gt;d&lt;/em&gt; is a positive integer.&lt;/p&gt; &lt;p&gt;This
+entry defines these series including their basic algebraic properties.
+Furthermore, it proves the Newton–Puiseux Theorem, namely that the
+Puiseux series over an algebraically closed field of characteristic 0
+are also algebraically closed.&lt;/p&gt;</description>
+ </item>
<item>
<title>The Laws of Large Numbers</title>
<link>https://www.isa-afp.org/entries/Laws_of_Large_Numbers.html</link>
<guid>https://www.isa-afp.org/entries/Laws_of_Large_Numbers.html</guid>
<dc:creator> Manuel Eberl </dc:creator>
<pubDate>10 Feb 2021 00:00:00 +0000</pubDate>
<description>
&lt;p&gt;The Law of Large Numbers states that, informally, if one
performs a random experiment $X$ many times and takes the average of
the results, that average will be very close to the expected value
$E[X]$.&lt;/p&gt; &lt;p&gt; More formally, let
$(X_i)_{i\in\mathbb{N}}$ be a sequence of independently identically
distributed random variables whose expected value $E[X_1]$ exists.
Denote the running average of $X_1, \ldots, X_n$ as $\overline{X}_n$.
Then:&lt;/p&gt; &lt;ul&gt; &lt;li&gt;The Weak Law of Large Numbers
states that $\overline{X}_{n} \longrightarrow E[X_1]$ in probability
for $n\to\infty$, i.e. $\mathcal{P}(|\overline{X}_{n} - E[X_1]| &gt;
\varepsilon) \longrightarrow 0$ as $n\to\infty$ for any $\varepsilon
&gt; 0$.&lt;/li&gt; &lt;li&gt;The Strong Law of Large Numbers states
that $\overline{X}_{n} \longrightarrow E[X_1]$ almost surely for
$n\to\infty$, i.e. $\mathcal{P}(\overline{X}_{n} \longrightarrow
E[X_1]) = 1$.&lt;/li&gt; &lt;/ul&gt; &lt;p&gt;In this entry, I
formally prove the strong law and from it the weak law. The approach
used for the proof of the strong law is a particularly quick and slick
one based on ergodic theory, which was formalised by Gouëzel in
another AFP entry.&lt;/p&gt;</description>
</item>
<item>
<title>Tarski's Parallel Postulate implies the 5th Postulate of Euclid, the Postulate of Playfair and the original Parallel Postulate of Euclid</title>
<link>https://www.isa-afp.org/entries/IsaGeoCoq.html</link>
<guid>https://www.isa-afp.org/entries/IsaGeoCoq.html</guid>
<dc:creator> Roland Coghetto </dc:creator>
<pubDate>31 Jan 2021 00:00:00 +0000</pubDate>
<description>
&lt;p&gt;The &lt;a href=&#34;https://geocoq.github.io/GeoCoq/&#34;&gt;GeoCoq library&lt;/a&gt; contains a formalization
of geometry using the Coq proof assistant. It contains both proofs
about the foundations of geometry and high-level proofs in the same
style as in high school. We port a part of the GeoCoq
2.4.0 library to Isabelle/HOL: more precisely,
the files Chap02.v to Chap13_3.v, suma.v as well as the associated
definitions and some useful files for the demonstration of certain
parallel postulates. The synthetic approach of the demonstrations is directly
inspired by those contained in GeoCoq. The names of the lemmas and
theorems used are kept as far as possible as well as the definitions.
&lt;/p&gt;
&lt;p&gt;It should be noted that T.J.M. Makarios has done
&lt;a href=&#34;https://www.isa-afp.org/entries/Tarskis_Geometry.html&#34;&gt;some proofs in Tarski&#39;s Geometry&lt;/a&gt;. It uses a definition that does not quite
coincide with the definition used in Geocoq and here.
Furthermore, corresponding definitions in the &lt;a href=&#34;https://www.isa-afp.org/entries/Poincare_Disc.html&#34;&gt;Poincaré Disc Model
development&lt;/a&gt; are not identical to those defined in GeoCoq.
&lt;/p&gt;
&lt;p&gt;In the last part, it is
formalized that, in the neutral/absolute space, the axiom of the
parallels of Tarski&#39;s system implies the Playfair axiom, the 5th
postulate of Euclid and Euclid&#39;s original parallel postulate. These
proofs, which are not constructive, are directly inspired by Pierre
Boutry, Charly Gries, Julien Narboux and Pascal Schreck.
&lt;/p&gt;</description>
</item>
<item>
<title>Solution to the xkcd Blue Eyes puzzle</title>
<link>https://www.isa-afp.org/entries/Blue_Eyes.html</link>
<guid>https://www.isa-afp.org/entries/Blue_Eyes.html</guid>
<dc:creator> Jakub Kądziołka </dc:creator>
<pubDate>30 Jan 2021 00:00:00 +0000</pubDate>
<description>
In a &lt;a href=&#34;https://xkcd.com/blue_eyes.html&#34;&gt;puzzle published by
Randall Munroe&lt;/a&gt;, perfect logicians forbidden
from communicating are stranded on an island, and may only leave once
they have figured out their own eye color. We present a method of
modeling the behavior of perfect logicians and formalize a solution of
the puzzle.</description>
</item>
<item>
<title>Hood-Melville Queue</title>
<link>https://www.isa-afp.org/entries/Hood_Melville_Queue.html</link>
<guid>https://www.isa-afp.org/entries/Hood_Melville_Queue.html</guid>
<dc:creator> Alejandro Gómez-Londoño </dc:creator>
<pubDate>18 Jan 2021 00:00:00 +0000</pubDate>
<description>
This is a verified implementation of a constant time queue. The
original design is due to &lt;a
href=&#34;https://doi.org/10.1016/0020-0190(81)90030-2&#34;&gt;Hood
and Melville&lt;/a&gt;. This formalization follows the presentation in
&lt;em&gt;Purely Functional Data Structures&lt;/em&gt;by Okasaki.</description>
</item>
<item>
<title>JinjaDCI: a Java semantics with dynamic class initialization</title>
<link>https://www.isa-afp.org/entries/JinjaDCI.html</link>
<guid>https://www.isa-afp.org/entries/JinjaDCI.html</guid>
<dc:creator> Susannah Mansky </dc:creator>
<pubDate>11 Jan 2021 00:00:00 +0000</pubDate>
<description>
We extend Jinja to include static fields, methods, and instructions,
and dynamic class initialization, based on the Java SE 8
specification. This includes extension of definitions and proofs. This
work is partially described in Mansky and Gunter&#39;s paper at CPP
2019 and Mansky&#39;s doctoral thesis (UIUC, 2020).</description>
</item>
<item>
<title>Cofinality and the Delta System Lemma</title>
<link>https://www.isa-afp.org/entries/Delta_System_Lemma.html</link>
<guid>https://www.isa-afp.org/entries/Delta_System_Lemma.html</guid>
<dc:creator> Pedro Sánchez Terraf </dc:creator>
<pubDate>27 Dec 2020 00:00:00 +0000</pubDate>
<description>
We formalize the basic results on cofinality of linearly ordered sets
and ordinals and Šanin’s Lemma for uncountable families of finite
sets. This last result is used to prove the countable chain condition
for Cohen posets. We work in the set theory framework of Isabelle/ZF,
using the Axiom of Choice as needed.</description>
</item>
<item>
<title>Topological semantics for paraconsistent and paracomplete logics</title>
<link>https://www.isa-afp.org/entries/Topological_Semantics.html</link>
<guid>https://www.isa-afp.org/entries/Topological_Semantics.html</guid>
<dc:creator> David Fuenmayor </dc:creator>
<pubDate>17 Dec 2020 00:00:00 +0000</pubDate>
<description>
We introduce a generalized topological semantics for paraconsistent
and paracomplete logics by drawing upon early works on topological
Boolean algebras (cf. works by Kuratowski, Zarycki, McKinsey &amp;
Tarski, etc.). In particular, this work exemplarily illustrates the
shallow semantical embeddings approach (&lt;a
href=&#34;http://dx.doi.org/10.1007/s11787-012-0052-y&#34;&gt;SSE&lt;/a&gt;)
employing the proof assistant Isabelle/HOL. By means of the SSE
technique we can effectively harness theorem provers, model finders
and &#39;hammers&#39; for reasoning with quantified non-classical
logics.</description>
</item>
<item>
<title>Relational Minimum Spanning Tree Algorithms</title>
<link>https://www.isa-afp.org/entries/Relational_Minimum_Spanning_Trees.html</link>
<guid>https://www.isa-afp.org/entries/Relational_Minimum_Spanning_Trees.html</guid>
<dc:creator> Walter Guttmann, Nicolas Robinson-O'Brien </dc:creator>
<pubDate>08 Dec 2020 00:00:00 +0000</pubDate>
<description>
We verify the correctness of Prim&#39;s, Kruskal&#39;s and
Borůvka&#39;s minimum spanning tree algorithms based on algebras for
aggregation and minimisation.</description>
</item>
<item>
<title>Inline Caching and Unboxing Optimization for Interpreters</title>
<link>https://www.isa-afp.org/entries/Interpreter_Optimizations.html</link>
<guid>https://www.isa-afp.org/entries/Interpreter_Optimizations.html</guid>
<dc:creator> Martin Desharnais </dc:creator>
<pubDate>07 Dec 2020 00:00:00 +0000</pubDate>
<description>
This Isabelle/HOL formalization builds on the
&lt;em&gt;VeriComp&lt;/em&gt; entry of the &lt;em&gt;Archive of Formal
Proofs&lt;/em&gt; to provide the following contributions: &lt;ul&gt;
&lt;li&gt;an operational semantics for a realistic virtual machine
(Std) for dynamically typed programming languages;&lt;/li&gt;
&lt;li&gt;the formalization of an inline caching optimization (Inca),
a proof of bisimulation with (Std), and a compilation
function;&lt;/li&gt; &lt;li&gt;the formalization of an unboxing
optimization (Ubx), a proof of bisimulation with (Inca), and a simple
compilation function.&lt;/li&gt; &lt;/ul&gt; This formalization was
described in the CPP 2021 paper &lt;em&gt;Towards Efficient and
Verified Virtual Machines for Dynamic Languages&lt;/em&gt;</description>
</item>
<item>
<title>The Relational Method with Message Anonymity for the Verification of Cryptographic Protocols</title>
<link>https://www.isa-afp.org/entries/Relational_Method.html</link>
<guid>https://www.isa-afp.org/entries/Relational_Method.html</guid>
<dc:creator> Pasquale Noce </dc:creator>
<pubDate>05 Dec 2020 00:00:00 +0000</pubDate>
<description>
This paper introduces a new method for the formal verification of
cryptographic protocols, the relational method, derived from
Paulson&#39;s inductive method by means of some enhancements aimed at
streamlining formal definitions and proofs, specially for protocols
using public key cryptography. Moreover, this paper proposes a method
to formalize a further security property, message anonymity, in
addition to message confidentiality and authenticity. The relational
method, including message anonymity, is then applied to the
verification of a sample authentication protocol, comprising Password
Authenticated Connection Establishment (PACE) with Chip Authentication
Mapping followed by the explicit verification of an additional
password over the PACE secure channel.</description>
</item>
<item>
<title>Isabelle Marries Dirac: a Library for Quantum Computation and Quantum Information</title>
<link>https://www.isa-afp.org/entries/Isabelle_Marries_Dirac.html</link>
<guid>https://www.isa-afp.org/entries/Isabelle_Marries_Dirac.html</guid>
<dc:creator> Anthony Bordg, Hanna Lachnitt, Yijun He </dc:creator>
<pubDate>22 Nov 2020 00:00:00 +0000</pubDate>
<description>
This work is an effort to formalise some quantum algorithms and
results in quantum information theory. Formal methods being critical
for the safety and security of algorithms and protocols, we foresee
their widespread use for quantum computing in the future. We have
developed a large library for quantum computing in Isabelle based on a
matrix representation for quantum circuits, successfully formalising
the no-cloning theorem, quantum teleportation, Deutsch&#39;s
algorithm, the Deutsch-Jozsa algorithm and the quantum Prisoner&#39;s
Dilemma.</description>
</item>
<item>
<title>The HOL-CSP Refinement Toolkit</title>
<link>https://www.isa-afp.org/entries/CSP_RefTK.html</link>
<guid>https://www.isa-afp.org/entries/CSP_RefTK.html</guid>
<dc:creator> Safouan Taha, Burkhart Wolff, Lina Ye </dc:creator>
<pubDate>19 Nov 2020 00:00:00 +0000</pubDate>
<description>
We use a formal development for CSP, called HOL-CSP2.0, to analyse a
family of refinement notions, comprising classic and new ones. This
analysis enables to derive a number of properties that allow to deepen
the understanding of these notions, in particular with respect to
specification decomposition principles for the case of infinite sets
of events. The established relations between the refinement relations
help to clarify some obscure points in the CSP literature, but also
provide a weapon for shorter refinement proofs. Furthermore, we
provide a framework for state-normalisation allowing to formally
reason on parameterised process architectures. As a result, we have a
modern environment for formal proofs of concurrent systems that allow
for the combination of general infinite processes with locally finite
ones in a logically safe way. We demonstrate these
verification-techniques for classical, generalised examples: The
CopyBuffer for arbitrary data and the Dijkstra&#39;s Dining
Philosopher Problem of arbitrary size.</description>
</item>
<item>
<title>Verified SAT-Based AI Planning</title>
<link>https://www.isa-afp.org/entries/Verified_SAT_Based_AI_Planning.html</link>
<guid>https://www.isa-afp.org/entries/Verified_SAT_Based_AI_Planning.html</guid>
<dc:creator> Mohammad Abdulaziz, Friedrich Kurz </dc:creator>
<pubDate>29 Oct 2020 00:00:00 +0000</pubDate>
<description>
We present an executable formally verified SAT encoding of classical
AI planning that is based on the encodings by Kautz and Selman and the
one by Rintanen et al. The encoding was experimentally tested and
shown to be usable for reasonably sized standard AI planning
benchmarks. We also use it as a reference to test a state-of-the-art
SAT-based planner, showing that it sometimes falsely claims that
problems have no solutions of certain lengths. The formalisation in
this submission was described in an independent publication.</description>
</item>
<item>
<title>AI Planning Languages Semantics</title>
<link>https://www.isa-afp.org/entries/AI_Planning_Languages_Semantics.html</link>
<guid>https://www.isa-afp.org/entries/AI_Planning_Languages_Semantics.html</guid>
<dc:creator> Mohammad Abdulaziz, Peter Lammich </dc:creator>
<pubDate>29 Oct 2020 00:00:00 +0000</pubDate>
<description>
This is an Isabelle/HOL formalisation of the semantics of the
multi-valued planning tasks language that is used by the planning
system Fast-Downward, the STRIPS fragment of the Planning Domain
Definition Language (PDDL), and the STRIPS soundness meta-theory
developed by Vladimir Lifschitz. It also contains formally verified
checkers for checking the well-formedness of problems specified in
either language as well the correctness of potential solutions. The
formalisation in this entry was described in an earlier publication.</description>
</item>
<item>
<title>A Sound Type System for Physical Quantities, Units, and Measurements</title>
<link>https://www.isa-afp.org/entries/Physical_Quantities.html</link>
<guid>https://www.isa-afp.org/entries/Physical_Quantities.html</guid>
<dc:creator> Simon Foster, Burkhart Wolff </dc:creator>
<pubDate>20 Oct 2020 00:00:00 +0000</pubDate>
<description>
The present Isabelle theory builds a formal model for both the
International System of Quantities (ISQ) and the International System
of Units (SI), which are both fundamental for physics and engineering.
Both the ISQ and the SI are deeply integrated into Isabelle&#39;s
type system. Quantities are parameterised by dimension types, which
correspond to base vectors, and thus only quantities of the same
dimension can be equated. Since the underlying &#34;algebra of
quantities&#34; induces congruences on quantity and SI types,
specific tactic support is developed to capture these. Our
construction is validated by a test-set of known equivalences between
both quantities and SI units. Moreover, the presented theory can be
used for type-safe conversions between the SI system and others, like
the British Imperial System (BIS).</description>
</item>
<item>
<title>Finite Map Extras</title>
<link>https://www.isa-afp.org/entries/Finite-Map-Extras.html</link>
<guid>https://www.isa-afp.org/entries/Finite-Map-Extras.html</guid>
<dc:creator> Javier Díaz </dc:creator>
<pubDate>12 Oct 2020 00:00:00 +0000</pubDate>
<description>
This entry includes useful syntactic sugar, new operators and functions, and
their associated lemmas for finite maps which currently are not
present in the standard Finite_Map theory.</description>
</item>
<item>
<title>A Formal Model of the Safely Composable Document Object Model with Shadow Roots</title>
<link>https://www.isa-afp.org/entries/Shadow_SC_DOM.html</link>
<guid>https://www.isa-afp.org/entries/Shadow_SC_DOM.html</guid>
<dc:creator> Achim D. Brucker, Michael Herzberg </dc:creator>
<pubDate>28 Sep 2020 00:00:00 +0000</pubDate>
<description>
In this AFP entry, we extend our formalization of the safely
composable DOM with Shadow Roots. This is a proposal for Shadow Roots
with stricter safety guarantess than the standard compliant
formalization (see &#34;Shadow DOM&#34;). Shadow Roots are a recent
proposal of the web community to support a component-based development
approach for client-side web applications. Shadow roots are a
significant extension to the DOM standard and, as web standards are
condemned to be backward compatible, such extensions often result in
complex specification that may contain unwanted subtleties that can be
detected by a formalization. Our Isabelle/HOL formalization is, in
the sense of object-orientation, an extension of our formalization of
the core DOM and enjoys the same basic properties, i.e., it is
extensible, i.e., can be extended without the need of re-proving
already proven properties and executable, i.e., we can generate
executable code from our specification. We exploit the executability
to show that our formalization complies to the official standard of
the W3C, respectively, the WHATWG.</description>
</item>
<item>
<title>A Formal Model of the Document Object Model with Shadow Roots</title>
<link>https://www.isa-afp.org/entries/Shadow_DOM.html</link>
<guid>https://www.isa-afp.org/entries/Shadow_DOM.html</guid>
<dc:creator> Achim D. Brucker, Michael Herzberg </dc:creator>
<pubDate>28 Sep 2020 00:00:00 +0000</pubDate>
<description>
In this AFP entry, we extend our formalization of the core DOM with
Shadow Roots. Shadow roots are a recent proposal of the web community
to support a component-based development approach for client-side web
applications. Shadow roots are a significant extension to the DOM
standard and, as web standards are condemned to be backward
compatible, such extensions often result in complex specification that
may contain unwanted subtleties that can be detected by a
formalization. Our Isabelle/HOL formalization is, in the sense of
object-orientation, an extension of our formalization of the core DOM
and enjoys the same basic properties, i.e., it is extensible, i.e.,
can be extended without the need of re-proving already proven
properties and executable, i.e., we can generate executable code from
our specification. We exploit the executability to show that our
formalization complies to the official standard of the W3C,
respectively, the WHATWG.</description>
</item>
<item>
<title>A Formalization of Safely Composable Web Components</title>
<link>https://www.isa-afp.org/entries/SC_DOM_Components.html</link>
<guid>https://www.isa-afp.org/entries/SC_DOM_Components.html</guid>
<dc:creator> Achim D. Brucker, Michael Herzberg </dc:creator>
<pubDate>28 Sep 2020 00:00:00 +0000</pubDate>
<description>
While the (safely composable) DOM with shadow trees provide the
technical basis for defining web components, it does neither defines
the concept of web components nor specifies the safety properties that
web components should guarantee. Consequently, the standard also does
not discuss how or even if the methods for modifying the DOM respect
component boundaries. In AFP entry, we present a formally verified
model of safely composable web components and define safety properties
which ensure that different web components can only interact with each
other using well-defined interfaces. Moreover, our verification of the
application programming interface (API) of the DOM revealed numerous
invariants that implementations of the DOM API need to preserve to
ensure the integrity of components. In comparison to the strict
standard compliance formalization of Web Components in the AFP entry
&#34;DOM_Components&#34;, the notion of components in this entry
(based on &#34;SC_DOM&#34; and &#34;Shadow_SC_DOM&#34;) provides
much stronger safety guarantees.</description>
</item>
<item>
<title>A Formalization of Web Components</title>
<link>https://www.isa-afp.org/entries/DOM_Components.html</link>
<guid>https://www.isa-afp.org/entries/DOM_Components.html</guid>
<dc:creator> Achim D. Brucker, Michael Herzberg </dc:creator>
<pubDate>28 Sep 2020 00:00:00 +0000</pubDate>
<description>
While the DOM with shadow trees provide the technical basis for
defining web components, the DOM standard neither defines the concept
of web components nor specifies the safety properties that web
components should guarantee. Consequently, the standard also does not
discuss how or even if the methods for modifying the DOM respect
component boundaries. In AFP entry, we present a formally verified
model of web components and define safety properties which ensure that
different web components can only interact with each other using
well-defined interfaces. Moreover, our verification of the application
programming interface (API) of the DOM revealed numerous invariants
that implementations of the DOM API need to preserve to ensure the
integrity of components.</description>
</item>
<item>
<title>The Safely Composable DOM</title>
<link>https://www.isa-afp.org/entries/Core_SC_DOM.html</link>
<guid>https://www.isa-afp.org/entries/Core_SC_DOM.html</guid>
<dc:creator> Achim D. Brucker, Michael Herzberg </dc:creator>
<pubDate>28 Sep 2020 00:00:00 +0000</pubDate>
<description>
In this AFP entry, we formalize the core of the Safely Composable
Document Object Model (SC DOM). The SC DOM improve the standard DOM
(as formalized in the AFP entry &#34;Core DOM&#34;) by strengthening
the tree boundaries set by shadow roots: in the SC DOM, the shadow
root is a sub-class of the document class (instead of a base class).
This modifications also results in changes to some API methods (e.g.,
getOwnerDocument) to return the nearest shadow root rather than the
document root. As a result, many API methods that, when called on a
node inside a shadow tree, would previously ``break out&#39;&#39;
and return or modify nodes that are possibly outside the shadow tree,
now stay within its boundaries. This change in behavior makes programs
that operate on shadow trees more predictable for the developer and
allows them to make more assumptions about other code accessing the
DOM.</description>
</item>
<item>
<title>Syntax-Independent Logic Infrastructure</title>
<link>https://www.isa-afp.org/entries/Syntax_Independent_Logic.html</link>
<guid>https://www.isa-afp.org/entries/Syntax_Independent_Logic.html</guid>
<dc:creator> Andrei Popescu, Dmitriy Traytel </dc:creator>
<pubDate>16 Sep 2020 00:00:00 +0000</pubDate>
<description>
We formalize a notion of logic whose terms and formulas are kept
abstract. In particular, logical connectives, substitution, free
variables, and provability are not defined, but characterized by their
general properties as locale assumptions. Based on this abstract
characterization, we develop further reusable reasoning
infrastructure. For example, we define parallel substitution (along
with proving its characterizing theorems) from single-point
substitution. Similarly, we develop a natural deduction style proof
system starting from the abstract Hilbert-style one. These one-time
efforts benefit different concrete logics satisfying our locales&#39;
assumptions. We instantiate the syntax-independent logic
infrastructure to Robinson arithmetic (also known as Q) in the AFP
entry &lt;a
href=&#34;https://www.isa-afp.org/entries/Robinson_Arithmetic.html&#34;&gt;Robinson_Arithmetic&lt;/a&gt;
and to hereditarily finite set theory in the AFP entries &lt;a
href=&#34;https://www.isa-afp.org/entries/Goedel_HFSet_Semantic.html&#34;&gt;Goedel_HFSet_Semantic&lt;/a&gt;
and &lt;a
href=&#34;https://www.isa-afp.org/entries/Goedel_HFSet_Semanticless.html&#34;&gt;Goedel_HFSet_Semanticless&lt;/a&gt;,
which are part of our formalization of G&amp;ouml;del&#39;s
Incompleteness Theorems described in our CADE-27 paper &lt;a
href=&#34;https://dx.doi.org/10.1007/978-3-030-29436-6_26&#34;&gt;A
Formally Verified Abstract Account of Gödel&#39;s Incompleteness
Theorems&lt;/a&gt;.</description>
</item>
<item>
<title>Robinson Arithmetic</title>
<link>https://www.isa-afp.org/entries/Robinson_Arithmetic.html</link>
<guid>https://www.isa-afp.org/entries/Robinson_Arithmetic.html</guid>
<dc:creator> Andrei Popescu, Dmitriy Traytel </dc:creator>
<pubDate>16 Sep 2020 00:00:00 +0000</pubDate>
<description>
We instantiate our syntax-independent logic infrastructure developed
in &lt;a
href=&#34;https://www.isa-afp.org/entries/Syntax_Independent_Logic.html&#34;&gt;a
separate AFP entry&lt;/a&gt; to the FOL theory of Robinson arithmetic
(also known as Q). The latter was formalised using Nominal Isabelle by
adapting &lt;a
href=&#34;https://www.isa-afp.org/entries/Incompleteness.html&#34;&gt;Larry
Paulson’s formalization of the Hereditarily Finite Set
theory&lt;/a&gt;.</description>
</item>
<item>
<title>An Abstract Formalization of G&ouml;del's Incompleteness Theorems</title>
<link>https://www.isa-afp.org/entries/Goedel_Incompleteness.html</link>
<guid>https://www.isa-afp.org/entries/Goedel_Incompleteness.html</guid>
<dc:creator> Andrei Popescu, Dmitriy Traytel </dc:creator>
<pubDate>16 Sep 2020 00:00:00 +0000</pubDate>
<description>
We present an abstract formalization of G&amp;ouml;del&#39;s
incompleteness theorems. We analyze sufficient conditions for the
theorems&#39; applicability to a partially specified logic. Our
abstract perspective enables a comparison between alternative
approaches from the literature. These include Rosser&#39;s variation
of the first theorem, Jeroslow&#39;s variation of the second theorem,
and the Swierczkowski&amp;ndash;Paulson semantics-based approach. This
AFP entry is the main entry point to the results described in our
CADE-27 paper &lt;a
href=&#34;https://dx.doi.org/10.1007/978-3-030-29436-6_26&#34;&gt;A
Formally Verified Abstract Account of Gödel&#39;s Incompleteness
Theorems&lt;/a&gt;. As part of our abstract formalization&#39;s
validation, we instantiate our locales twice in the separate AFP
entries &lt;a
href=&#34;https://www.isa-afp.org/entries/Goedel_HFSet_Semantic.html&#34;&gt;Goedel_HFSet_Semantic&lt;/a&gt;
and &lt;a
href=&#34;https://www.isa-afp.org/entries/Goedel_HFSet_Semanticless.html&#34;&gt;Goedel_HFSet_Semanticless&lt;/a&gt;.</description>
</item>
<item>
<title>From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part II</title>
<link>https://www.isa-afp.org/entries/Goedel_HFSet_Semanticless.html</link>
<guid>https://www.isa-afp.org/entries/Goedel_HFSet_Semanticless.html</guid>
<dc:creator> Andrei Popescu, Dmitriy Traytel </dc:creator>
<pubDate>16 Sep 2020 00:00:00 +0000</pubDate>
<description>
We validate an abstract formulation of G&amp;ouml;del&#39;s Second
Incompleteness Theorem from a &lt;a
href=&#34;https://www.isa-afp.org/entries/Goedel_Incompleteness.html&#34;&gt;separate
AFP entry&lt;/a&gt; by instantiating it to the case of &lt;i&gt;finite
consistent extensions of the Hereditarily Finite (HF) Set
theory&lt;/i&gt;, i.e., consistent FOL theories extending the HF Set
theory with a finite set of axioms. The instantiation draws heavily
on infrastructure previously developed by Larry Paulson in his &lt;a
href=&#34;https://www.isa-afp.org/entries/Incompleteness.html&#34;&gt;direct
formalisation of the concrete result&lt;/a&gt;. It strengthens
Paulson&#39;s formalization of G&amp;ouml;del&#39;s Second from that
entry by &lt;i&gt;not&lt;/i&gt; assuming soundness, and in fact not
relying on any notion of model or semantic interpretation. The
strengthening was obtained by first replacing some of Paulson’s
semantic arguments with proofs within his HF calculus, and then
plugging in some of Paulson&#39;s (modified) lemmas to instantiate
our soundness-free G&amp;ouml;del&#39;s Second locale.</description>
</item>
<item>
<title>From Abstract to Concrete G&ouml;del's Incompleteness Theorems&mdash;Part I</title>
<link>https://www.isa-afp.org/entries/Goedel_HFSet_Semantic.html</link>
<guid>https://www.isa-afp.org/entries/Goedel_HFSet_Semantic.html</guid>
<dc:creator> Andrei Popescu, Dmitriy Traytel </dc:creator>
<pubDate>16 Sep 2020 00:00:00 +0000</pubDate>
<description>
We validate an abstract formulation of G&amp;ouml;del&#39;s First and
Second Incompleteness Theorems from a &lt;a
href=&#34;https://www.isa-afp.org/entries/Goedel_Incompleteness.html&#34;&gt;separate
AFP entry&lt;/a&gt; by instantiating them to the case of
&lt;i&gt;finite sound extensions of the Hereditarily Finite (HF) Set
theory&lt;/i&gt;, i.e., FOL theories extending the HF Set theory with
a finite set of axioms that are sound in the standard model. The
concrete results had been previously formalised in an &lt;a
href=&#34;https://www.isa-afp.org/entries/Incompleteness.html&#34;&gt;AFP
entry by Larry Paulson&lt;/a&gt;; our instantiation reuses the
infrastructure developed in that entry.</description>
</item>
<item>
<title>A Formal Model of Extended Finite State Machines</title>
<link>https://www.isa-afp.org/entries/Extended_Finite_State_Machines.html</link>
<guid>https://www.isa-afp.org/entries/Extended_Finite_State_Machines.html</guid>
<dc:creator> Michael Foster, Achim D. Brucker, Ramsay G. Taylor, John Derrick </dc:creator>
<pubDate>07 Sep 2020 00:00:00 +0000</pubDate>
<description>
In this AFP entry, we provide a formalisation of extended finite state
machines (EFSMs) where models are represented as finite sets of
transitions between states. EFSMs execute traces to produce observable
outputs. We also define various simulation and equality metrics for
EFSMs in terms of traces and prove their strengths in relation to each
other. Another key contribution is a framework of function definitions
such that LTL properties can be phrased over EFSMs. Finally, we
provide a simple example case study in the form of a drinks machine.</description>
</item>
<item>
<title>Inference of Extended Finite State Machines</title>
<link>https://www.isa-afp.org/entries/Extended_Finite_State_Machine_Inference.html</link>
<guid>https://www.isa-afp.org/entries/Extended_Finite_State_Machine_Inference.html</guid>
<dc:creator> Michael Foster, Achim D. Brucker, Ramsay G. Taylor, John Derrick </dc:creator>
<pubDate>07 Sep 2020 00:00:00 +0000</pubDate>
<description>
In this AFP entry, we provide a formal implementation of a
state-merging technique to infer extended finite state machines
(EFSMs), complete with output and update functions, from black-box
traces. In particular, we define the subsumption in context relation
as a means of determining whether one transition is able to account
for the behaviour of another. Building on this, we define the direct
subsumption relation, which lifts the subsumption in context relation
to EFSM level such that we can use it to determine whether it is safe
to merge a given pair of transitions. Key proofs include the
conditions necessary for subsumption to occur and that subsumption
and direct subsumption are preorder relations. We also provide a
number of different heuristics which can be used to abstract away
concrete values into registers so that more states and transitions can
be merged and provide proofs of the various conditions which must hold
for these abstractions to subsume their ungeneralised counterparts. A
Code Generator setup to create executable Scala code is also defined.</description>
</item>
- <item>
- <title>Practical Algebraic Calculus Checker</title>
- <link>https://www.isa-afp.org/entries/PAC_Checker.html</link>
- <guid>https://www.isa-afp.org/entries/PAC_Checker.html</guid>
- <dc:creator> Mathias Fleury, Daniela Kaufmann </dc:creator>
- <pubDate>31 Aug 2020 00:00:00 +0000</pubDate>
- <description>
-Generating and checking proof certificates is important to increase
-the trust in automated reasoning tools. In recent years formal
-verification using computer algebra became more important and is
-heavily used in automated circuit verification. An existing proof
-format which covers algebraic reasoning and allows efficient proof
-checking is the practical algebraic calculus (PAC). In this
-development, we present the verified checker Pastèque that is obtained
-by synthesis via the Refinement Framework. This is the formalization
-going with our FMCAD&#39;20 tool presentation.</description>
- </item>
- <item>
- <title>Some classical results in inductive inference of recursive functions</title>
- <link>https://www.isa-afp.org/entries/Inductive_Inference.html</link>
- <guid>https://www.isa-afp.org/entries/Inductive_Inference.html</guid>
- <dc:creator> Frank J. Balbach </dc:creator>
- <pubDate>31 Aug 2020 00:00:00 +0000</pubDate>
- <description>
-&lt;p&gt; This entry formalizes some classical concepts and results
-from inductive inference of recursive functions. In the basic setting
-a partial recursive function (&#34;strategy&#34;) must identify
-(&#34;learn&#34;) all functions from a set (&#34;class&#34;) of
-recursive functions. To that end the strategy receives more and more
-values $f(0), f(1), f(2), \ldots$ of some function $f$ from the given
-class and in turn outputs descriptions of partial recursive functions,
-for example, Gödel numbers. The strategy is considered successful if
-the sequence of outputs (&#34;hypotheses&#34;) converges to a
-description of $f$. A class of functions learnable in this sense is
-called &#34;learnable in the limit&#34;. The set of all these
-classes is denoted by LIM. &lt;/p&gt; &lt;p&gt; Other types of
-inference considered are finite learning (FIN), behaviorally correct
-learning in the limit (BC), and some variants of LIM with restrictions
-on the hypotheses: total learning (TOTAL), consistent learning (CONS),
-and class-preserving learning (CP). The main results formalized are
-the proper inclusions $\mathrm{FIN} \subset \mathrm{CP} \subset
-\mathrm{TOTAL} \subset \mathrm{CONS} \subset \mathrm{LIM} \subset
-\mathrm{BC} \subset 2^{\mathcal{R}}$, where $\mathcal{R}$ is the set
-of all total recursive functions. Further results show that for all
-these inference types except CONS, strategies can be assumed to be
-total recursive functions; that all inference types but CP are closed
-under the subset relation between classes; and that no inference type
-is closed under the union of classes. &lt;/p&gt; &lt;p&gt; The above
-is based on a formalization of recursive functions heavily inspired by
-the &lt;a
-href=&#34;https://www.isa-afp.org/entries/Universal_Turing_Machine.html&#34;&gt;Universal
-Turing Machine&lt;/a&gt; entry by Xu et al., but different in that it
-models partial functions with codomain &lt;em&gt;nat
-option&lt;/em&gt;. The formalization contains a construction of a
-universal partial recursive function, without resorting to Turing
-machines, introduces decidability and recursive enumerability, and
-proves some standard results: existence of a Kleene normal form, the
-&lt;em&gt;s-m-n&lt;/em&gt; theorem, Rice&#39;s theorem, and assorted
-fixed-point theorems (recursion theorems) by Kleene, Rogers, and
-Smullyan. &lt;/p&gt;</description>
- </item>
</channel>
</rss>
diff --git a/web/statistics.html b/web/statistics.html
--- a/web/statistics.html
+++ b/web/statistics.html
@@ -1,302 +1,302 @@
<!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 class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1><font class="first">S</font>tatistics
</h1>
<p>&nbsp;</p>
<table width="80%" class="descr">
<tbody>
<tr><td>
<h2>Statistics</h2>
<table>
-<tr><td>Number of Articles:</td><td class="statsnumber">582</td></tr>
-<tr><td>Number of Authors:</td><td class="statsnumber">374</td></tr>
-<tr><td>Number of lemmas:</td><td class="statsnumber">~163,600</td></tr>
-<tr><td>Lines of Code:</td><td class="statsnumber">~2,854,700</td></tr>
+<tr><td>Number of Articles:</td><td class="statsnumber">584</td></tr>
+<tr><td>Number of Authors:</td><td class="statsnumber">375</td></tr>
+<tr><td>Number of lemmas:</td><td class="statsnumber">~163,900</td></tr>
+<tr><td>Lines of Code:</td><td class="statsnumber">~2,861,000</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/List-Index.html">List-Index</a></td>
<td>17</td>
</tr>
<tr><td>2.</td>
<td><a href="entries/Coinductive.html">Coinductive</a></td>
<td>12</td>
</tr>
<td></td>
<td><a href="entries/Collections.html">Collections</a></td>
<td>12</td>
</tr>
<td></td>
<td><a href="entries/Regular-Sets.html">Regular-Sets</a></td>
<td>12</td>
</tr>
<tr><td>3.</td>
<td><a href="entries/Landau_Symbols.html">Landau_Symbols</a></td>
<td>11</td>
</tr>
<td></td>
<td><a href="entries/Show.html">Show</a></td>
<td>11</td>
</tr>
<tr><td>4.</td>
<td><a href="entries/Polynomial_Factorization.html">Polynomial_Factorization</a></td>
<td>10</td>
</tr>
<tr><td>5.</td>
<td><a href="entries/Abstract-Rewriting.html">Abstract-Rewriting</a></td>
<td>9</td>
</tr>
<td></td>
<td><a href="entries/Automatic_Refinement.html">Automatic_Refinement</a></td>
<td>9</td>
</tr>
<td></td>
<td><a href="entries/Deriving.html">Deriving</a></td>
<td>9</td>
</tr>
<td></td>
<td><a href="entries/Jordan_Normal_Form.html">Jordan_Normal_Form</a></td>
<td>9</td>
</tr>
</table>
<script>
// DATA
var years = [2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021];
-var no_articles = [14, 22, 29, 37, 52, 64, 86, 103, 128, 151, 208, 253, 326, 396, 455, 511, 577, 582];
-var no_loc = [60900.0, 96700.0, 131300.0, 238800.0, 353700.0, 435900.0, 517100.0, 568200.0, 740500.0, 828500.0, 1038900.0, 1219600.0, 1597900.0, 1850300.0, 2122200.0, 2422000.0, 2801700.0, 2854700.0 ];
-var no_authors = [14, 11, 6, 6, 10, 6, 24, 11, 17, 16, 36, 20, 63, 31, 28, 38, 33, 4];
-var no_authors_series = [14, 25, 31, 37, 47, 53, 77, 88, 105, 121, 157, 177, 240, 271, 299, 337, 370, 374];
-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","Triangle","Prime_Harmonic_Series","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","Randomised_BSTs","Lambda_Free_EPO","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","Differential_Game_Logic","IMP2_Binary_Heap","Groebner_Macaulay","Nullstellensatz","Linear_Inequalities","Priority_Search_Trees","Prim_Dijkstra_Simple","Complete_Non_Orders","MFOTL_Monitor","CakeML_Codegen","FOL_Seq_Calc1","Szpilrajn","TESL_Language","Stellar_Quorums","IMO2019","C2KA_DistributedSystems","Linear_Programming","Laplace_Transform","Adaptive_State_Counting","Jacobson_Basic_Algebra","Fourier","Hybrid_Systems_VCs","Generic_Join","Clean","Sigma_Commit_Crypto","Aristotles_Assertoric_Syllogistic","VerifyThis2019","Isabelle_C","ZFC_in_HOL","Interval_Arithmetic_Word32","Generalized_Counting_Sort","Gauss_Sums","Poincare_Disc","Complex_Geometry","Poincare_Bendixson","Hybrid_Logic","Zeta_3_Irrational","Bicategory","Skip_Lists","Closest_Pair_Points","Approximation_Algorithms","Mersenne_Primes","Subset_Boolean_Algebras","Arith_Prog_Rel_Primes","VeriComp","Goodstein_Lambda","Hello_World","Relational-Incorrectness-Logic","Furstenberg_Topology","WOOT_Strong_Eventual_Consistency","Lucas_Theorem","Automated_Stateful_Protocol_Verification","Stateful_Protocol_Composition_and_Typing","MFODL_Monitor_Optimized","Saturation_Framework","Sliding_Window_Algorithm","ADS_Functor","Matrices_for_ODEs","Power_Sum_Polynomials","Lambert_W","Gaussian_Integers","Attack_Trees","Banach_Steinhaus","Forcing","LTL_Normal_Form","Recursion-Addition","Irrational_Series_Erdos_Straus","Knuth_Bendix_Order","Nash_Williams","Smith_Normal_Form","Safe_Distance","Relational_Paths","Chandy_Lamport","Ordinal_Partitions","Amicable_Numbers","BirdKMP","Saturation_Framework_Extensions","Relational_Disjoint_Set_Forests","PAC_Checker","Inductive_Inference","Extended_Finite_State_Machine_Inference","Extended_Finite_State_Machines","Goedel_HFSet_Semanticless","Syntax_Independent_Logic","Goedel_HFSet_Semantic","Goedel_Incompleteness","Robinson_Arithmetic","Shadow_SC_DOM","Shadow_DOM","DOM_Components","Core_SC_DOM","SC_DOM_Components","Finite-Map-Extras","Physical_Quantities","Verified_SAT_Based_AI_Planning","AI_Planning_Languages_Semantics","CSP_RefTK","Isabelle_Marries_Dirac","Relational_Method","Interpreter_Optimizations","Relational_Minimum_Spanning_Trees","Topological_Semantics","Delta_System_Lemma","JinjaDCI","Hood_Melville_Queue","Blue_Eyes","IsaGeoCoq","Laws_of_Large_Numbers"];
-var years_loc_articles = [ 2004 , , , , , , , , , , , , , ,2005 , , , , , , , ,2006 , , , , , , ,2007 , , , , , , , ,2008 , , , , , , , , , , , , , , ,2009 , , , , , , , , , , , ,2010 , , , , , , , , , , , , , , , , , , , , , ,2011 , , , , , , , , , , , , , , , , ,2012 , , , , , , , , , , , , , , , , , , , , , , , , ,2013 , , , , , , , , , , , , , , , , , , , , , , ,2014 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2015 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2016 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2017 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2018 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2019 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2020 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2021 , , , ,];
-var loc_articles = [ "1798","839","1544","1096","1058","2419","44227","205","142","1994","209","1110","3792","506","1141","3769","17206","3119","6430","1145","447","2537","1275","1583","1838","12832","13126","2685","1228","3556","4238","9649","970","2847","1741","79746","4738","3396","2185","31176","10664","6723","30332","180","793","1047","14413","2080","254","2221","5959","3463","799","1540","684","6654","8","2627","27490","264","32553","5025","4380","208","9533","447","2380","3399","611","6311","2042","840","713","1024","5632","1427","4078","2230","6002","22617","1602","1587","3370","2451","2591","260","1617","16","2937","7805","6557","6381","992","125","10134","332","235","1828","1039","1784","4425","434","4461","11857","2835","8583","1043","408","2940","2613","38084","3243","1480","2612","3157","27588","2580","25274","2266","4107","7701","1245","260","5309","73","9729","719","6673","1511","4354","1249","1908","6214","4979","10110","7894","538","3830","4591","202","848","1777","5512","10319","1524","150","5292","706","10776","2248","1463","1958","3067","11485","1860","1190","1219","2175","1144","14861","2215","1964","166","10685","6420","572","590","1698","465","883","4133","2138","1403","2280","1959","2467","220","5429","4433","9390","3999","4463","406","5935","1829","12828","3214","9486","4560","931","659","63","2338","1653","9143","753","2113","875","1727","627","931","1201","1296","7880","1922","90","28055","2879","2796","1116","4863","5259","8842","1344","6178","527","2606","6658","1782","5327","1085","4103","952","2446","1089","1064","2362","468","2074","3761","2148","710","16080","8267","908","1063","21109","9679","8658","3142","9161","695","435","13992","478","898","2724","10637","1162","401","498","495","741","843","3622","4616","6284","4102","8166","12108","3178","518","17583","2876","2411","5496","2453","885","1162","17386","509","702","5036","10363","4287","5331","3811","656","329","1057","14033","3257","2593","553","8478","206","25451","8773","3278","398","2960","12833","9483","370","173","384","18976","2545","6119","3779","1017","2608","4338","9356","20045","4053","3420","319","3208","169","19521","541","14634","2651","7058","7590","3898","3244","4546","855","2289","5020","1349","276","4339","1475","3482","7119","9662","601","1722","852","2194","12222","4173","590","13558","1695","4484","1640","835","694","737","3346","105","68","10492","1127","8513","4135","4711","1200","378","11280","2078","14059","639","2283","3930","4869","398","1531","5554","5665","1993","4205","478","4121","3146","3471","88","480","1261","1877","2193","250","10669","854","7463","5301","3083","2784","8849","5261","2325","6164","945","6514","992","489","810","8891","3133","338","854","493","4585","9457","15962","6326","10345","1818","2288","785","3260","8438","3278","12958","592","841","3383","3638","11570","13548","3734","6597","530","965","7674","1042","1221","5297","2754","1390","1622","2173","13358","805","10026","2667","541","1271","2668","5318","9770","2765","934","11918","1743","2355","7917","1490","449","685","1811","1132","3540","3578","1644","2983","2218","5182","4968","2767","17369","34365","3259","6022","1900","372","10305","16866","3018","3298","5304","4576","10485","986","15843","4437","9487","5543","3301","1264","2973","805","10253","2606","5262","472","3365","3603","3199","13339","951","192","4455","527","713","782","2335","2134","9934","2090","3736","5752","2350","3195","3809","176","1726","8509","6892","5069","5730","4561","10314","14530","6402","4470","1907","67700","2450","3936","3086","1699","3154","944","933","596","370","691","764","2564","332","14517","21775","10948","3059","744","2353","1559","1239","1609","2537","1939","1337","11999","1034","1444","1902","2670","832","12970","3028","5074","9796","6679","1261","2908","1929","2074","9116","12872","4265","4747","11477","8100","426","3546","1295","15453","12769","3523","16385","7798","648","1761","16434","1967","2359","7700","3752","4280","4556","2826","3295","25018","747","363","26525","290"];
+var no_articles = [14, 22, 29, 37, 52, 64, 86, 103, 128, 151, 208, 253, 326, 396, 455, 511, 577, 584];
+var no_loc = [60900.0, 96700.0, 131300.0, 238800.0, 353700.0, 435900.0, 517100.0, 568200.0, 740500.0, 828500.0, 1038900.0, 1219600.0, 1597800.0, 1850200.0, 2122200.0, 2421500.0, 2801200.0, 2861000.0 ];
+var no_authors = [14, 11, 6, 6, 10, 6, 24, 11, 17, 16, 36, 20, 63, 31, 28, 38, 33, 5];
+var no_authors_series = [14, 25, 31, 37, 47, 53, 77, 88, 105, 121, 157, 177, 240, 271, 299, 337, 370, 375];
+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","Triangle","Prime_Harmonic_Series","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","Randomised_BSTs","Lambda_Free_EPO","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","Differential_Game_Logic","IMP2_Binary_Heap","Groebner_Macaulay","Nullstellensatz","Linear_Inequalities","Priority_Search_Trees","Prim_Dijkstra_Simple","Complete_Non_Orders","MFOTL_Monitor","CakeML_Codegen","FOL_Seq_Calc1","Szpilrajn","TESL_Language","Stellar_Quorums","IMO2019","C2KA_DistributedSystems","Linear_Programming","Laplace_Transform","Adaptive_State_Counting","Jacobson_Basic_Algebra","Fourier","Hybrid_Systems_VCs","Generic_Join","Clean","Sigma_Commit_Crypto","Aristotles_Assertoric_Syllogistic","VerifyThis2019","Isabelle_C","ZFC_in_HOL","Interval_Arithmetic_Word32","Generalized_Counting_Sort","Gauss_Sums","Poincare_Disc","Complex_Geometry","Poincare_Bendixson","Hybrid_Logic","Zeta_3_Irrational","Bicategory","Skip_Lists","Closest_Pair_Points","Approximation_Algorithms","Mersenne_Primes","Subset_Boolean_Algebras","Arith_Prog_Rel_Primes","VeriComp","Goodstein_Lambda","Hello_World","Relational-Incorrectness-Logic","Furstenberg_Topology","WOOT_Strong_Eventual_Consistency","Lucas_Theorem","Automated_Stateful_Protocol_Verification","Stateful_Protocol_Composition_and_Typing","MFODL_Monitor_Optimized","Saturation_Framework","Sliding_Window_Algorithm","ADS_Functor","Matrices_for_ODEs","Power_Sum_Polynomials","Lambert_W","Gaussian_Integers","Attack_Trees","Banach_Steinhaus","Forcing","LTL_Normal_Form","Recursion-Addition","Irrational_Series_Erdos_Straus","Knuth_Bendix_Order","Nash_Williams","Smith_Normal_Form","Safe_Distance","Relational_Paths","Chandy_Lamport","Ordinal_Partitions","Amicable_Numbers","BirdKMP","Saturation_Framework_Extensions","Relational_Disjoint_Set_Forests","PAC_Checker","Inductive_Inference","Extended_Finite_State_Machine_Inference","Extended_Finite_State_Machines","Goedel_HFSet_Semanticless","Syntax_Independent_Logic","Goedel_HFSet_Semantic","Goedel_Incompleteness","Robinson_Arithmetic","Shadow_SC_DOM","Shadow_DOM","DOM_Components","Core_SC_DOM","SC_DOM_Components","Finite-Map-Extras","Physical_Quantities","Verified_SAT_Based_AI_Planning","AI_Planning_Languages_Semantics","CSP_RefTK","Isabelle_Marries_Dirac","Relational_Method","Interpreter_Optimizations","Relational_Minimum_Spanning_Trees","Topological_Semantics","Delta_System_Lemma","JinjaDCI","Hood_Melville_Queue","Blue_Eyes","IsaGeoCoq","Laws_of_Large_Numbers","Formal_Puiseux_Series","BTree"];
+var years_loc_articles = [ 2004 , , , , , , , , , , , , , ,2005 , , , , , , , ,2006 , , , , , , ,2007 , , , , , , , ,2008 , , , , , , , , , , , , , , ,2009 , , , , , , , , , , , ,2010 , , , , , , , , , , , , , , , , , , , , , ,2011 , , , , , , , , , , , , , , , , ,2012 , , , , , , , , , , , , , , , , , , , , , , , , ,2013 , , , , , , , , , , , , , , , , , , , , , , ,2014 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2015 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2016 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2017 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2018 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2019 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2020 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,2021 , , , , , ,];
+var loc_articles = [ "1798","839","1544","1096","1058","2419","44227","205","142","1994","209","1110","3792","506","1141","3769","17206","3119","6430","1145","447","2537","1275","1583","1838","12832","13126","2685","1228","3556","4238","9649","970","2847","1741","79746","4738","3396","2185","31176","10664","6723","30332","180","793","1047","14413","2080","254","2221","5959","3463","799","1540","684","6654","8","2627","27490","264","32553","5025","4380","208","9533","447","2380","3399","611","6311","2042","840","713","1024","5632","1427","4078","2230","6002","22617","1602","1587","3370","2451","2591","260","1617","16","2937","7805","6557","6381","992","125","10134","332","235","1828","1039","1784","4425","434","4461","11857","2835","8583","1043","408","2940","2613","38084","3243","1480","2612","3157","27588","2580","25274","2266","4107","7701","1245","260","5309","73","9729","719","6673","1511","4354","1249","1908","6214","4979","10110","7894","538","3830","4591","202","848","1777","5512","10319","1524","150","5292","706","10776","2248","1463","1958","3067","11485","1860","1190","1219","2175","1144","14861","2215","1964","166","10685","6420","572","590","1698","465","883","4133","2138","1403","2280","1959","2467","220","5429","4433","9390","3999","4463","406","5935","1829","12828","3214","9486","4560","931","659","63","2338","1653","9143","753","2113","875","1727","627","931","1201","1296","7880","1922","90","28055","2879","2796","1116","4863","5259","8842","1344","6178","527","2606","6658","1782","5327","1085","4103","952","2446","1089","1064","2362","468","2074","3761","2148","710","16080","8267","908","1063","21109","9679","8659","3142","9161","695","435","13984","478","898","2724","10637","1162","401","498","495","741","838","3622","4616","6284","4102","8166","12108","3178","518","17583","2876","2411","5496","2453","885","1162","17386","509","702","5036","10363","4287","5331","3811","656","329","1057","14033","3257","2593","553","8478","206","25451","8773","3275","398","2960","12822","9483","370","173","384","18976","2545","6119","3779","1017","2608","4338","9356","20045","4053","3420","319","3208","169","19521","541","14634","2651","7058","7590","3898","3244","4546","855","2289","5020","1349","276","4339","1475","3482","7119","9662","601","1722","852","2194","12222","4173","590","13558","1695","4484","1640","835","694","737","3346","105","68","10492","1127","8513","4135","4711","1200","378","11280","2078","14059","639","2283","3930","4869","397","1531","5554","5665","1993","4205","478","4121","3146","3471","88","480","1261","1877","2193","250","10669","854","7463","5301","3083","2784","8844","5261","2325","6164","945","6514","992","489","810","8891","3133","338","854","493","4585","9457","15962","6326","10345","1818","2288","785","3260","8438","3278","12958","592","841","3383","3638","11570","13548","3734","6597","530","965","7674","1042","1221","5297","2754","1390","1622","2173","13358","805","10026","2667","541","1271","2668","5318","9770","2765","934","11918","1743","2355","7917","1490","449","685","1811","1132","3540","3578","1644","2983","2218","5182","4968","2767","17369","34365","3259","6022","1900","372","10305","16866","3018","3298","5304","4576","10485","986","15843","4437","9487","5543","3301","1264","2973","805","10253","2606","5262","472","3365","3603","3199","13339","951","192","4455","527","713","782","2335","2134","9934","2090","3736","5752","2350","3195","3809","176","1726","8509","6892","5069","5730","4561","10292","14170","6402","4470","1907","67700","2355","3936","3086","1699","3154","944","933","596","370","691","764","2564","332","14517","21775","10948","3059","744","2353","1559","1239","1609","2537","1939","1337","11999","1034","1444","1902","2670","832","12970","3028","5074","9796","6679","1261","2908","1929","2074","9116","12872","4265","4747","11477","8100","426","3546","1295","15453","12769","3523","16385","7798","648","1761","16434","1967","2359","7700","3752","4280","4556","2826","3295","25018","747","363","26525","290","2582","4265"];
</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,940 +1,942 @@
<!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 class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1><font class="first">I</font>ndex by <font class="first">T</font>opic
</h1>
<p>&nbsp;</p>
<table width="80%" class="descr">
<tbody>
<tr>
<td>
<h2>Computer science</h2>
<div class="list">
</div>
<h3>Artificial intelligence</h3>
<div class="list">
<a href="entries/AI_Planning_Languages_Semantics.html">AI_Planning_Languages_Semantics</a> &nbsp;
<a href="entries/Verified_SAT_Based_AI_Planning.html">Verified_SAT_Based_AI_Planning</a> &nbsp;
</div>
<h3>Automata and formal languages</h3>
<div class="list">
<a href="entries/Partial_Order_Reduction.html">Partial_Order_Reduction</a> &nbsp;
<a href="entries/C2KA_DistributedSystems.html">C2KA_DistributedSystems</a> &nbsp;
<a href="entries/Posix-Lexing.html">Posix-Lexing</a> &nbsp;
<a href="entries/LocalLexing.html">LocalLexing</a> &nbsp;
<a href="entries/KBPs.html">KBPs</a> &nbsp;
<a href="entries/Regular-Sets.html">Regular-Sets</a> &nbsp;
<a href="entries/Regex_Equivalence.html">Regex_Equivalence</a> &nbsp;
<a href="entries/MSO_Regex_Equivalence.html">MSO_Regex_Equivalence</a> &nbsp;
<a href="entries/Formula_Derivatives.html">Formula_Derivatives</a> &nbsp;
<a href="entries/Myhill-Nerode.html">Myhill-Nerode</a> &nbsp;
<a href="entries/Universal_Turing_Machine.html">Universal_Turing_Machine</a> &nbsp;
<a href="entries/CYK.html">CYK</a> &nbsp;
<a href="entries/Presburger-Automata.html">Presburger-Automata</a> &nbsp;
<a href="entries/Functional-Automata.html">Functional-Automata</a> &nbsp;
<a href="entries/Statecharts.html">Statecharts</a> &nbsp;
<a href="entries/Stuttering_Equivalence.html">Stuttering_Equivalence</a> &nbsp;
<a href="entries/Coinductive_Languages.html">Coinductive_Languages</a> &nbsp;
<a href="entries/Tree-Automata.html">Tree-Automata</a> &nbsp;
<a href="entries/Kleene_Algebra.html">Kleene_Algebra</a> &nbsp;
<a href="entries/KAT_and_DRA.html">KAT_and_DRA</a> &nbsp;
<a href="entries/KAD.html">KAD</a> &nbsp;
<a href="entries/Regular_Algebras.html">Regular_Algebras</a> &nbsp;
<a href="entries/Markov_Models.html">Markov_Models</a> &nbsp;
<a href="entries/Probabilistic_System_Zoo.html">Probabilistic_System_Zoo</a> &nbsp;
<a href="entries/CAVA_Automata.html">CAVA_Automata</a> &nbsp;
<a href="entries/LTL.html">LTL</a> &nbsp;
<a href="entries/LTL_to_GBA.html">LTL_to_GBA</a> &nbsp;
<a href="entries/CAVA_LTL_Modelchecker.html">CAVA_LTL_Modelchecker</a> &nbsp;
<a href="entries/Probabilistic_Timed_Automata.html">Probabilistic_Timed_Automata</a> &nbsp;
<a href="entries/Finite_Automata_HF.html">Finite_Automata_HF</a> &nbsp;
<a href="entries/LTL_to_DRA.html">LTL_to_DRA</a> &nbsp;
<a href="entries/Timed_Automata.html">Timed_Automata</a> &nbsp;
<a href="entries/Stochastic_Matrices.html">Stochastic_Matrices</a> &nbsp;
<a href="entries/Buchi_Complementation.html">Buchi_Complementation</a> &nbsp;
<a href="entries/Transition_Systems_and_Automata.html">Transition_Systems_and_Automata</a> &nbsp;
<a href="entries/Factored_Transition_System_Bounding.html">Factored_Transition_System_Bounding</a> &nbsp;
<a href="entries/LTL_Master_Theorem.html">LTL_Master_Theorem</a> &nbsp;
<a href="entries/MFOTL_Monitor.html">MFOTL_Monitor</a> &nbsp;
<a href="entries/Adaptive_State_Counting.html">Adaptive_State_Counting</a> &nbsp;
<a href="entries/MFODL_Monitor_Optimized.html">MFODL_Monitor_Optimized</a> &nbsp;
<a href="entries/LTL_Normal_Form.html">LTL_Normal_Form</a> &nbsp;
<a href="entries/Extended_Finite_State_Machines.html">Extended_Finite_State_Machines</a> &nbsp;
<a href="entries/Extended_Finite_State_Machine_Inference.html">Extended_Finite_State_Machine_Inference</a> &nbsp;
</div>
<h3>Algorithms</h3>
<div class="list">
<a href="entries/Knuth_Morris_Pratt.html">Knuth_Morris_Pratt</a> &nbsp;
<a href="entries/Probabilistic_While.html">Probabilistic_While</a> &nbsp;
<a href="entries/Comparison_Sort_Lower_Bound.html">Comparison_Sort_Lower_Bound</a> &nbsp;
<a href="entries/Quick_Sort_Cost.html">Quick_Sort_Cost</a> &nbsp;
<a href="entries/TortoiseHare.html">TortoiseHare</a> &nbsp;
<a href="entries/Selection_Heap_Sort.html">Selection_Heap_Sort</a> &nbsp;
<a href="entries/VerifyThis2018.html">VerifyThis2018</a> &nbsp;
<a href="entries/CYK.html">CYK</a> &nbsp;
<a href="entries/Boolean_Expression_Checkers.html">Boolean_Expression_Checkers</a> &nbsp;
<a href="entries/Efficient-Mergesort.html">Efficient-Mergesort</a> &nbsp;
<a href="entries/SATSolverVerification.html">SATSolverVerification</a> &nbsp;
<a href="entries/MuchAdoAboutTwo.html">MuchAdoAboutTwo</a> &nbsp;
<a href="entries/First_Order_Terms.html">First_Order_Terms</a> &nbsp;
<a href="entries/Monad_Memo_DP.html">Monad_Memo_DP</a> &nbsp;
<a href="entries/Hidden_Markov_Models.html">Hidden_Markov_Models</a> &nbsp;
<a href="entries/Imperative_Insertion_Sort.html">Imperative_Insertion_Sort</a> &nbsp;
<a href="entries/Formal_SSA.html">Formal_SSA</a> &nbsp;
<a href="entries/ROBDD.html">ROBDD</a> &nbsp;
<a href="entries/Median_Of_Medians_Selection.html">Median_Of_Medians_Selection</a> &nbsp;
<a href="entries/Fisher_Yates.html">Fisher_Yates</a> &nbsp;
<a href="entries/Optimal_BST.html">Optimal_BST</a> &nbsp;
<a href="entries/IMP2.html">IMP2</a> &nbsp;
<a href="entries/Auto2_Imperative_HOL.html">Auto2_Imperative_HOL</a> &nbsp;
<a href="entries/List_Inversions.html">List_Inversions</a> &nbsp;
<a href="entries/IMP2_Binary_Heap.html">IMP2_Binary_Heap</a> &nbsp;
<a href="entries/MFOTL_Monitor.html">MFOTL_Monitor</a> &nbsp;
<a href="entries/Adaptive_State_Counting.html">Adaptive_State_Counting</a> &nbsp;
<a href="entries/Generic_Join.html">Generic_Join</a> &nbsp;
<a href="entries/VerifyThis2019.html">VerifyThis2019</a> &nbsp;
<a href="entries/Generalized_Counting_Sort.html">Generalized_Counting_Sort</a> &nbsp;
<a href="entries/MFODL_Monitor_Optimized.html">MFODL_Monitor_Optimized</a> &nbsp;
<a href="entries/Sliding_Window_Algorithm.html">Sliding_Window_Algorithm</a> &nbsp;
<a href="entries/PAC_Checker.html">PAC_Checker</a> &nbsp;
<strong>Graph:</strong>
<a href="entries/DFS_Framework.html">DFS_Framework</a> &nbsp;
<a href="entries/Prpu_Maxflow.html">Prpu_Maxflow</a> &nbsp;
<a href="entries/Floyd_Warshall.html">Floyd_Warshall</a> &nbsp;
<a href="entries/Roy_Floyd_Warshall.html">Roy_Floyd_Warshall</a> &nbsp;
<a href="entries/Dijkstra_Shortest_Path.html">Dijkstra_Shortest_Path</a> &nbsp;
<a href="entries/EdmondsKarp_Maxflow.html">EdmondsKarp_Maxflow</a> &nbsp;
<a href="entries/Depth-First-Search.html">Depth-First-Search</a> &nbsp;
<a href="entries/GraphMarkingIBP.html">GraphMarkingIBP</a> &nbsp;
<a href="entries/Transitive-Closure.html">Transitive-Closure</a> &nbsp;
<a href="entries/Transitive-Closure-II.html">Transitive-Closure-II</a> &nbsp;
<a href="entries/Gabow_SCC.html">Gabow_SCC</a> &nbsp;
<a href="entries/Kruskal.html">Kruskal</a> &nbsp;
<a href="entries/Prim_Dijkstra_Simple.html">Prim_Dijkstra_Simple</a> &nbsp;
<a href="entries/Relational_Minimum_Spanning_Trees.html">Relational_Minimum_Spanning_Trees</a> &nbsp;
<strong>Distributed:</strong>
<a href="entries/DiskPaxos.html">DiskPaxos</a> &nbsp;
<a href="entries/GenClock.html">GenClock</a> &nbsp;
<a href="entries/ClockSynchInst.html">ClockSynchInst</a> &nbsp;
<a href="entries/Heard_Of.html">Heard_Of</a> &nbsp;
<a href="entries/Consensus_Refined.html">Consensus_Refined</a> &nbsp;
<a href="entries/Abortable_Linearizable_Modules.html">Abortable_Linearizable_Modules</a> &nbsp;
<a href="entries/IMAP-CRDT.html">IMAP-CRDT</a> &nbsp;
<a href="entries/CRDT.html">CRDT</a> &nbsp;
<a href="entries/Chandy_Lamport.html">Chandy_Lamport</a> &nbsp;
<a href="entries/OpSets.html">OpSets</a> &nbsp;
<a href="entries/Stellar_Quorums.html">Stellar_Quorums</a> &nbsp;
<a href="entries/WOOT_Strong_Eventual_Consistency.html">WOOT_Strong_Eventual_Consistency</a> &nbsp;
<strong>Concurrent:</strong>
<a href="entries/ConcurrentGC.html">ConcurrentGC</a> &nbsp;
<strong>Online:</strong>
<a href="entries/List_Update.html">List_Update</a> &nbsp;
<strong>Geometry:</strong>
<a href="entries/Closest_Pair_Points.html">Closest_Pair_Points</a> &nbsp;
<strong>Approximation:</strong>
<a href="entries/Approximation_Algorithms.html">Approximation_Algorithms</a> &nbsp;
<strong>Mathematical:</strong>
<a href="entries/FFT.html">FFT</a> &nbsp;
<a href="entries/Gauss-Jordan-Elim-Fun.html">Gauss-Jordan-Elim-Fun</a> &nbsp;
<a href="entries/UpDown_Scheme.html">UpDown_Scheme</a> &nbsp;
<a href="entries/Polynomials.html">Polynomials</a> &nbsp;
<a href="entries/Gauss_Jordan.html">Gauss_Jordan</a> &nbsp;
<a href="entries/Echelon_Form.html">Echelon_Form</a> &nbsp;
<a href="entries/QR_Decomposition.html">QR_Decomposition</a> &nbsp;
<a href="entries/Hermite.html">Hermite</a> &nbsp;
<a href="entries/Groebner_Bases.html">Groebner_Bases</a> &nbsp;
<a href="entries/Diophantine_Eqns_Lin_Hom.html">Diophantine_Eqns_Lin_Hom</a> &nbsp;
<a href="entries/Taylor_Models.html">Taylor_Models</a> &nbsp;
<a href="entries/LLL_Basis_Reduction.html">LLL_Basis_Reduction</a> &nbsp;
<a href="entries/Signature_Groebner.html">Signature_Groebner</a> &nbsp;
<a href="entries/Smith_Normal_Form.html">Smith_Normal_Form</a> &nbsp;
<a href="entries/Safe_Distance.html">Safe_Distance</a> &nbsp;
<strong>Optimization:</strong>
<a href="entries/Simplex.html">Simplex</a> &nbsp;
<strong>Quantum computing:</strong>
<a href="entries/Isabelle_Marries_Dirac.html">Isabelle_Marries_Dirac</a> &nbsp;
</div>
<h3>Concurrency</h3>
<div class="list">
<a href="entries/FLP.html">FLP</a> &nbsp;
<a href="entries/Concurrent_Ref_Alg.html">Concurrent_Ref_Alg</a> &nbsp;
<a href="entries/Concurrent_Revisions.html">Concurrent_Revisions</a> &nbsp;
<a href="entries/Store_Buffer_Reduction.html">Store_Buffer_Reduction</a> &nbsp;
<a href="entries/TESL_Language.html">TESL_Language</a> &nbsp;
<strong>Process calculi:</strong>
<a href="entries/Noninterference_Generic_Unwinding.html">Noninterference_Generic_Unwinding</a> &nbsp;
<a href="entries/AODV.html">AODV</a> &nbsp;
<a href="entries/AWN.html">AWN</a> &nbsp;
<a href="entries/CCS.html">CCS</a> &nbsp;
<a href="entries/Pi_Calculus.html">Pi_Calculus</a> &nbsp;
<a href="entries/Psi_Calculi.html">Psi_Calculi</a> &nbsp;
<a href="entries/Encodability_Process_Calculi.html">Encodability_Process_Calculi</a> &nbsp;
<a href="entries/Circus.html">Circus</a> &nbsp;
<a href="entries/Noninterference_Sequential_Composition.html">Noninterference_Sequential_Composition</a> &nbsp;
<a href="entries/Noninterference_Concurrent_Composition.html">Noninterference_Concurrent_Composition</a> &nbsp;
<a href="entries/Modal_Logics_for_NTS.html">Modal_Logics_for_NTS</a> &nbsp;
<a href="entries/HOL-CSP.html">HOL-CSP</a> &nbsp;
<a href="entries/CSP_RefTK.html">CSP_RefTK</a> &nbsp;
</div>
<h3>Data structures</h3>
<div class="list">
<a href="entries/Generic_Deriving.html">Generic_Deriving</a> &nbsp;
<a href="entries/Random_BSTs.html">Random_BSTs</a> &nbsp;
<a href="entries/Randomised_BSTs.html">Randomised_BSTs</a> &nbsp;
<a href="entries/List_Interleaving.html">List_Interleaving</a> &nbsp;
<a href="entries/Refine_Imperative_HOL.html">Refine_Imperative_HOL</a> &nbsp;
<a href="entries/Amortized_Complexity.html">Amortized_Complexity</a> &nbsp;
<a href="entries/Dynamic_Tables.html">Dynamic_Tables</a> &nbsp;
<a href="entries/AVL-Trees.html">AVL-Trees</a> &nbsp;
<a href="entries/BDD.html">BDD</a> &nbsp;
<a href="entries/BinarySearchTree.html">BinarySearchTree</a> &nbsp;
<a href="entries/Splay_Tree.html">Splay_Tree</a> &nbsp;
<a href="entries/Root_Balanced_Tree.html">Root_Balanced_Tree</a> &nbsp;
<a href="entries/Skew_Heap.html">Skew_Heap</a> &nbsp;
<a href="entries/Pairing_Heap.html">Pairing_Heap</a> &nbsp;
<a href="entries/Priority_Queue_Braun.html">Priority_Queue_Braun</a> &nbsp;
<a href="entries/Binomial-Queues.html">Binomial-Queues</a> &nbsp;
<a href="entries/Binomial-Heaps.html">Binomial-Heaps</a> &nbsp;
<a href="entries/Finger-Trees.html">Finger-Trees</a> &nbsp;
<a href="entries/Trie.html">Trie</a> &nbsp;
<a href="entries/FinFun.html">FinFun</a> &nbsp;
<a href="entries/Collections.html">Collections</a> &nbsp;
<a href="entries/Containers.html">Containers</a> &nbsp;
<a href="entries/FileRefinement.html">FileRefinement</a> &nbsp;
<a href="entries/Datatype_Order_Generator.html">Datatype_Order_Generator</a> &nbsp;
<a href="entries/Deriving.html">Deriving</a> &nbsp;
<a href="entries/List-Index.html">List-Index</a> &nbsp;
<a href="entries/List-Infinite.html">List-Infinite</a> &nbsp;
<a href="entries/Matrix.html">Matrix</a> &nbsp;
<a href="entries/Matrix_Tensor.html">Matrix_Tensor</a> &nbsp;
<a href="entries/Huffman.html">Huffman</a> &nbsp;
<a href="entries/Lazy-Lists-II.html">Lazy-Lists-II</a> &nbsp;
<a href="entries/IEEE_Floating_Point.html">IEEE_Floating_Point</a> &nbsp;
<a href="entries/Native_Word.html">Native_Word</a> &nbsp;
<a href="entries/XML.html">XML</a> &nbsp;
<a href="entries/ROBDD.html">ROBDD</a> &nbsp;
<a href="entries/IMAP-CRDT.html">IMAP-CRDT</a> &nbsp;
<a href="entries/Word_Lib.html">Word_Lib</a> &nbsp;
<a href="entries/CRDT.html">CRDT</a> &nbsp;
<a href="entries/KD_Tree.html">KD_Tree</a> &nbsp;
<a href="entries/Taylor_Models.html">Taylor_Models</a> &nbsp;
<a href="entries/Treaps.html">Treaps</a> &nbsp;
<a href="entries/Skip_Lists.html">Skip_Lists</a> &nbsp;
<a href="entries/Weight_Balanced_Trees.html">Weight_Balanced_Trees</a> &nbsp;
<a href="entries/OpSets.html">OpSets</a> &nbsp;
<a href="entries/Optimal_BST.html">Optimal_BST</a> &nbsp;
<a href="entries/Core_DOM.html">Core_DOM</a> &nbsp;
<a href="entries/Core_SC_DOM.html">Core_SC_DOM</a> &nbsp;
<a href="entries/Shadow_SC_DOM.html">Shadow_SC_DOM</a> &nbsp;
<a href="entries/SC_DOM_Components.html">SC_DOM_Components</a> &nbsp;
<a href="entries/Auto2_Imperative_HOL.html">Auto2_Imperative_HOL</a> &nbsp;
<a href="entries/IMP2_Binary_Heap.html">IMP2_Binary_Heap</a> &nbsp;
<a href="entries/Priority_Search_Trees.html">Priority_Search_Trees</a> &nbsp;
<a href="entries/Interval_Arithmetic_Word32.html">Interval_Arithmetic_Word32</a> &nbsp;
<a href="entries/ADS_Functor.html">ADS_Functor</a> &nbsp;
<a href="entries/Relational_Disjoint_Set_Forests.html">Relational_Disjoint_Set_Forests</a> &nbsp;
<a href="entries/Shadow_DOM.html">Shadow_DOM</a> &nbsp;
<a href="entries/DOM_Components.html">DOM_Components</a> &nbsp;
<a href="entries/Finite-Map-Extras.html">Finite-Map-Extras</a> &nbsp;
<a href="entries/Hood_Melville_Queue.html">Hood_Melville_Queue</a> &nbsp;
+ <a href="entries/BTree.html">BTree</a> &nbsp;
</div>
<h3>Functional programming</h3>
<div class="list">
<a href="entries/Optics.html">Optics</a> &nbsp;
<a href="entries/CryptHOL.html">CryptHOL</a> &nbsp;
<a href="entries/Probabilistic_While.html">Probabilistic_While</a> &nbsp;
<a href="entries/Monad_Normalisation.html">Monad_Normalisation</a> &nbsp;
<a href="entries/Monomorphic_Monad.html">Monomorphic_Monad</a> &nbsp;
<a href="entries/Show.html">Show</a> &nbsp;
<a href="entries/Certification_Monads.html">Certification_Monads</a> &nbsp;
<a href="entries/Partial_Function_MR.html">Partial_Function_MR</a> &nbsp;
<a href="entries/Lifting_Definition_Option.html">Lifting_Definition_Option</a> &nbsp;
<a href="entries/Coinductive.html">Coinductive</a> &nbsp;
<a href="entries/Stream-Fusion.html">Stream-Fusion</a> &nbsp;
<a href="entries/Tycon.html">Tycon</a> &nbsp;
<a href="entries/Monad_Memo_DP.html">Monad_Memo_DP</a> &nbsp;
<a href="entries/XML.html">XML</a> &nbsp;
<a href="entries/Tail_Recursive_Functions.html">Tail_Recursive_Functions</a> &nbsp;
<a href="entries/Stream_Fusion_Code.html">Stream_Fusion_Code</a> &nbsp;
<a href="entries/Applicative_Lifting.html">Applicative_Lifting</a> &nbsp;
<a href="entries/HOLCF-Prelude.html">HOLCF-Prelude</a> &nbsp;
<a href="entries/BNF_CC.html">BNF_CC</a> &nbsp;
<a href="entries/Binding_Syntax_Theory.html">Binding_Syntax_Theory</a> &nbsp;
<a href="entries/Generalized_Counting_Sort.html">Generalized_Counting_Sort</a> &nbsp;
<a href="entries/Hello_World.html">Hello_World</a> &nbsp;
<a href="entries/BirdKMP.html">BirdKMP</a> &nbsp;
</div>
<h3>Hardware</h3>
<div class="list">
<a href="entries/SPARCv8.html">SPARCv8</a> &nbsp;
</div>
<h3>Machine learning</h3>
<div class="list">
<a href="entries/Deep_Learning.html">Deep_Learning</a> &nbsp;
<a href="entries/Inductive_Inference.html">Inductive_Inference</a> &nbsp;
</div>
<h3>Networks</h3>
<div class="list">
<a href="entries/UPF_Firewall.html">UPF_Firewall</a> &nbsp;
<a href="entries/IP_Addresses.html">IP_Addresses</a> &nbsp;
<a href="entries/Simple_Firewall.html">Simple_Firewall</a> &nbsp;
<a href="entries/Iptables_Semantics.html">Iptables_Semantics</a> &nbsp;
<a href="entries/Routing.html">Routing</a> &nbsp;
<a href="entries/LOFT.html">LOFT</a> &nbsp;
</div>
<h3>Programming languages</h3>
<div class="list">
<a href="entries/Clean.html">Clean</a> &nbsp;
<a href="entries/Decl_Sem_Fun_PL.html">Decl_Sem_Fun_PL</a> &nbsp;
<strong>Language definitions:</strong>
<a href="entries/CakeML.html">CakeML</a> &nbsp;
<a href="entries/WebAssembly.html">WebAssembly</a> &nbsp;
<a href="entries/pGCL.html">pGCL</a> &nbsp;
<a href="entries/GPU_Kernel_PL.html">GPU_Kernel_PL</a> &nbsp;
<a href="entries/LightweightJava.html">LightweightJava</a> &nbsp;
<a href="entries/CoreC++.html">CoreC++</a> &nbsp;
<a href="entries/FeatherweightJava.html">FeatherweightJava</a> &nbsp;
<a href="entries/Jinja.html">Jinja</a> &nbsp;
<a href="entries/JinjaThreads.html">JinjaThreads</a> &nbsp;
<a href="entries/Locally-Nameless-Sigma.html">Locally-Nameless-Sigma</a> &nbsp;
<a href="entries/AutoFocus-Stream.html">AutoFocus-Stream</a> &nbsp;
<a href="entries/FocusStreamsCaseStudies.html">FocusStreamsCaseStudies</a> &nbsp;
<a href="entries/Isabelle_Meta_Model.html">Isabelle_Meta_Model</a> &nbsp;
<a href="entries/Simpl.html">Simpl</a> &nbsp;
<a href="entries/Complx.html">Complx</a> &nbsp;
<a href="entries/Safe_OCL.html">Safe_OCL</a> &nbsp;
<a href="entries/Isabelle_C.html">Isabelle_C</a> &nbsp;
<a href="entries/JinjaDCI.html">JinjaDCI</a> &nbsp;
<strong>Lambda calculi:</strong>
<a href="entries/Higher_Order_Terms.html">Higher_Order_Terms</a> &nbsp;
<a href="entries/Launchbury.html">Launchbury</a> &nbsp;
<a href="entries/PCF.html">PCF</a> &nbsp;
<a href="entries/POPLmark-deBruijn.html">POPLmark-deBruijn</a> &nbsp;
<a href="entries/Lam-ml-Normalization.html">Lam-ml-Normalization</a> &nbsp;
<a href="entries/LambdaMu.html">LambdaMu</a> &nbsp;
<a href="entries/Binding_Syntax_Theory.html">Binding_Syntax_Theory</a> &nbsp;
<a href="entries/LambdaAuth.html">LambdaAuth</a> &nbsp;
<strong>Type systems:</strong>
<a href="entries/Name_Carrying_Type_Inference.html">Name_Carrying_Type_Inference</a> &nbsp;
<a href="entries/MiniML.html">MiniML</a> &nbsp;
<a href="entries/Possibilistic_Noninterference.html">Possibilistic_Noninterference</a> &nbsp;
<a href="entries/SIFUM_Type_Systems.html">SIFUM_Type_Systems</a> &nbsp;
<a href="entries/Dependent_SIFUM_Type_Systems.html">Dependent_SIFUM_Type_Systems</a> &nbsp;
<a href="entries/Strong_Security.html">Strong_Security</a> &nbsp;
<a href="entries/WHATandWHERE_Security.html">WHATandWHERE_Security</a> &nbsp;
<a href="entries/VolpanoSmith.html">VolpanoSmith</a> &nbsp;
<a href="entries/Physical_Quantities.html">Physical_Quantities</a> &nbsp;
<strong>Logics:</strong>
<a href="entries/ConcurrentIMP.html">ConcurrentIMP</a> &nbsp;
<a href="entries/Refine_Monadic.html">Refine_Monadic</a> &nbsp;
<a href="entries/Automatic_Refinement.html">Automatic_Refinement</a> &nbsp;
<a href="entries/MonoBoolTranAlgebra.html">MonoBoolTranAlgebra</a> &nbsp;
<a href="entries/Simpl.html">Simpl</a> &nbsp;
<a href="entries/Separation_Algebra.html">Separation_Algebra</a> &nbsp;
<a href="entries/Separation_Logic_Imperative_HOL.html">Separation_Logic_Imperative_HOL</a> &nbsp;
<a href="entries/Relational-Incorrectness-Logic.html">Relational-Incorrectness-Logic</a> &nbsp;
<a href="entries/Abstract-Hoare-Logics.html">Abstract-Hoare-Logics</a> &nbsp;
<a href="entries/Kleene_Algebra.html">Kleene_Algebra</a> &nbsp;
<a href="entries/KAT_and_DRA.html">KAT_and_DRA</a> &nbsp;
<a href="entries/KAD.html">KAD</a> &nbsp;
<a href="entries/BytecodeLogicJmlTypes.html">BytecodeLogicJmlTypes</a> &nbsp;
<a href="entries/DataRefinementIBP.html">DataRefinementIBP</a> &nbsp;
<a href="entries/RefinementReactive.html">RefinementReactive</a> &nbsp;
<a href="entries/SIFPL.html">SIFPL</a> &nbsp;
<a href="entries/TLA.html">TLA</a> &nbsp;
<a href="entries/Ribbon_Proofs.html">Ribbon_Proofs</a> &nbsp;
<a href="entries/Separata.html">Separata</a> &nbsp;
<a href="entries/Complx.html">Complx</a> &nbsp;
<a href="entries/Differential_Dynamic_Logic.html">Differential_Dynamic_Logic</a> &nbsp;
<a href="entries/Hoare_Time.html">Hoare_Time</a> &nbsp;
<a href="entries/IMP2.html">IMP2</a> &nbsp;
<a href="entries/UTP.html">UTP</a> &nbsp;
<a href="entries/QHLProver.html">QHLProver</a> &nbsp;
<a href="entries/Differential_Game_Logic.html">Differential_Game_Logic</a> &nbsp;
<strong>Compiling:</strong>
<a href="entries/CakeML_Codegen.html">CakeML_Codegen</a> &nbsp;
<a href="entries/Compiling-Exceptions-Correctly.html">Compiling-Exceptions-Correctly</a> &nbsp;
<a href="entries/NormByEval.html">NormByEval</a> &nbsp;
<a href="entries/Density_Compiler.html">Density_Compiler</a> &nbsp;
<a href="entries/VeriComp.html">VeriComp</a> &nbsp;
<strong>Static analysis:</strong>
<a href="entries/RIPEMD-160-SPARK.html">RIPEMD-160-SPARK</a> &nbsp;
<a href="entries/Program-Conflict-Analysis.html">Program-Conflict-Analysis</a> &nbsp;
<a href="entries/Shivers-CFA.html">Shivers-CFA</a> &nbsp;
<a href="entries/Slicing.html">Slicing</a> &nbsp;
<a href="entries/HRB-Slicing.html">HRB-Slicing</a> &nbsp;
<a href="entries/InfPathElimination.html">InfPathElimination</a> &nbsp;
<a href="entries/Abs_Int_ITP2012.html">Abs_Int_ITP2012</a> &nbsp;
<strong>Transformations:</strong>
<a href="entries/Call_Arity.html">Call_Arity</a> &nbsp;
<a href="entries/Refine_Imperative_HOL.html">Refine_Imperative_HOL</a> &nbsp;
<a href="entries/WorkerWrapper.html">WorkerWrapper</a> &nbsp;
<a href="entries/Monad_Memo_DP.html">Monad_Memo_DP</a> &nbsp;
<a href="entries/Formal_SSA.html">Formal_SSA</a> &nbsp;
<a href="entries/Minimal_SSA.html">Minimal_SSA</a> &nbsp;
<strong>Misc:</strong>
<a href="entries/JiveDataStoreModel.html">JiveDataStoreModel</a> &nbsp;
<a href="entries/Pop_Refinement.html">Pop_Refinement</a> &nbsp;
<a href="entries/Case_Labeling.html">Case_Labeling</a> &nbsp;
<a href="entries/Interpreter_Optimizations.html">Interpreter_Optimizations</a> &nbsp;
</div>
<h3>Security</h3>
<div class="list">
<a href="entries/Multi_Party_Computation.html">Multi_Party_Computation</a> &nbsp;
<a href="entries/Noninterference_Generic_Unwinding.html">Noninterference_Generic_Unwinding</a> &nbsp;
<a href="entries/Noninterference_Ipurge_Unwinding.html">Noninterference_Ipurge_Unwinding</a> &nbsp;
<a href="entries/Relational_Method.html">Relational_Method</a> &nbsp;
<a href="entries/UPF.html">UPF</a> &nbsp;
<a href="entries/UPF_Firewall.html">UPF_Firewall</a> &nbsp;
<a href="entries/CISC-Kernel.html">CISC-Kernel</a> &nbsp;
<a href="entries/Noninterference_CSP.html">Noninterference_CSP</a> &nbsp;
<a href="entries/Key_Agreement_Strong_Adversaries.html">Key_Agreement_Strong_Adversaries</a> &nbsp;
<a href="entries/Security_Protocol_Refinement.html">Security_Protocol_Refinement</a> &nbsp;
<a href="entries/Attack_Trees.html">Attack_Trees</a> &nbsp;
<a href="entries/Inductive_Confidentiality.html">Inductive_Confidentiality</a> &nbsp;
<a href="entries/Possibilistic_Noninterference.html">Possibilistic_Noninterference</a> &nbsp;
<a href="entries/SIFUM_Type_Systems.html">SIFUM_Type_Systems</a> &nbsp;
<a href="entries/Dependent_SIFUM_Type_Systems.html">Dependent_SIFUM_Type_Systems</a> &nbsp;
<a href="entries/Dependent_SIFUM_Refinement.html">Dependent_SIFUM_Refinement</a> &nbsp;
<a href="entries/Relational-Incorrectness-Logic.html">Relational-Incorrectness-Logic</a> &nbsp;
<a href="entries/Strong_Security.html">Strong_Security</a> &nbsp;
<a href="entries/WHATandWHERE_Security.html">WHATandWHERE_Security</a> &nbsp;
<a href="entries/VolpanoSmith.html">VolpanoSmith</a> &nbsp;
<a href="entries/SIFPL.html">SIFPL</a> &nbsp;
<a href="entries/HotelKeyCards.html">HotelKeyCards</a> &nbsp;
<a href="entries/InformationFlowSlicing.html">InformationFlowSlicing</a> &nbsp;
<a href="entries/InformationFlowSlicing_Inter.html">InformationFlowSlicing_Inter</a> &nbsp;
<a href="entries/CryptoBasedCompositionalProperties.html">CryptoBasedCompositionalProperties</a> &nbsp;
<a href="entries/Probabilistic_Noninterference.html">Probabilistic_Noninterference</a> &nbsp;
<a href="entries/HyperCTL.html">HyperCTL</a> &nbsp;
<a href="entries/Bounded_Deducibility_Security.html">Bounded_Deducibility_Security</a> &nbsp;
<a href="entries/Network_Security_Policy_Verification.html">Network_Security_Policy_Verification</a> &nbsp;
<a href="entries/Noninterference_Inductive_Unwinding.html">Noninterference_Inductive_Unwinding</a> &nbsp;
<a href="entries/Password_Authentication_Protocol.html">Password_Authentication_Protocol</a> &nbsp;
<a href="entries/Noninterference_Sequential_Composition.html">Noninterference_Sequential_Composition</a> &nbsp;
<a href="entries/Noninterference_Concurrent_Composition.html">Noninterference_Concurrent_Composition</a> &nbsp;
<a href="entries/SPARCv8.html">SPARCv8</a> &nbsp;
<a href="entries/Modular_Assembly_Kit_Security.html">Modular_Assembly_Kit_Security</a> &nbsp;
<a href="entries/LambdaAuth.html">LambdaAuth</a> &nbsp;
<a href="entries/Stateful_Protocol_Composition_and_Typing.html">Stateful_Protocol_Composition_and_Typing</a> &nbsp;
<a href="entries/Automated_Stateful_Protocol_Verification.html">Automated_Stateful_Protocol_Verification</a> &nbsp;
<strong>Cryptography:</strong>
<a href="entries/Game_Based_Crypto.html">Game_Based_Crypto</a> &nbsp;
<a href="entries/Sigma_Commit_Crypto.html">Sigma_Commit_Crypto</a> &nbsp;
<a href="entries/CryptHOL.html">CryptHOL</a> &nbsp;
<a href="entries/Constructive_Cryptography.html">Constructive_Cryptography</a> &nbsp;
<a href="entries/RSAPSS.html">RSAPSS</a> &nbsp;
<a href="entries/Elliptic_Curves_Group_Law.html">Elliptic_Curves_Group_Law</a> &nbsp;
</div>
<h3>Semantics</h3>
<div class="list">
<a href="entries/Launchbury.html">Launchbury</a> &nbsp;
<a href="entries/Clean.html">Clean</a> &nbsp;
<a href="entries/Transformer_Semantics.html">Transformer_Semantics</a> &nbsp;
<a href="entries/HOL-CSP.html">HOL-CSP</a> &nbsp;
<a href="entries/QHLProver.html">QHLProver</a> &nbsp;
<a href="entries/TESL_Language.html">TESL_Language</a> &nbsp;
<a href="entries/Isabelle_C.html">Isabelle_C</a> &nbsp;
<a href="entries/CSP_RefTK.html">CSP_RefTK</a> &nbsp;
</div>
<h3>System description languages</h3>
<div class="list">
<a href="entries/Circus.html">Circus</a> &nbsp;
<a href="entries/ComponentDependencies.html">ComponentDependencies</a> &nbsp;
<a href="entries/Promela.html">Promela</a> &nbsp;
<a href="entries/Featherweight_OCL.html">Featherweight_OCL</a> &nbsp;
<a href="entries/DynamicArchitectures.html">DynamicArchitectures</a> &nbsp;
<a href="entries/Architectural_Design_Patterns.html">Architectural_Design_Patterns</a> &nbsp;
<a href="entries/TESL_Language.html">TESL_Language</a> &nbsp;
</div>
<h2>Logic</h2>
<div class="list">
</div>
<h3>Philosophical aspects</h3>
<div class="list">
<a href="entries/GoedelGod.html">GoedelGod</a> &nbsp;
<a href="entries/Types_Tableaus_and_Goedels_God.html">Types_Tableaus_and_Goedels_God</a> &nbsp;
<a href="entries/GewirthPGCProof.html">GewirthPGCProof</a> &nbsp;
<a href="entries/Lowe_Ontological_Argument.html">Lowe_Ontological_Argument</a> &nbsp;
<a href="entries/AnselmGod.html">AnselmGod</a> &nbsp;
<a href="entries/PLM.html">PLM</a> &nbsp;
<a href="entries/Aristotles_Assertoric_Syllogistic.html">Aristotles_Assertoric_Syllogistic</a> &nbsp;
</div>
<h3>General logic</h3>
<div class="list">
<a href="entries/Topological_Semantics.html">Topological_Semantics</a> &nbsp;
<strong>Classical propositional logic:</strong>
<a href="entries/Free-Boolean-Algebra.html">Free-Boolean-Algebra</a> &nbsp;
<strong>Classical first-order logic:</strong>
<a href="entries/FOL-Fitting.html">FOL-Fitting</a> &nbsp;
<strong>Decidability of theories:</strong>
<a href="entries/MSO_Regex_Equivalence.html">MSO_Regex_Equivalence</a> &nbsp;
<a href="entries/Formula_Derivatives.html">Formula_Derivatives</a> &nbsp;
<a href="entries/Presburger-Automata.html">Presburger-Automata</a> &nbsp;
<a href="entries/LinearQuantifierElim.html">LinearQuantifierElim</a> &nbsp;
<strong>Mechanization of proofs:</strong>
<a href="entries/Boolean_Expression_Checkers.html">Boolean_Expression_Checkers</a> &nbsp;
<a href="entries/Verified-Prover.html">Verified-Prover</a> &nbsp;
<a href="entries/Sort_Encodings.html">Sort_Encodings</a> &nbsp;
<a href="entries/PropResPI.html">PropResPI</a> &nbsp;
<a href="entries/Resolution_FOL.html">Resolution_FOL</a> &nbsp;
<a href="entries/FOL_Harrison.html">FOL_Harrison</a> &nbsp;
<a href="entries/Ordered_Resolution_Prover.html">Ordered_Resolution_Prover</a> &nbsp;
<a href="entries/Functional_Ordered_Resolution_Prover.html">Functional_Ordered_Resolution_Prover</a> &nbsp;
<a href="entries/Binding_Syntax_Theory.html">Binding_Syntax_Theory</a> &nbsp;
<a href="entries/Saturation_Framework.html">Saturation_Framework</a> &nbsp;
<a href="entries/Saturation_Framework_Extensions.html">Saturation_Framework_Extensions</a> &nbsp;
<strong>Lambda calculus:</strong>
<a href="entries/LambdaMu.html">LambdaMu</a> &nbsp;
<strong>Logics of knowledge and belief:</strong>
<a href="entries/Epistemic_Logic.html">Epistemic_Logic</a> &nbsp;
<a href="entries/Blue_Eyes.html">Blue_Eyes</a> &nbsp;
<strong>Temporal logic:</strong>
<a href="entries/Nat-Interval-Logic.html">Nat-Interval-Logic</a> &nbsp;
<a href="entries/LTL.html">LTL</a> &nbsp;
<a href="entries/HyperCTL.html">HyperCTL</a> &nbsp;
<a href="entries/Allen_Calculus.html">Allen_Calculus</a> &nbsp;
<a href="entries/MFOTL_Monitor.html">MFOTL_Monitor</a> &nbsp;
<a href="entries/LTL_Normal_Form.html">LTL_Normal_Form</a> &nbsp;
<strong>Modal logic:</strong>
<a href="entries/Modal_Logics_for_NTS.html">Modal_Logics_for_NTS</a> &nbsp;
<a href="entries/Differential_Dynamic_Logic.html">Differential_Dynamic_Logic</a> &nbsp;
<a href="entries/Hybrid_Multi_Lane_Spatial_Logic.html">Hybrid_Multi_Lane_Spatial_Logic</a> &nbsp;
<a href="entries/Hybrid_Logic.html">Hybrid_Logic</a> &nbsp;
<a href="entries/MFODL_Monitor_Optimized.html">MFODL_Monitor_Optimized</a> &nbsp;
<strong>Paraconsistent logics:</strong>
<a href="entries/Paraconsistency.html">Paraconsistency</a> &nbsp;
</div>
<h3>Computability</h3>
<div class="list">
<a href="entries/Universal_Turing_Machine.html">Universal_Turing_Machine</a> &nbsp;
<a href="entries/Recursion-Theory-I.html">Recursion-Theory-I</a> &nbsp;
<a href="entries/Inductive_Inference.html">Inductive_Inference</a> &nbsp;
<a href="entries/Minsky_Machines.html">Minsky_Machines</a> &nbsp;
</div>
<h3>Set theory</h3>
<div class="list">
<a href="entries/Ordinal.html">Ordinal</a> &nbsp;
<a href="entries/Ordinals_and_Cardinals.html">Ordinals_and_Cardinals</a> &nbsp;
<a href="entries/HereditarilyFinite.html">HereditarilyFinite</a> &nbsp;
<a href="entries/ZFC_in_HOL.html">ZFC_in_HOL</a> &nbsp;
<a href="entries/Forcing.html">Forcing</a> &nbsp;
<a href="entries/Delta_System_Lemma.html">Delta_System_Lemma</a> &nbsp;
<a href="entries/Recursion-Addition.html">Recursion-Addition</a> &nbsp;
<a href="entries/Ordinal_Partitions.html">Ordinal_Partitions</a> &nbsp;
</div>
<h3>Proof theory</h3>
<div class="list">
<a href="entries/Propositional_Proof_Systems.html">Propositional_Proof_Systems</a> &nbsp;
<a href="entries/Completeness.html">Completeness</a> &nbsp;
<a href="entries/SequentInvertibility.html">SequentInvertibility</a> &nbsp;
<a href="entries/Incompleteness.html">Incompleteness</a> &nbsp;
<a href="entries/Abstract_Completeness.html">Abstract_Completeness</a> &nbsp;
<a href="entries/SuperCalc.html">SuperCalc</a> &nbsp;
<a href="entries/Incredible_Proof_Machine.html">Incredible_Proof_Machine</a> &nbsp;
<a href="entries/Surprise_Paradox.html">Surprise_Paradox</a> &nbsp;
<a href="entries/Abstract_Soundness.html">Abstract_Soundness</a> &nbsp;
<a href="entries/Syntax_Independent_Logic.html">Syntax_Independent_Logic</a> &nbsp;
<a href="entries/Goedel_Incompleteness.html">Goedel_Incompleteness</a> &nbsp;
<a href="entries/Goedel_HFSet_Semantic.html">Goedel_HFSet_Semantic</a> &nbsp;
<a href="entries/Goedel_HFSet_Semanticless.html">Goedel_HFSet_Semanticless</a> &nbsp;
<a href="entries/Robinson_Arithmetic.html">Robinson_Arithmetic</a> &nbsp;
<a href="entries/FOL_Seq_Calc1.html">FOL_Seq_Calc1</a> &nbsp;
</div>
<h3>Rewriting</h3>
<div class="list">
<a href="entries/CakeML_Codegen.html">CakeML_Codegen</a> &nbsp;
<a href="entries/Monad_Normalisation.html">Monad_Normalisation</a> &nbsp;
<a href="entries/Lambda_Free_RPOs.html">Lambda_Free_RPOs</a> &nbsp;
<a href="entries/Lambda_Free_KBOs.html">Lambda_Free_KBOs</a> &nbsp;
<a href="entries/Lambda_Free_EPO.html">Lambda_Free_EPO</a> &nbsp;
<a href="entries/Nested_Multisets_Ordinals.html">Nested_Multisets_Ordinals</a> &nbsp;
<a href="entries/Abstract-Rewriting.html">Abstract-Rewriting</a> &nbsp;
<a href="entries/First_Order_Terms.html">First_Order_Terms</a> &nbsp;
<a href="entries/Decreasing-Diagrams.html">Decreasing-Diagrams</a> &nbsp;
<a href="entries/Decreasing-Diagrams-II.html">Decreasing-Diagrams-II</a> &nbsp;
<a href="entries/Rewriting_Z.html">Rewriting_Z</a> &nbsp;
<a href="entries/Graph_Saturation.html">Graph_Saturation</a> &nbsp;
<a href="entries/Goodstein_Lambda.html">Goodstein_Lambda</a> &nbsp;
<a href="entries/Knuth_Bendix_Order.html">Knuth_Bendix_Order</a> &nbsp;
</div>
<h2>Mathematics</h2>
<div class="list">
</div>
<h3>Order</h3>
<div class="list">
<a href="entries/LatticeProperties.html">LatticeProperties</a> &nbsp;
<a href="entries/Stone_Algebras.html">Stone_Algebras</a> &nbsp;
<a href="entries/Allen_Calculus.html">Allen_Calculus</a> &nbsp;
<a href="entries/Order_Lattice_Props.html">Order_Lattice_Props</a> &nbsp;
<a href="entries/Complete_Non_Orders.html">Complete_Non_Orders</a> &nbsp;
<a href="entries/Szpilrajn.html">Szpilrajn</a> &nbsp;
</div>
<h3>Algebra</h3>
<div class="list">
<a href="entries/Optics.html">Optics</a> &nbsp;
<a href="entries/Subresultants.html">Subresultants</a> &nbsp;
<a href="entries/Buildings.html">Buildings</a> &nbsp;
<a href="entries/Algebraic_VCs.html">Algebraic_VCs</a> &nbsp;
<a href="entries/C2KA_DistributedSystems.html">C2KA_DistributedSystems</a> &nbsp;
<a href="entries/Multirelations.html">Multirelations</a> &nbsp;
<a href="entries/Residuated_Lattices.html">Residuated_Lattices</a> &nbsp;
<a href="entries/PseudoHoops.html">PseudoHoops</a> &nbsp;
<a href="entries/Impossible_Geometry.html">Impossible_Geometry</a> &nbsp;
<a href="entries/Gauss-Jordan-Elim-Fun.html">Gauss-Jordan-Elim-Fun</a> &nbsp;
<a href="entries/Matrix_Tensor.html">Matrix_Tensor</a> &nbsp;
<a href="entries/Kleene_Algebra.html">Kleene_Algebra</a> &nbsp;
<a href="entries/KAT_and_DRA.html">KAT_and_DRA</a> &nbsp;
<a href="entries/KAD.html">KAD</a> &nbsp;
<a href="entries/Regular_Algebras.html">Regular_Algebras</a> &nbsp;
<a href="entries/Free-Groups.html">Free-Groups</a> &nbsp;
<a href="entries/CofGroups.html">CofGroups</a> &nbsp;
<a href="entries/Group-Ring-Module.html">Group-Ring-Module</a> &nbsp;
<a href="entries/Robbins-Conjecture.html">Robbins-Conjecture</a> &nbsp;
<a href="entries/Valuation.html">Valuation</a> &nbsp;
<a href="entries/Rank_Nullity_Theorem.html">Rank_Nullity_Theorem</a> &nbsp;
<a href="entries/Polynomials.html">Polynomials</a> &nbsp;
<a href="entries/Relation_Algebra.html">Relation_Algebra</a> &nbsp;
<a href="entries/PSemigroupsConvolution.html">PSemigroupsConvolution</a> &nbsp;
<a href="entries/Secondary_Sylow.html">Secondary_Sylow</a> &nbsp;
<a href="entries/Jordan_Hoelder.html">Jordan_Hoelder</a> &nbsp;
<a href="entries/Cayley_Hamilton.html">Cayley_Hamilton</a> &nbsp;
<a href="entries/VectorSpace.html">VectorSpace</a> &nbsp;
<a href="entries/Echelon_Form.html">Echelon_Form</a> &nbsp;
<a href="entries/QR_Decomposition.html">QR_Decomposition</a> &nbsp;
<a href="entries/Hermite.html">Hermite</a> &nbsp;
<a href="entries/Rep_Fin_Groups.html">Rep_Fin_Groups</a> &nbsp;
<a href="entries/Jordan_Normal_Form.html">Jordan_Normal_Form</a> &nbsp;
<a href="entries/Algebraic_Numbers.html">Algebraic_Numbers</a> &nbsp;
<a href="entries/Polynomial_Interpolation.html">Polynomial_Interpolation</a> &nbsp;
<a href="entries/Polynomial_Factorization.html">Polynomial_Factorization</a> &nbsp;
<a href="entries/Perron_Frobenius.html">Perron_Frobenius</a> &nbsp;
<a href="entries/Stochastic_Matrices.html">Stochastic_Matrices</a> &nbsp;
<a href="entries/Groebner_Bases.html">Groebner_Bases</a> &nbsp;
<a href="entries/Nullstellensatz.html">Nullstellensatz</a> &nbsp;
<a href="entries/Mason_Stothers.html">Mason_Stothers</a> &nbsp;
<a href="entries/Berlekamp_Zassenhaus.html">Berlekamp_Zassenhaus</a> &nbsp;
<a href="entries/Stone_Relation_Algebras.html">Stone_Relation_Algebras</a> &nbsp;
<a href="entries/Stone_Kleene_Relation_Algebras.html">Stone_Kleene_Relation_Algebras</a> &nbsp;
<a href="entries/Orbit_Stabiliser.html">Orbit_Stabiliser</a> &nbsp;
<a href="entries/Dirichlet_L.html">Dirichlet_L</a> &nbsp;
<a href="entries/Symmetric_Polynomials.html">Symmetric_Polynomials</a> &nbsp;
<a href="entries/Taylor_Models.html">Taylor_Models</a> &nbsp;
<a href="entries/LLL_Basis_Reduction.html">LLL_Basis_Reduction</a> &nbsp;
<a href="entries/LLL_Factorization.html">LLL_Factorization</a> &nbsp;
<a href="entries/Localization_Ring.html">Localization_Ring</a> &nbsp;
<a href="entries/Quaternions.html">Quaternions</a> &nbsp;
<a href="entries/Octonions.html">Octonions</a> &nbsp;
<a href="entries/Aggregation_Algebras.html">Aggregation_Algebras</a> &nbsp;
<a href="entries/Signature_Groebner.html">Signature_Groebner</a> &nbsp;
<a href="entries/Quantales.html">Quantales</a> &nbsp;
<a href="entries/Transformer_Semantics.html">Transformer_Semantics</a> &nbsp;
<a href="entries/Farkas.html">Farkas</a> &nbsp;
<a href="entries/Groebner_Macaulay.html">Groebner_Macaulay</a> &nbsp;
<a href="entries/Linear_Inequalities.html">Linear_Inequalities</a> &nbsp;
<a href="entries/Linear_Programming.html">Linear_Programming</a> &nbsp;
<a href="entries/Jacobson_Basic_Algebra.html">Jacobson_Basic_Algebra</a> &nbsp;
<a href="entries/Hybrid_Systems_VCs.html">Hybrid_Systems_VCs</a> &nbsp;
<a href="entries/Subset_Boolean_Algebras.html">Subset_Boolean_Algebras</a> &nbsp;
<a href="entries/Power_Sum_Polynomials.html">Power_Sum_Polynomials</a> &nbsp;
+ <a href="entries/Formal_Puiseux_Series.html">Formal_Puiseux_Series</a> &nbsp;
<a href="entries/Matrices_for_ODEs.html">Matrices_for_ODEs</a> &nbsp;
<a href="entries/Smith_Normal_Form.html">Smith_Normal_Form</a> &nbsp;
</div>
<h3>Analysis</h3>
<div class="list">
<a href="entries/Banach_Steinhaus.html">Banach_Steinhaus</a> &nbsp;
<a href="entries/Fourier.html">Fourier</a> &nbsp;
<a href="entries/E_Transcendental.html">E_Transcendental</a> &nbsp;
<a href="entries/Liouville_Numbers.html">Liouville_Numbers</a> &nbsp;
<a href="entries/Descartes_Sign_Rule.html">Descartes_Sign_Rule</a> &nbsp;
<a href="entries/Euler_MacLaurin.html">Euler_MacLaurin</a> &nbsp;
<a href="entries/Real_Impl.html">Real_Impl</a> &nbsp;
<a href="entries/Lower_Semicontinuous.html">Lower_Semicontinuous</a> &nbsp;
<a href="entries/Affine_Arithmetic.html">Affine_Arithmetic</a> &nbsp;
<a href="entries/Laplace_Transform.html">Laplace_Transform</a> &nbsp;
<a href="entries/Cauchy.html">Cauchy</a> &nbsp;
<a href="entries/Integration.html">Integration</a> &nbsp;
<a href="entries/Ordinary_Differential_Equations.html">Ordinary_Differential_Equations</a> &nbsp;
<a href="entries/Polynomials.html">Polynomials</a> &nbsp;
<a href="entries/Sqrt_Babylonian.html">Sqrt_Babylonian</a> &nbsp;
<a href="entries/Sturm_Sequences.html">Sturm_Sequences</a> &nbsp;
<a href="entries/Sturm_Tarski.html">Sturm_Tarski</a> &nbsp;
<a href="entries/Special_Function_Bounds.html">Special_Function_Bounds</a> &nbsp;
<a href="entries/Landau_Symbols.html">Landau_Symbols</a> &nbsp;
<a href="entries/Error_Function.html">Error_Function</a> &nbsp;
<a href="entries/Akra_Bazzi.html">Akra_Bazzi</a> &nbsp;
<a href="entries/Zeta_Function.html">Zeta_Function</a> &nbsp;
<a href="entries/Linear_Recurrences.html">Linear_Recurrences</a> &nbsp;
<a href="entries/Lambert_W.html">Lambert_W</a> &nbsp;
<a href="entries/Cartan_FP.html">Cartan_FP</a> &nbsp;
<a href="entries/Deep_Learning.html">Deep_Learning</a> &nbsp;
<a href="entries/Stirling_Formula.html">Stirling_Formula</a> &nbsp;
<a href="entries/Lp.html">Lp</a> &nbsp;
<a href="entries/Bernoulli.html">Bernoulli</a> &nbsp;
<a href="entries/Winding_Number_Eval.html">Winding_Number_Eval</a> &nbsp;
<a href="entries/Count_Complex_Roots.html">Count_Complex_Roots</a> &nbsp;
<a href="entries/Taylor_Models.html">Taylor_Models</a> &nbsp;
<a href="entries/Green.html">Green</a> &nbsp;
<a href="entries/Irrationality_J_Hancl.html">Irrationality_J_Hancl</a> &nbsp;
<a href="entries/Budan_Fourier.html">Budan_Fourier</a> &nbsp;
<a href="entries/Smooth_Manifolds.html">Smooth_Manifolds</a> &nbsp;
<a href="entries/Transcendence_Series_Hancl_Rucki.html">Transcendence_Series_Hancl_Rucki</a> &nbsp;
<a href="entries/Hybrid_Systems_VCs.html">Hybrid_Systems_VCs</a> &nbsp;
<a href="entries/Poincare_Bendixson.html">Poincare_Bendixson</a> &nbsp;
<a href="entries/Matrices_for_ODEs.html">Matrices_for_ODEs</a> &nbsp;
<a href="entries/Irrational_Series_Erdos_Straus.html">Irrational_Series_Erdos_Straus</a> &nbsp;
</div>
<h3>Probability theory</h3>
<div class="list">
<a href="entries/DiscretePricing.html">DiscretePricing</a> &nbsp;
<a href="entries/CryptHOL.html">CryptHOL</a> &nbsp;
<a href="entries/Constructive_Cryptography.html">Constructive_Cryptography</a> &nbsp;
<a href="entries/Probabilistic_While.html">Probabilistic_While</a> &nbsp;
<a href="entries/Markov_Models.html">Markov_Models</a> &nbsp;
<a href="entries/Density_Compiler.html">Density_Compiler</a> &nbsp;
<a href="entries/Probabilistic_Timed_Automata.html">Probabilistic_Timed_Automata</a> &nbsp;
<a href="entries/Hidden_Markov_Models.html">Hidden_Markov_Models</a> &nbsp;
<a href="entries/Random_Graph_Subgraph_Threshold.html">Random_Graph_Subgraph_Threshold</a> &nbsp;
<a href="entries/Ergodic_Theory.html">Ergodic_Theory</a> &nbsp;
<a href="entries/Source_Coding_Theorem.html">Source_Coding_Theorem</a> &nbsp;
<a href="entries/Buffons_Needle.html">Buffons_Needle</a> &nbsp;
<a href="entries/Laws_of_Large_Numbers.html">Laws_of_Large_Numbers</a> &nbsp;
</div>
<h3>Number theory</h3>
<div class="list">
<a href="entries/Arith_Prog_Rel_Primes.html">Arith_Prog_Rel_Primes</a> &nbsp;
<a href="entries/Pell.html">Pell</a> &nbsp;
<a href="entries/Minkowskis_Theorem.html">Minkowskis_Theorem</a> &nbsp;
<a href="entries/E_Transcendental.html">E_Transcendental</a> &nbsp;
<a href="entries/Pi_Transcendental.html">Pi_Transcendental</a> &nbsp;
<a href="entries/Liouville_Numbers.html">Liouville_Numbers</a> &nbsp;
<a href="entries/Prime_Harmonic_Series.html">Prime_Harmonic_Series</a> &nbsp;
<a href="entries/Fermat3_4.html">Fermat3_4</a> &nbsp;
<a href="entries/Perfect-Number-Thm.html">Perfect-Number-Thm</a> &nbsp;
<a href="entries/SumSquares.html">SumSquares</a> &nbsp;
<a href="entries/Lehmer.html">Lehmer</a> &nbsp;
<a href="entries/Pratt_Certificate.html">Pratt_Certificate</a> &nbsp;
<a href="entries/Dirichlet_Series.html">Dirichlet_Series</a> &nbsp;
<a href="entries/Gauss_Sums.html">Gauss_Sums</a> &nbsp;
<a href="entries/Zeta_Function.html">Zeta_Function</a> &nbsp;
<a href="entries/Stern_Brocot.html">Stern_Brocot</a> &nbsp;
<a href="entries/Bertrands_Postulate.html">Bertrands_Postulate</a> &nbsp;
<a href="entries/Bernoulli.html">Bernoulli</a> &nbsp;
<a href="entries/Diophantine_Eqns_Lin_Hom.html">Diophantine_Eqns_Lin_Hom</a> &nbsp;
<a href="entries/Dirichlet_L.html">Dirichlet_L</a> &nbsp;
<a href="entries/Mersenne_Primes.html">Mersenne_Primes</a> &nbsp;
<a href="entries/Irrationality_J_Hancl.html">Irrationality_J_Hancl</a> &nbsp;
<a href="entries/Prime_Number_Theorem.html">Prime_Number_Theorem</a> &nbsp;
<a href="entries/Probabilistic_Prime_Tests.html">Probabilistic_Prime_Tests</a> &nbsp;
<a href="entries/Prime_Distribution_Elementary.html">Prime_Distribution_Elementary</a> &nbsp;
<a href="entries/Transcendence_Series_Hancl_Rucki.html">Transcendence_Series_Hancl_Rucki</a> &nbsp;
<a href="entries/Zeta_3_Irrational.html">Zeta_3_Irrational</a> &nbsp;
<a href="entries/Furstenberg_Topology.html">Furstenberg_Topology</a> &nbsp;
<a href="entries/Lucas_Theorem.html">Lucas_Theorem</a> &nbsp;
<a href="entries/Gaussian_Integers.html">Gaussian_Integers</a> &nbsp;
<a href="entries/Irrational_Series_Erdos_Straus.html">Irrational_Series_Erdos_Straus</a> &nbsp;
<a href="entries/Amicable_Numbers.html">Amicable_Numbers</a> &nbsp;
</div>
<h3>Games and economics</h3>
<div class="list">
<a href="entries/DiscretePricing.html">DiscretePricing</a> &nbsp;
<a href="entries/ArrowImpossibilityGS.html">ArrowImpossibilityGS</a> &nbsp;
<a href="entries/SenSocialChoice.html">SenSocialChoice</a> &nbsp;
<a href="entries/Vickrey_Clarke_Groves.html">Vickrey_Clarke_Groves</a> &nbsp;
<a href="entries/Parity_Game.html">Parity_Game</a> &nbsp;
<a href="entries/First_Welfare_Theorem.html">First_Welfare_Theorem</a> &nbsp;
<a href="entries/Randomised_Social_Choice.html">Randomised_Social_Choice</a> &nbsp;
<a href="entries/SDS_Impossibility.html">SDS_Impossibility</a> &nbsp;
<a href="entries/Stable_Matching.html">Stable_Matching</a> &nbsp;
<a href="entries/Fishburn_Impossibility.html">Fishburn_Impossibility</a> &nbsp;
<a href="entries/Neumann_Morgenstern_Utility.html">Neumann_Morgenstern_Utility</a> &nbsp;
</div>
<h3>Geometry</h3>
<div class="list">
<a href="entries/Complex_Geometry.html">Complex_Geometry</a> &nbsp;
<a href="entries/Poincare_Disc.html">Poincare_Disc</a> &nbsp;
<a href="entries/Minkowskis_Theorem.html">Minkowskis_Theorem</a> &nbsp;
<a href="entries/Buildings.html">Buildings</a> &nbsp;
<a href="entries/Chord_Segments.html">Chord_Segments</a> &nbsp;
<a href="entries/Triangle.html">Triangle</a> &nbsp;
<a href="entries/Impossible_Geometry.html">Impossible_Geometry</a> &nbsp;
<a href="entries/Tarskis_Geometry.html">Tarskis_Geometry</a> &nbsp;
<a href="entries/IsaGeoCoq.html">IsaGeoCoq</a> &nbsp;
<a href="entries/General-Triangle.html">General-Triangle</a> &nbsp;
<a href="entries/Nullstellensatz.html">Nullstellensatz</a> &nbsp;
<a href="entries/Ptolemys_Theorem.html">Ptolemys_Theorem</a> &nbsp;
<a href="entries/Buffons_Needle.html">Buffons_Needle</a> &nbsp;
<a href="entries/Stewart_Apollonius.html">Stewart_Apollonius</a> &nbsp;
<a href="entries/Gromov_Hyperbolicity.html">Gromov_Hyperbolicity</a> &nbsp;
<a href="entries/Projective_Geometry.html">Projective_Geometry</a> &nbsp;
<a href="entries/Quaternions.html">Quaternions</a> &nbsp;
<a href="entries/Octonions.html">Octonions</a> &nbsp;
</div>
<h3>Topology</h3>
<div class="list">
<a href="entries/Topology.html">Topology</a> &nbsp;
<a href="entries/Knot_Theory.html">Knot_Theory</a> &nbsp;
<a href="entries/Kuratowski_Closure_Complement.html">Kuratowski_Closure_Complement</a> &nbsp;
<a href="entries/Smooth_Manifolds.html">Smooth_Manifolds</a> &nbsp;
</div>
<h3>Graph theory</h3>
<div class="list">
<a href="entries/Flow_Networks.html">Flow_Networks</a> &nbsp;
<a href="entries/Prpu_Maxflow.html">Prpu_Maxflow</a> &nbsp;
<a href="entries/MFMC_Countable.html">MFMC_Countable</a> &nbsp;
<a href="entries/ShortestPath.html">ShortestPath</a> &nbsp;
<a href="entries/Gabow_SCC.html">Gabow_SCC</a> &nbsp;
<a href="entries/Graph_Theory.html">Graph_Theory</a> &nbsp;
<a href="entries/Planarity_Certificates.html">Planarity_Certificates</a> &nbsp;
<a href="entries/Max-Card-Matching.html">Max-Card-Matching</a> &nbsp;
<a href="entries/Girth_Chromatic.html">Girth_Chromatic</a> &nbsp;
<a href="entries/Random_Graph_Subgraph_Threshold.html">Random_Graph_Subgraph_Threshold</a> &nbsp;
<a href="entries/Flyspeck-Tame.html">Flyspeck-Tame</a> &nbsp;
<a href="entries/Koenigsberg_Friendship.html">Koenigsberg_Friendship</a> &nbsp;
<a href="entries/Tree_Decomposition.html">Tree_Decomposition</a> &nbsp;
<a href="entries/Menger.html">Menger</a> &nbsp;
<a href="entries/Parity_Game.html">Parity_Game</a> &nbsp;
<a href="entries/Factored_Transition_System_Bounding.html">Factored_Transition_System_Bounding</a> &nbsp;
<a href="entries/Graph_Saturation.html">Graph_Saturation</a> &nbsp;
<a href="entries/Relational_Paths.html">Relational_Paths</a> &nbsp;
</div>
<h3>Combinatorics</h3>
<div class="list">
<a href="entries/Card_Equiv_Relations.html">Card_Equiv_Relations</a> &nbsp;
<a href="entries/Twelvefold_Way.html">Twelvefold_Way</a> &nbsp;
<a href="entries/Card_Multisets.html">Card_Multisets</a> &nbsp;
<a href="entries/Card_Partitions.html">Card_Partitions</a> &nbsp;
<a href="entries/Card_Number_Partitions.html">Card_Number_Partitions</a> &nbsp;
<a href="entries/Well_Quasi_Orders.html">Well_Quasi_Orders</a> &nbsp;
<a href="entries/Marriage.html">Marriage</a> &nbsp;
<a href="entries/Bondy.html">Bondy</a> &nbsp;
<a href="entries/Ramsey-Infinite.html">Ramsey-Infinite</a> &nbsp;
<a href="entries/Derangements.html">Derangements</a> &nbsp;
<a href="entries/Euler_Partition.html">Euler_Partition</a> &nbsp;
<a href="entries/Discrete_Summation.html">Discrete_Summation</a> &nbsp;
<a href="entries/Open_Induction.html">Open_Induction</a> &nbsp;
<a href="entries/Latin_Square.html">Latin_Square</a> &nbsp;
<a href="entries/Bell_Numbers_Spivey.html">Bell_Numbers_Spivey</a> &nbsp;
<a href="entries/Catalan_Numbers.html">Catalan_Numbers</a> &nbsp;
<a href="entries/Falling_Factorial_Sum.html">Falling_Factorial_Sum</a> &nbsp;
<a href="entries/Matroids.html">Matroids</a> &nbsp;
<a href="entries/Delta_System_Lemma.html">Delta_System_Lemma</a> &nbsp;
<a href="entries/Nash_Williams.html">Nash_Williams</a> &nbsp;
<a href="entries/Ordinal_Partitions.html">Ordinal_Partitions</a> &nbsp;
</div>
<h3>Category theory</h3>
<div class="list">
<a href="entries/Category3.html">Category3</a> &nbsp;
<a href="entries/MonoidalCategory.html">MonoidalCategory</a> &nbsp;
<a href="entries/Category.html">Category</a> &nbsp;
<a href="entries/Category2.html">Category2</a> &nbsp;
<a href="entries/AxiomaticCategoryTheory.html">AxiomaticCategoryTheory</a> &nbsp;
<a href="entries/Bicategory.html">Bicategory</a> &nbsp;
</div>
<h3>Physics</h3>
<div class="list">
<a href="entries/No_FTL_observers.html">No_FTL_observers</a> &nbsp;
<a href="entries/Safe_Distance.html">Safe_Distance</a> &nbsp;
<a href="entries/Physical_Quantities.html">Physical_Quantities</a> &nbsp;
<strong>Quantum information:</strong>
<a href="entries/Isabelle_Marries_Dirac.html">Isabelle_Marries_Dirac</a> &nbsp;
</div>
<h3>Misc</h3>
<div class="list">
<a href="entries/FunWithFunctions.html">FunWithFunctions</a> &nbsp;
<a href="entries/FunWithTilings.html">FunWithTilings</a> &nbsp;
<a href="entries/IMO2019.html">IMO2019</a> &nbsp;
</div>
<h2>Tools</h2>
<div class="list">
<a href="entries/Monad_Normalisation.html">Monad_Normalisation</a> &nbsp;
<a href="entries/Constructor_Funs.html">Constructor_Funs</a> &nbsp;
<a href="entries/Lazy_Case.html">Lazy_Case</a> &nbsp;
<a href="entries/Dict_Construction.html">Dict_Construction</a> &nbsp;
<a href="entries/Case_Labeling.html">Case_Labeling</a> &nbsp;
<a href="entries/DPT-SAT-Solver.html">DPT-SAT-Solver</a> &nbsp;
<a href="entries/Nominal2.html">Nominal2</a> &nbsp;
<a href="entries/Separata.html">Separata</a> &nbsp;
<a href="entries/Proof_Strategy_Language.html">Proof_Strategy_Language</a> &nbsp;
<a href="entries/Diophantine_Eqns_Lin_Hom.html">Diophantine_Eqns_Lin_Hom</a> &nbsp;
<a href="entries/BNF_Operations.html">BNF_Operations</a> &nbsp;
<a href="entries/BNF_CC.html">BNF_CC</a> &nbsp;
<a href="entries/Auto2_HOL.html">Auto2_HOL</a> &nbsp;
<a href="entries/Isabelle_C.html">Isabelle_C</a> &nbsp;
<a href="entries/Automated_Stateful_Protocol_Verification.html">Automated_Stateful_Protocol_Verification</a> &nbsp;
</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,126 @@
<!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 class="mathjax_ignore">
<table width="100%">
<tbody>
<tr>
<!-- Navigation -->
<td width="20%" align="center" valign="top">
<p>&nbsp;</p>
<a href="https://www.isa-afp.org/">
<img src="images/isabelle.png" width="100" height="88" border=0>
</a>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table class="nav" width="80%">
<tr>
<td class="nav" width="100%"><a href="index.html">Home</a></td>
</tr>
<tr>
<td class="nav"><a href="about.html">About</a></td>
</tr>
<tr>
<td class="nav"><a href="submitting.html">Submission</a></td>
</tr>
<tr>
<td class="nav"><a href="updating.html">Updating Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="using.html">Using Entries</a></td>
</tr>
<tr>
<td class="nav"><a href="search.html">Search</a></td>
</tr>
<tr>
<td class="nav"><a href="statistics.html">Statistics</a></td>
</tr>
<tr>
<td class="nav"><a href="topics.html">Index</a></td>
</tr>
<tr>
<td class="nav"><a href="download.html">Download</a></td>
</tr>
</table>
<p>&nbsp;</p>
<p>&nbsp;</p>
</td>
<!-- Content -->
<td width="80%" valign="top">
<div align="center">
<p>&nbsp;</p>
<h1><font class="first">R</font>eferring to
<font class="first">A</font>FP
<font class="first">E</font>ntries
</h1>
<p>&nbsp;</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 Isabelle2020, 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>
+If you are using Isabelle2021, and have downloaded your AFP directory to
+<code>/home/myself/afp</code>, for Linux/Mac you can run the following command to make the AFP session ROOTS available to Isabelle:</p>
<p>
<pre class="code">
- echo "/home/myself/afp/thys" >> ~/.isabelle/Isabelle2020/ROOTS
+ echo "/home/myself/afp/thys" >> ~/.isabelle/Isabelle2021/ROOTS
</pre>
+This adds the path <code>/home/myself/afp/thys/</code> to the ROOTS file, which
+Isabelle will scan by default. You can also manually edit and/or create that
+ROOTS file. There are many other ways to achieve the same outcome, this is just
+one option.
+</p>
+<p>
+For Windows, the idea is the same just the path is slightly different. If the
+AFP is in <code>C:\afp</code>, you should be able to run the following in a
+Cygwin terminal.
+<pre class="code">
+ echo "/cygdrive/c/afp/thys" >> ~/.isabelle/Isabelle2021/ROOTS
+</pre>
+</p>
<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>&nbsp;</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 6, 9:51 PM (1 d, 23 h)
Storage Engine
chunks
Storage Format
Chunks
Storage Handle
OSwPl76xpTwf
Default Alt Text
(5 MB)

Event Timeline